TICS

(define (smooth input-stream)
  (let ((avpt (/ (+ (stream-car input-stream)
                    (stream-car (stream-cdr input-stream)))
                 2)))
    (cons-stream avpt
                 (smooth (stream-cdr input-stream)))))

(define input-example (cons-stream 1 (cons-stream 2 (cons-stream 3 (cons-stream 4 nil)))))

(define (make-zero-crossings input-stream last-value smooth)
  (smooth (cons-stream last-value input-stream)))

(define (make-zero-crossings input-stream last-value last-avpt)
  (let ((avpt (/ (+ last-value (stream-car input-stream)) 2)))
    (cons-stream (sign-change-detector avpt last-avpt)
                 (make-zero-crossings (stream-cdr input-stream)
                                      (stream-car input-stream)
                                      avpt))))

(define (make-zero-crossings input-stream last-value)
  (cons-stream
   (sign-change-detector (stream-car input-stream) last-value)
   (make-zero-crossings (stream-cdr input-stream)
                        (stream-car input-stream))))

(define zero-crossings (make-zero-crossings sense-data 0))

(define zero-crossings
  (stream-map sign-change-detector
              sense-data
              (cons-stream 0 sense-data)))

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

(define (RC R C dt)
  (lambda (i v0)
    (define v
      (add-streams (integral (scale-stream i (/ 1.0 C)) v0 dt)
                   (scale-stream i R)))
    v))

(define RC1 (RC 5 1 0.5))

(define (weight-sum-squares pair)
  (let ((i (car pair))
        (j (cadr pair)))
    (+ (* i i) (* j j))))

(define sum-squares
  (weighted-pairs integers integers weight-sum-squares))

(define (iter-sq pairs weight)
  (let ((car-pairs (stream-car pairs))
        (cadr-pairs (stream-car (stream-cdr pairs)))
        (caddr-pairs (stream-car (stream-cdr (stream-cdr pairs))))
        (cdddr-pairs (stream-cdr (stream-cdr (stream-cdr pairs)))))
    (cond ((stream-null? pairs) nil)
          ((= (weight car-pairs)
              (weight cadr-pairs)
              (weight caddr-pairs))
           (cons-stream (list (weight car-pairs)
                              car-pairs
                              cadr-pairs
                              caddr-pairs)
                        (iter-sq cdddr-pairs weight)))
          (else (iter-sq (stream-cdr pairs) weight)))))

(define 3way-square-numbers  
  (iter-sq sum-squares weight-sum-squares))

(display-stream 3way-square-numbers 6)
(325 (1 18) (6 17) (10 15))
(425 (5 20) (8 19) (13 16))
(650 (5 25) (11 23) (17 19))
(725 (7 26) (10 25) (14 23))
(845 (2 29) (13 26) (19 22))
(850 (3 29) (11 27) (15 25))

(define (weight-sum-cubes pair)
  (let ((i (car pair))
        (j (cadr pair)))
    (+ (* i i i) (* j j j))))

(define sum-cubes
  (weighted-pairs integers integers weight-sum-cubes))

(define (iter pairs weight)
  (let ((car-pairs (stream-car pairs))
        (cadr-pairs (stream-car (stream-cdr pairs)))
        (cddr-pairs (stream-cdr (stream-cdr pairs))))
    (cond ((stream-null? pairs) nil)
          ((= (weight car-pairs)
              (weight cadr-pairs))
           (cons-stream (list (weight car-pairs) car-pairs cadr-pairs)
                        (iter cddr-pairs weight)))
          (else (iter (stream-cdr pairs) weight)))))

(define ramanujan-numbers  
  (iter sum-cubes weight-sum-cubes))

(display-stream ramanujan-numbers 6)
(1729 (1 12) (9 10))
(4104 (2 16) (9 15))
(13832 (2 24) (18 20))
(20683 (10 27) (19 24))
(32832 (4 32) (18 30))
(39312 (2 34) (15 33))

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

(define (weighted-pairs s t weight)
  (cons-stream
   (list (stream-car s) (stream-car t))
   (merge-weighted
    (stream-map (lambda (x) (list (stream-car s) x))
                (stream-cdr t))
    (weighted-pairs (stream-cdr s) (stream-cdr t) weight)
    weight)))

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

(define (stream-for-each proc s n)
  (cond ((stream-null? s) (newline))
        ((= n 0) (newline))
        (else (begin (proc (stream-car s))
                     (stream-for-each proc (stream-cdr s) (- n 1))))))

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

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

(define (accumulated pair)
  (let ((i (car pair))
        (j (cadr pair)))
    (+ i j)))

(define accumulated-pairs
  (weighted-pairs integers integers accumulated))

(display-stream accumulated-pairs 10)
(1 1)
(1 2)
(1 3)
(2 2)
(1 4)
(2 3)
(1 5)
(2 4)
(3 3)
(1 6)

(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)))))

(define (divisible? n)
  (or (= 0 (remainder n 2))
      (= 0 (remainder n 3))
      (= 0 (remainder n 5))))

(define (weight-non-divisible pair)
  (let ((i (car pair))
        (j (cadr pair)))
    (+ (* 2 i) (* 3 j) (* 5 i j))))

(define non-divisible
  (stream-filter (lambda (x) (not (divisible? x))) integers))

(define non-divisible-pairs
  (weighted-pairs non-divisible non-divisible weight-non-divisible))

(display-stream non-divisible-pairs 10)
(1 1)
(1 7)
(1 11)
(1 13)
(1 17)
(1 19)
(1 23)
(1 29)
(1 31)
(7 7)