Tags SICP

The code for this section is in Common Lisp.

#### Exercise 3.63

It is less efficient because it involves a recursive function call, which isn’t optimized by `memo-proc`. This call recurses back on `sqrt-stream` for each new element forced.

#### Exercise 3.64

I’ll define a helper procedure first. It should be familiar from conventional list processing:

```(defun stream-cadr (s)
(stream-car (stream-cdr s)))
```

Now:

```(defun stream-limit (s tolerance)
(if (<
(abs (- (stream-car s) (stream-cadr s)))
tolerance)
(stream-limit (stream-cdr s) tolerance)))
```

#### Exercise 3.65

First, the approxumation function:

```(defun ln2-summands (n)
(cons-stream
(/ 1.0 n)
(stream-map #'- (ln2-summands (1+ n)))))

(deflex ln2-stream
(partial-sums (ln2-summands 1)))
```

This converges slowly:

```(display-n-stream-elements ln2-stream 10)
=>
1.0
0.5
0.8333334
0.5833334
0.78333336
0.6166667
0.7595238
0.6345238
0.7456349
0.6456349
```

Now, with Euler’s acceleration:

```(display-n-stream-elements
(euler-transform ln2-stream)
10)
=>
0.70000005
0.69047624
0.6944445
0.6924243
0.69358975
0.69285715
0.69334733
0.6930033
0.69325393
0.69306576
```

Indeed, much quicker (the real value of `ln2` is 0.693147181056). When accelerated using the tableau method, however, the values become accurate very rapidly:

```(display-n-stream-elements
(accelerated-sequence
#'euler-transform ln2-stream) 7)
=>
1.0
0.70000005
0.69327736
0.6931489
0.6931472
0.6931472
0.6931471
```

#### Exercise 3.66

`pairs` gives the first pair, and then interleaves the elements of the second stream with the head of the first, with a recursive call on itself with the tails of both streams. So, in examining the sequence we can “peel off” sub-sequences. Here are the first 10 pairs:

```(1 1)
(1 2)
(2 2)
(1 3)
(2 3)
(1 4)
(3 3)
(1 5)
(2 4)
(1 6)
```

Notice that after the initial `(1 1)`, `(1 n)` appears every second element. This is because the nature of the `interleave` function. So we can already say that `(1 100)` will take 198 elements to show up, because `(1 n)` appears on position `2n-2`. The next task is more tricky. It will help to look at the stream with all the `(1 n)` pairs peeled off:

```(2 2)
(2 3)
(3 3)
(2 4)
(3 4)
(2 5)
(4 4)
(2 6)
(3 5)
(2 7)
```

Looks familiar, doesn’t it ? Again, `(2 n)` now appears every second element. But recall that we took `(1 n)` away, and two of these squeeze between each pair of `(2 n)`. Therefore, `(2 n)` come in steps of 4 in the `pairs` stream. Similarly, `(3 n)` come in steps of 8. Overall, `(m n)` is the n-th element of `2^m` apart, or approximately `n*2^m`.

#### Exercise 3.67

```(defun all-pairs (s1 s2)
(cons-stream
(list (stream-car s1) (stream-car s2))
(interleave
(stream-map
(lambda (x) (list (stream-car s1) x))
(stream-cdr s2))
(interleave
(stream-map
(lambda (x) (list x (stream-car s2)))
(stream-cdr s1))
(all-pairs (stream-cdr s1) (stream-cdr s2))))))
```

#### Exercise 3.68

Calling Louis’s `pairs` will cause an infinite loop, because there’s no delayed definition like we’re used to have with streams. `interleave` evaluates its second argument, which is a recursive call to `pairs`, which in turn calls itself again and again. In the original version, `interleave` is called through `cons-stream` that doesn’t actually evaluate it until asked for the next element.

#### Exercise 3.69

Conceptually, we can think of triplets recursively in terms of pairs. If we take the first element of the first stream, and enumerate all the pairs taken from the other two streams with this element prepended, and repeat this procedure for every element in the first stream, we will eventually enumerate all triplets. Perhaps the code will be clearer than the explanation :-)

```(defun triplets (s1 s2 s3)
(cons-stream
(list
(stream-car s1)
(stream-car s2)
(stream-car s3))
(interleave
(stream-map
(lambda (x) (append (list (stream-car s1)) x))
(stream-cdr (pairs s2 s3)))
(triplets
(stream-cdr s1)
(stream-cdr s2)
(stream-cdr s3)))))
```

Note that I’m taking the `stream-cdr` or `pairs`, to skip the first pair which is already present in the first element given to `cons-stream`.

To generate the Pythagorean triplets:

```(deflex ppp (triplets integers integers integers))

(deflex pythagorean
(stream-filter
(lambda (triplet)
(=
(+  (square (car triplet))
ppp))

(display-n-stream-elements pythagorean 20)
=>
(3 4 5)
(6 8 10)
...
```

#### Exercise 3.70

```(defun merge-weighted (weight s1 s2)
(cond
((stream-null? s1) s2)
((stream-null? s2) s1)
(t
(let* ( (s1car (stream-car s1))
(s1w (funcall weight s1car))
(s2car (stream-car s2))
(s2w (funcall weight s2car)))
(cond ((<= s1w s2w)
(cons-stream s1car (merge-weighted weight (stream-cdr s1) s2)))
(t
(cons-stream s2car (merge-weighted weight s1 (stream-cdr s2)))))))))

(defun weighted-pairs (weight s1 s2)
(cons-stream
(list (stream-car s1) (stream-car s2))
(merge-weighted
weight
(stream-map
(lambda (x) (list (stream-car s1) x))
(stream-cdr s2))
(weighted-pairs weight (stream-cdr s1) (stream-cdr s2)))))
```

Note that `merge-weighted` is a bit different from the original `merge`. The original `merge` is supposed to merge elements which may be equal. In such case, it will leave only one of those elements in the result stream (removing duplications). On the other hand, we are merging according to weight, and we can’t allow one of the pairs `(2 3)` and `(1 4)` to disappear just because they have the same weight, so we must merge in both.

a.

```(deflex sump
(weighted-pairs
(lambda (pair) (apply #'+ pair))
integers
integers))

(display-n-stream-elements sump 10)
=>
(1 1)
(1 2)
(1 3)
(2 2)
(1 4)
(2 3)
(1 5)
(3 3)
(2 4)
(1 6)
```

b.

```(deflex no-235-factors
(stream-filter
(lambda (n)
(not (or  (divides? 2 n)
(divides? 3 n)
(divides? 5 n))))
integers))

(deflex s235
(weighted-pairs
(lambda (pair)
(let ((i (car pair)) (j (cadr pair)))
(+ (* 2 i) (* 3 j) (* 5 i j))))
no-235-factors
no-235-factors))

(display-n-stream-elements s235 20)
=>
(1 1)
(1 7)
(1 11)
(1 13)
(1 17)
(1 19)
(1 23)
(1 29)
(1 31)
(7 7)
(1 37)
(1 41)
(1 43)
(1 47)
(1 49)
(1 53)
(7 11)
(1 59)
(1 61)
(1 67)
```

#### Exercise 3.71

```(defun ij-cube (pair)
(+ (cube (car pair)) (cube (cadr pair))))

(deflex cubew
(weighted-pairs
#'ij-cube
integers
integers))

(defun ramanujan (stream max-count)
(do* ((s stream (stream-cdr s))
(count 1))
(nil)
(if (= (ij-cube (stream-car s)) (ij-cube (stream-cadr s)))
(if (> count max-count)
(return)
(progn
(incf count)
(format t "~a~%"
(list (ij-cube (stream-car s))
(stream-car s)

(ramanujan cubew 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))
```

#### Exercise 3.72

This is very similar to the previous exercise:

```(defun ij-square (pair)
(+ (square (car pair)) (square (cadr pair))))

(deflex squarew
(weighted-pairs
#'ij-square
integers
integers))

(defun squares-3ways (stream max-count)
(do* ((s stream (stream-cdr s))
(count 1))
(nil)
(let ((a (stream-car s))
(if (= (ij-square a) (ij-square b) (ij-square c))
(if (> count max-count)
(return)
(progn
(incf count)
(format t "~a~%"
(list (ij-square a) a b c))))))))

(squares-3ways squarew 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))
```

I suppose this could be generalized in some way: “find all numbers that can be written as a f(i,j) of `i` and `j` in `n` different ways”. This will be left as an exercise to the diligent readers :-)

#### Exercise 3.73

First of all, I want to show how `integral` is implemented in Common Lisp. It is done a bit differently from Scheme, because it touches one of the points of difference between these two languages. In Scheme, variables and functions reside in the same namespace, while Common Lisp has separate namespaces for them4.

Therefore, Common Lisp can’t treat variables the same way it treats functions, while Scheme can. Particularly, recursive definitions of variables are not as universal in Common Lisp. Scheme can use `define` to define recursive variables, and it can use `letrec` to do it locally. Common Lisp can’t5. What Common Lisp can do, however, is look at such variables explicitly as functions:

```(defun integral (integrand initial-value dt)
(labels (
(int ()
(cons-stream
initial-value
(int)))
```

This works just fine because, if you come to think of it, there isn’t much of a difference between evaluating a variable for its value and calling a parameter-less function for its return value.

Now, to the `RC` circuit:

```(defun RC (R C dt)
(labels (
(rc-model (v0 i-stream)
(scale-stream i-stream R)
(integral
(scale-stream i-stream (/ 1 C))
v0
dt))))
#'rc-model))
```

#### Exercise 3.74

I’m pretty sure that what is expected as an answer here is:

```(deflex zero-crossings
(stream-map
#'sign-change-detector
sense-data
(stream-cdr sense-data)))
```

However, there is a problem with this function. It is non-causal – a term in the study of signals and systems which describes functions that foresee future values. For instance, for the stream: `(1 2 -5 -6)` it produces `(0 -1 0 1)`. Note the -1 in the result, it comes at an earlier point of time than -5 in the input. This isn’t a physical system! It would probably be more correct to implement it as:

```(deflex zero-crossings
(stream-map
#'sign-change-detector
(cons-stream 0 sense-data)
sense-data))
```

#### Exercise 3.75

The fallacy in Louis’s code is using the output values for the averaging. To make it right, the averaging must take only elements of input into account.

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

Note the clear separation of inputs and outputs here. `last-value` is only for the inputs, and it is used in the computation of the next `avpt`. `last-avpt` keeps track of the outputs for sign change detection.

#### Exercise 3.76

Here’s the smoothing function:

```(defun smooth (s)
(stream-map
(lambda (x1 x2) (/ (+ x1 x2) 2))
(cons-stream 0 s)
s))
```

It would be most modular to plug it in as follows:

```(defun make-zero-crossings (in transform)
(let ((smoothed-in (funcall transform in)))
(stream-map
#'sign-change-detector
(cons-stream 0 smoothed-in)
smoothed-in)))

(deflex sm-zero-crossings
(make-zero-crossings sense-data #'smooth))
```

1 Defined by the authors in exercise 3.51

2 `deflex` is explained here

3 This is a simplified view of a complex reality. However, I don’t intend to teach macros here – there are enough Lisp resources online for that. Macros are a tricky business – I must confess I don’t fully master their use myself yet.

4 This is, of course, the reason for the need to use `funcall` and `#'` in Common Lisp, which don’t exist in Scheme.

5 Well, not exactly. It works for some extent with `defvar`, but `defvar` is actually a macro which bends some of the rules, and works only for “toplevel” variables.