#+TITLE: 3.5 - Streams

#+BEGIN_HTML
  <script type="text/javascript"
          src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
  </script>
#+END_HTML

* Streams are Delayed Lists
#+begin_src scheme
  (define (cons-stream a b)
    (cons a (delay b)))

  (define (stream-car s)
    (car s))

  (define (stream-cdr s)
    (force (cdr s)))

  (define the-empty-stream '())

  (define (stream-ref s n)
    (if (= n 0)
        (stream-car s)
        (stream-ref (stream-cdr s) (- n 1))))

  (define (stream-map proc s)
    (if (stream-null? s)
        the-empty-stream
        (cons-stream (proc (stream-car s))
                     (stream-map proc (stream-cdr s)))))

  (define (stream-for-each proc s)
    (if (stream-null? s)
        'done
        (begin (proc (stream-car s))
               (stream-for-each proc (stream-cdr s)))))
#+end_src

#+begin_src scheme :tangle yes
  ;; ===================================================================
  ;; 3.5.1: Streams are Delayed Lists
  ;; ===================================================================

  (define (display-stream s)
    (stream-for-each display-line s))

  (define (display-line x)
    (newline)
    (display x))

  (define (stream-enumerate-interval low high)
    (if (> low high)
        the-empty-stream
        (cons-stream
         low
         (stream-enumerate-interval (+ low 1) high))))

  (define (stream-filter pred stream)
    (cond ((stream-null? stream) the-empty-stream)
          ((pred (stream-car stream))
           (cons-stream (stream-car stream)
                        (stream-filter pred
                                       (stream-cdr stream))))
          (else (stream-filter pred (stream-cdr stream)))))

  #+end_src

** Exercise 3.50
Complete the following definition, which generalizes `stream-map' to
allow procedures that take multiple arguments, analogous to `map' in
section *Note 2-2-3::, footnote *Note Footnote 12::.

#+begin_src scheme
  (define (stream-map proc . argstreams)
    (if (<??> (car argstreams))
        the-empty-stream
        (<??>
         (apply proc (map <??> argstreams))
         (apply stream-map
                (cons proc (map <??> argstreams))))))
#+end_src

----------------------------------------------------------------------

#+begin_src scheme
  ;; -------------------------------------------------------------------
  ;; Exercise 3.50
  ;; -------------------------------------------------------------------

  (define (stream-map proc . argstreams)
    (if (stream-null? (car argstreams))
        the-empty-stream
        (cons-stream
         (apply proc (map stream-car argstreams))
         (apply stream-map
                (cons proc (map stream-cdr argstreams))))))
#+end_src

** Exercise 3.51
In order to take a closer look at delayed
evaluation, we will use the following procedure, which simply
returns its argument after printing it:

#+begin_src scheme
  (define (show x)
    (display-line x)
    x)
#+end_src

What does the interpreter print in response to evaluating each
expression in the following sequence?(7)

#+begin_src scheme
  (define x (stream-map show (stream-enumerate-interval 0 10)))

  (stream-ref x 5)

  (stream-ref x 7)
#+end_src scheme

----------------------------------------------------------------------

#+begin_src scheme
  (define x (stream-map show (stream-enumerate-interval 0 10)))
  ; 9
  ; 8
  ; 7
  ; 6
  ; 5
  ; 4
  ; 3
  ; 2
  ; 1
  ; 0
  ;Value: x
   
  (stream-ref x 5)
  ;Value: 5

  (stream-ref x 7)
  ;Value: 7

#+end_src
** Exercise 3.52
Consider the sequence of expressions

#+begin_src scheme
     (define sum 0)

     (define (accum x)
       (set! sum (+ x sum))
       sum)

     (define seq (stream-map accum (stream-enumerate-interval 1 20)))
     (define y (stream-filter even? seq))
     (define z (stream-filter (lambda (x) (= (remainder x 5) 0))
                              seq))

     (stream-ref y 7)

     (display-stream z)
#+end_src

What is the value of `sum' after each of the above expressions is
evaluated?  What is the printed response to evaluating the
`stream-ref' and `display-stream' expressions?  Would these responses
differ if we had implemented `(delay <EXP>)' simply as `(lambda ()
<EXP>)' without using the optimization provided by `memo-proc'?
Explain

----------------------------------------------------------------------

#+begin_example
  1 ]=> sum
  ;Value: 210

  1 ]=> (stream-head y 10)

  ;Value 18: (210 204 200 182 174 144 132 90 74 20)

  1 ]=> (display-stream z)

  210
  200
  195
  165
  155
  105
  90
  20
  ;Value: done
#+end_example

After the definition of =seq=, =sum= is equal to 210. It remains at
210 through the remainder of the operations.This would not be the
case if delay were not memoized, as without being so it would be
recalculated each time the items in the node were resolved, adding to
the value of =sum= each time, and changing the results captured by =y=
and =z=.
* 3.5.2 Infinite Streams
#+begin_src scheme :tangle yes
  ;; ===================================================================
  ;; 3.5.2: Infinite Streams
  ;; ===================================================================

  (define (integers-starting-from n)
    (cons-stream n (integers-starting-from (+ n 1))))

  (define integers (integers-starting-from 1))

  (define (divisible? x y) (= (remainder x y) 0))

  (define no-sevens
    (stream-filter (lambda (x) (not (divisible? x 7)))
                   integers))

  (define (fibgen a b)
    (cons-stream a (fibgen b (+ a b))))

  (define fibs (fibgen 0 1))

  (define (sieve stream)
    (cons-stream
     (stream-car stream)
     (sieve (stream-filter
             (lambda (x)
               (not (divisible? x (stream-car stream))))
             (stream-cdr stream)))))

  (define primes (sieve (integers-starting-from 2)))
#+end_src
** Defining streams implicitly
#+begin_src scheme :tangle yes
  (define ones (cons-stream 1 ones))

  (define (add-streams s1 s2)
    (stream-map + s1 s2))

  (define integers (cons-stream 1 (add-streams ones integers)))

  (define fibs
    (cons-stream 0
                 (cons-stream 1
                              (add-streams (stream-cdr fibs)
                                           fibs))))
  (define (scale-stream stream factor)
    (stream-map (lambda (x) (* x factor)) stream))

  (define double (cons-stream 1 (scale-stream double 2)))

  (define primes
    (cons-stream
     2
     (stream-filter prime? (integers-starting-from 3))))

  (define (prime? n)
    (define (iter ps)
      (cond ((> (square (stream-car ps)) n) true)
            ((divisible? n (stream-car ps)) false)
            (else (iter (stream-cdr ps)))))
    (iter primes))
#+end_src
*** Exercise 3.53
Without running the program, describe the elements of the stream
defined by

#+begin_src scheme
  (define s (cons-stream 1 (add-streams s s)))
#+end_src

----------------------------------------------------------------------

\[
\sum_{i=1}^\infty 2^i
\]
*** Exercise 3.54
Define a procedure `mul-streams', analogous to `add-streams', that
produces the elementwise product of its two input streams.  Use this
together with the stream of `integers' to complete the following
definition of the stream whose nth element (counting from 0) is n + 1
factorial:

#+begin_src scheme
  (define factorials (cons-stream 1 (mul-streams <??> <??>)))
#+end_src

----------------------------------------------------------------------

#+begin_src scheme :tangle yes
  (define (mul-streams s1 s2)
    (stream-map * s1 s2))

  (define factorials (cons-stream 1 (mul-streams (add-streams ones integers) factorials)))
#+end_src
*** Exercise 3.55
Define a procedure `partial-sums' that takes as argument a stream S
and returns the stream whose elements are S_0, S_0 + S_1, S_0 + S_1 +
S_2, ....  For example, `(partial-sums integers)' should be the stream
1, 3, 6, 10, 15, ....