Comments on: SICP section 3.5.3

By: José Hérnandez

José Hérnandez — Fri, 29 May 2009 16:24:02 +0000

In exercise 3.76, it might be more correct to write the smooth function as follows:

(define (smooth-stream stream)
(define (avg a b) (/ (+ a b) 2.0))
(stream-map2 avg stream (stream-cdr stream)))

This approach doesn’t require introducing a zero at the beginning of the stream, since technically smoothing shouldn’t do so. It’s only in zero-crossings that prepending a zero is needed.

By: Ray Bai

Ray Bai — Wed, 18 Mar 2009 14:17:40 +0000

Sorry I made a mistake. It shouldn’t work.

By: Ray Bai

Ray Bai — Wed, 18 Mar 2009 13:41:49 +0000

The code in exercise 3.68 actually works.

Although interleave isn’t called withn cons-stream, it contains cons-stream itself.

By: eliben

eliben — Sun, 13 Jul 2008 16:06:22 +0000

Sigrid,
Stream operations are memoized with memo-proc, but simple recursive function calls are not. The new implementation in exercise 3.63 involves a recursive call which isn’t being optimized by memo-proc.

By: Sigrid

Sigrid — Fri, 11 Jul 2008 06:12:19 +0000

Hi Eli,

first of all, thanks so much for posting the SICP solutions on the web! They are extremely valuable for me, reading SICP as a complete autodidact who made her way into (Java) software development completely on her own without attending any informatics curriculum (unfortunately!).

If you like, could you explain the solution for 3.63 a little more? I think a got a basic grep on memoization by drawing the environment diagram in ex. 3.27, but in the context of streams I’m not really sure about what exactly is being memoized and how this works (I did not really manage to draw the environment diagram for this…)

Also, I added a logging message to memo-proc, like this:

(define memo-proc
(lambda (p)
(let ((already-run? #f) (result #f))
(lambda ()
(if (not already-run?)
(begin (set! result (p))
(set! already-run? #t)
result)
(begin (display-line (list ‘already-computed: result))
result))))))

… and I get the same output for both versions:

1.0
1.5
(already-computed: (1.5 . #))
1.4166666666666665
(already-computed: (1.4166666666666665 . #))
1.4142156862745097….

Just in case it matters, that’s how I defined delay:

(define-syntax delay
(syntax-rules ()
((_ expr)
(memo-proc (lambda () expr)))))

best greetings,
Sigrid