TICS

(define (integral delayed-integrand initial-value dt)
  (cons-stream initial-value
               (let ((integral (force delayed-integral)))
                 (if (stream-null? integrand)
                     the-empty-stream
                     (integral (delay (stream-cdr integrand))
                               (+ (* dt (stream-car integrand))
                                  initial-value)
                               dt)))))

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