3.53 ~ 3.54 sicp

stream.scm

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

(define s (cons-stream 1 (add-stream s s)))
(stream-ref s 2)

(stream-ref s 5)

(define (mul-stream s1 s2)
  (stream-map * s1 s2))

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

(stream-ref integers 4)

(define factorials (cons-stream 1 (mul-stream factorials (stream-cdr integers))))

(stream-ref factorials 4)

(define partial-sum (cons-stream 1 (add-stream partial-sum (stream-cdr integers))))

(stream-ref partial-sum 3)

(define (scale-stream stream factor)
  (stream-map (lambda (x) (* factor x)) stream))

(define (merge s1 s2)
  (cond ((stream-null? s1) s2)
        ((stream-null? s2) s1)
        (else
         (let ((s1car (stream-car s1))
               (s2car (stream-car s2)))
           (cond ((< s1car s2car)
                  (cons-stream s1car (merge (stream-cdr s1) s2)))
                 ((< s2car s1car)
                  (cons-stream s2car (merge (stream-cdr s2) s1)))
                 (else
                  (cons-stream s1car (merge (stream-cdr s1) (stream-cdr s2)))))))))


(define S (cons-stream 1 (merge (scale-stream S 2)
                                (merge (scale-stream S 3) (scale-stream S 5)))))

;; 3.59
(define inverse (stream-map (lambda (x y) (/ x y)) ones integers))

(define (integrate-series stream)
  (stream-map (lambda x y) (* x y) inverse stream))

(define sine-series (cons-stream 0 (integrate-series cosine-series)))
(define cosine-series (cons-stream 1 (integrate-series (scale-stream sine-series -1))))

;; 3.60
(define (mul-stream s1 s2)
  (cons-stream (* (stream-car s1) (stream-car s2))
               (add-stream (scale-stream (stream-cdr s2) (stream-car s1))
                           (mul-stream s2 (stream-cdr s1)))))

(define s3 (+ (mul-stream sine-series sine-series)
              (mul-stream cosine-series cosine-series)))

;; 3.61
(define (invert-unit-series S)
  (cons-stream 1 (scale-stream (mul-stream (stream-cdr S) (invert-unit-series S))
                               -1)))

;; 3.63
(define (average x y)
  (/ (+ x y) 2))

(define (sqrt-improve guess x)
  (average guess (/ x guess)))

(define (sqrt-stream x)
  (define guesses
    (cons-stream 1.0
                 (stream-map (lambda (guess)
                               (sqrt-improve guess x))
                             guesses)))
  guesses)

(define sqrt-two (sqrt-stream 2))
(stream-ref sqrt-two 6)

(define (less-efficient-sqrt-stream x)
  (cons-stream 1.0
               (stream-map (lambda (guess)
                             (sqrt-improve guess x))
                           (less-efficient-sqrt-stream x))))

;; 3.64
(define (stream-limit stream tolerance)
  (let ((s0 (stream-car stream))
        (s1 (stream-car (stream-cdr stream))))
    (let ((difference (abs (- s0 s1))))
      (cond ((< difference tolerance) s1)
            (else
             (stream-limit (stream-cdr stream) tolerance))))))

(define (sqrt x tolerance)
  (stream-limit (sqrt-stream x) tolerance))


;; 3.65
(define (pi-summands n)
  (cons-stream (/ 1.0 n)
               (stream-map - (pi-summands (+ n 2)))))

(define (log-two-summands n)
  (cons-stream (/ 1.0 n)
               (stream-map - (log-two-summands (+ n 1)))))

(define (partial-sums stream)
  (cons-stream (stream-car stream)
               (stream-map (lambda (x) (+ x (stream-car stream)))
                           (partial-sums (stream-cdr stream)))))

(define integers-sum (partial-sums integers))

(stream-ref integers-sum 3)

(define log-two-stream
  (partial-sums (log-two-summands 1)))

(stream-ref log-two-stream 1000)

;; 3.67
(define (all-pairs s t)
  (cons-stream 
   (list (stream-car s) (stream-car t))
   (interleave
    (interleave
     (stream-map (lambda (x) (list (stream-car s) x))
                 (stream-cdr t))
     (all-pairs (stream-cdr s) (stream-cdr t)))
    (stream-map (lambda (x) (list x (stream-car t)))
                (stream-cdr s)))))

(define (integral integrand initial-value dt)
  (define int
    (cons-stream initial-value
                 (add-streams (scale-stream integrand dt)
                              int)))
  int)


;; 3.73
(define (rc r c dt)
  (lambda (current v0)
    (add-stream (scale-stream current r)
                (integral (scale-stream current (/ 1.0 c)) v0 dt))))

;; 3.74
(define zero-crossings
  (stream-map sign-change-detector sense-data (cons-stream last-value sense-data)))


;;
(define (integral delayed-integrand initial-value dt)
  (define int
    (cons-stream initial-value
                 (let ((integrand (force delayed-integrand)))
                   (add-streams (scale-stream integrand dt)))))
  int)


(define (solve f y0 dt)
  (define y (integral (delay dy) y0 dt))
  (define dy (stream-map f y))
  y)