欲說還休

Hierarchical Data and the Closure Property

Mon, 02 Jan 2017 00:00:00 +0000

Section 2.2 Hierarchical Data and the Closure Property

Exercises in this section of SCIP.

Exercise 2.17. Define a procedure last-pair that returns the list that contains only the last element of a given (nonempty) list:

(last-pair (list 23 72 149 34))
(34)

Answer 2.17.

(define (last-pair items)
    (if (null? (cdr items))
        items
        (last-pair (cdr items))
    )
)

Exercise 2.18. Define a procedure reverse that takes a list as argument and returns a list of the same elements in reverse order:

(reverse (list 1 4 9 16 25))
(25 16 9 4 1)

Answer 2.18.

(define (reverse items)
    (if (null? (cdr items))
        items
        (append (reverse (cdr items)) (cons (car items) ()))
    )
)

Exercise 2.19. Consider the change-counting program of section 1.2.2. It would be nice to be able to easily change the currency used by the program, so that we could compute the number of ways to change a British pound, for example. As the program is written, the knowledge of the currency is distributed partly into the procedure first-denomination and partly into the procedure count-change (which knows that there are five kinds of U.S. coins). It would be nicer to be able to supply a list of coins to be used for making change.

We want to rewrite the procedure cc so that its second argument is a list of the values of the coins to use rather than an integer specifying which coins to use. We could then have lists that defined each kind of currency:

(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))

We could then call cc as follows:

(cc 100 us-coins)
292

To do this will require changing the program cc somewhat. It will still have the same form, but it will access its second argument differently, as follows:

(define (cc amount coin-values)
  (cond ((= amount 0) 1)
        ((or (< amount 0) (no-more? coin-values)) 0)
        (else
         (+ (cc amount
                (except-first-denomination coin-values))
            (cc (- amount
                   (first-denomination coin-values))
                coin-values)))))

Define the procedures first-denomination, except-first-denomination, and no-more? in terms of primitive operations on list structures. Does the order of the list coin-values affect the answer produced by cc? Why or why not?

Answer 2.19.

(define (cc amount coin-values)
  (cond ((= amount 0) 1)
        ((or (< amount 0) (no-more? coin-values)) 0)
        (else
         (+ (cc amount
                (except-first-denomination coin-values))
            (cc (- amount
                   (first-denomination coin-values))
                coin-values)))))

(define (no-more? coin-values)
    (null? coin-values)
)

(define (except-first-denomination coin-values)
    (cdr coin-values)
)

(define (first-denomination coin-values)
    (car coin-values)
)

(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))

(cc 100 us-coins)

Exercise 2.20. The procedures +, *, and list take arbitrary numbers of arguments. One way to define such procedures is to use define with dotted-tail notation. In a procedure definition, a parameter list that has a dot before the last parameter name indicates that, when the procedure is called, the initial parameters (if any) will have as values the initial arguments, as usual, but the final parameter’s value will be a list of any remaining arguments. For instance, given the definition

(define (f x y . z) )

the procedure f can be called with two or more arguments. If we evaluate

(f 1 2 3 4 5 6)

then in the body of f, x will be $1$, y will be $2$, and z will be the list (3 4 5 6). Given the definition

(define (g . w) )

the procedure g can be called with zero or more arguments. If we evaluate

(g 1 2 3 4 5 6)

then in the body of g, w will be the list (1 2 3 4 5 6).

Use this notation to write a procedure same-parity that takes one or more integers and returns a list of all the arguments that have the same even-odd parity as the first argument. For example,

(same-parity 1 2 3 4 5 6 7)
(1 3 5 7)

(same-parity 2 3 4 5 6 7)
(2 4 6)

Answer 2.20.

(define (same-parity first . rest)
    (define (filter x)
        (if (even? x)
            even?
            odd?
        )
    )

    (define (parity f l)
        (cond ((null? l) ())
              ((f (car l)) (cons (car l) (parity f (cdr l))))
              (else (parity f (cdr l)))
        )
    )
    (parity (filter first) rest)
)

Exercise 2.21. The procedure square-list takes a list of numbers as argument and returns a list of the squares of those numbers.

(square-list (list 1 2 3 4))
(1 4 9 16)

Here are two different definitions of square-list. Complete both of them by filling in the missing expressions:

(define (square-list items)
  (if (null? items)
      nil
      (cons  )))
(define (square-list items)
  (map  ))

Answer 2.21.

(define (square-list items)
    (if (null? items)
        `()
        (cons (square (car items)) (square-list (cdr items)))
    )
)

(define (square x) (* x x))

(define (square-list-map items)
    (map square items)
)

Exercise 2.22. Louis Reasoner tries to rewrite the first square-list procedure of exercise 2.21 so that it evolves an iterative process:

(define (square-list items)
  (define (iter things answer)
    (if (null? things)
        answer
        (iter (cdr things) 
              (cons (square (car things))
                    answer))))
  (iter items nil))

Unfortunately, defining square-list this way produces the answer list in the reverse order of the one desired. Why?

Louis then tries to fix his bug by interchanging the arguments to cons:

(define (square-list items)
  (define (iter things answer)
    (if (null? things)
        answer
        (iter (cdr things)
              (cons answer
                    (square (car things))))))
  (iter items nil))

This doesn’t work either. Explain.

Answer 2.22. The first procedure doesn’t work because it constructs the last item from the front of the list to the answer. The second procedure seems right at first glance, but result is:

(square-list (list 1 2 3 4)) ((((() 1) 4) 9) 16)

Let’s look the definition of list:

(list   ... )
(cons  (cons  ... (cons  nil) ... ))

And the substitution of the procedure:

(square-list (list 1 2 3 4))

(iter (list 1 2 3 4) '())

(iter (list 2 3 4) (cons '() (square 1)))

(iter (list 3 4) (cons (cons '() 1)
                       (square 2)))

(iter (list 4)  (cons (cons (cons '() 1) 4)
                      (square 3)))

(iter '() (cons (cons (cons (cons '() 1) 4) 9)
                (square 4)))

(iter '() (cons (cons (cons (cons '() 1) 4) 9) 16))

(cons (cons (cons (cons '() 1) 4) 9) 16)

Therefore, the structure of answer is wrong.

Exercise 2.23. The procedure for-each is similar to map. It takes as arguments a procedure and a list of elements. However, rather than forming a list of the results, for-each just applies the procedure to each of the elements in turn, from left to right. The values returned by applying the procedure to the elements are not used at all – for-each is used with procedures that perform an action, such as printing. For example,

(for-each (lambda (x) (newline) (display x))
          (list 57 321 88))
57
321
88

The value returned by the call to for-each (not illustrated above) can be something arbitrary, such as true. Give an implementation of for-each.

Answer 2.23. I find a feature between cond and if in Lisp. If we want to use if instead of cond, one things should be concerned. Here are definitions:

(cond (  ...)
	  ...
	  (else  ..)
)

(if 
	
	
)

In cond, one clause has one predicate and several expressions, meanwhile consequent and alternative of if only have one expression for each. Thus, in this exercise we should use cond because (newline) and (display x) are two expressions.

(define (for-each f l)
    (cond ((null? l) '()) 
          (else (f (car l))
                (for-each f (cdr l)))
    )
)

Exercise 2.24. Suppose we evaluate the expression (list 1 (list 2 (list 3 4))). Give the result printed by the interpreter, the corresponding box-and-pointer structure, and the interpretation of this as a tree (as in figure 2.6).

Introduction to Data Abstraction

Sat, 31 Dec 2016 00:00:00 +0000

Section 2.1 Introduction to Data Abstraction

Exercises in this section of SCIP.

Exercise 2.1. Define a better version of make-rat that handles both positive and negative arguments. Make-rat should normalize the sign so that if the rational number is positive, both the numerator and denominator are positive, and if the rational number is negative, only the numerator is negative.

Answer 2.1.

(define (numer x) (car x))

(define (denom x) (cdr x))

(define (print-rat x)
    (newline)
    (display (numer x))
    (display "/")
    (display (denom x))
)

(define (make-rat n d)
    (let ((g ((if (< d 0) - +) (abs (gcd n d)))))
        (cons (/ n g) (/ d g))
    )
)

Exercise 2.2. Consider the problem of representing line segments in a plane. Each segment is represented as a pair of points: a starting point and an ending point. Define a constructor make-segment and selectors start-segment and end-segment that define the representation of segments in terms of points. Furthermore, a point can be represented as a pair of numbers: the $x$ coordinate and the $y$ coordinate. Accordingly, specify a constructor make-point and selectors x-point and y-point that define this representation. Finally, using your selectors and constructors, define a procedure midpoint-segment that takes a line segment as argument and returns its midpoint (the point whose coordinates are the average of the coordinates of the endpoints). To try your procedures, you’ll need a way to print points:

(define (print-point p)
  (newline)
  (display "(")
  (display (x-point p))
  (display ",")
  (display (y-point p))
  (display ")"))

Answer 2.2.

(define (x-point x) (car x))

(define (y-point x) (cdr x))

(define (print-point p)
    (newline)
    (display "(")
    (display (x-point p))
    (display ",")
    (display (y-point p))
    (display ")")
)

(define (make-point x y)
    (cons x y)
)

(define (start-segment x) (car x))

(define (end-segment x) (cdr x))

(define (make-segment x y)
    (cons x y)
)

(define (midpoint-segment s)
    (define (average a b) (/ (+ a b) 2.0))
    (let (
            (a (start-segment s))
            (b (end-segment s))
         )
         (make-point (average (x-point a) (x-point b)) (average (y-point a) (y-point b)))
    )
)

Exercise 2.3. Implement a representation for rectangles in a plane. (Hint: You may want to make use of exercise 2.2.) In terms of your constructors and selectors, create procedures that compute the perimeter and the area of a given rectangle. Now implement a different representation for rectangles. Can you design your system with suitable abstraction barriers, so that the same perimeter and area procedures will work using either representation?

Answer 2.3. Here, it talks about axis-aligned rectangles.

(define (x-point x) (car x))

(define (y-point x) (cdr x))

(define (print-point p)
    (newline)
    (display "(")
    (display (x-point p))
    (display ",")
    (display (y-point p))
    (display ")")
)

(define (make-point x y)
    (cons x y)
)

(define (make-rect p1 p2)
    (let (
            (x1 (x-point p1))
            (x2 (x-point p2))
            (y1 (y-point p1))
            (y2 (y-point p2))
         )
         (cond 
            ((and (< x1 x2) (< y1 y2)) (cons p1 p2))
            ((and (> x1 x2) (> y1 y2)) (cons p2 p1))
            ((and (< x1 x2) (> y1 y2)) (cons (make-point (x1 y2)) (make-point (x2 y1))))
            (else (cons (make-point (x2 y1)) (make-point (x1 y2))))
         )
    )
)

(define (bottom-left r) (car r))

(define (top-right r) (cdr r))

(define (print-rect r)
    (print-point (bottom-left r))
    (print-point (top-right r))
)

(define (perimeter r)
    (let (
            (p1 (bottom-left r))
            (p2 (top-right r))
         )
         (let (
                (x1 (x-point p1))
                (x2 (x-point p2))
                (y1 (y-point p1))
                (y2 (y-point p2))
              )
              (* 2 (+ (- x2 x1) (- y2 y1)))
         )
    )    
)

(define (area r)
     (let (
            (p1 (bottom-left r))
            (p2 (top-right r))
         )
         (let (
                (x1 (x-point p1))
                (x2 (x-point p2))
                (y1 (y-point p1))
                (y2 (y-point p2))
              )
              (* (- x2 x1) (- y2 y1))
         )
    )    
)

(define r (make-rect (make-point 1 1)
                     (make-point 4 5)))

Exercise 2.4. Here is an alternative procedural representation of pairs. For this representation, verify that (car (cons x y)) yields $x$ for any objects $x$ and $y$.

(define (cons x y)
  (lambda (m) (m x y)))

(define (car z)
  (z (lambda (p q) p)))

What is the corresponding definition of cdr? (Hint: To verify that this works, make use of the substitution model of section 1.1.5.)

Answer 2.4.

(define (cdr z)
	(z (lambda (p q) q))
)

Substitution model:

=> (cdr z)
=> (z (lambda (p q) p))
=> ((lambda (m) (m x y) (lambda (p q) q)))
=> ((lambda (p q) q) x y)
=> y

Exercise 2.5. Show that we can represent pairs of nonnegative integers using only numbers and arithmetic operations if we represent the pair $a$ and $b$ as the integer that is the product $2^a 3^b$. Give the corresponding definitions of the procedures cons, car, and cdr.

Answer 2.5.

(define (cons a b)
    (* (expt 2 a) (expt 3 b))
)

(define (logb b n) (floor (/ (log n) (log b))))

(define (car x)
    (logb 2 (/ x (gcd x (expt 3 (logb 3 x)))))
)

(define (cdr x)
    (logb 3 (/ x (gcd x (expt 2 (logb 2 x)))))
)

Exercise 2.6. In case representing pairs as procedures wasn’t mind-boggling enough, consider that, in a language that can manipulate procedures, we can get by without numbers (at least insofar as nonnegative integers are concerned) by implementing $0$ and the operation of adding $1$ as

(define zero (lambda (f) (lambda (x) x)))

(define (add-1 n)
  (lambda (f) (lambda (x) (f ((n f) x)))))

This representation is known as Church numerals, after its inventor, Alonzo Church, the logician who invented the $\lambda$ calculus.

Define one and two directly (not in terms of zero and add-1). (Hint: Use substitution to evaluate (add-1 zero)). Give a direct definition of the addition procedure + (not in terms of repeated application of add-1).

Answer 2.6.

=> (one)
=> (add-1 zero)
=> (lambda (f) (lambda (x) (f ((zero f) x))))

zero is a function of one argument, that returns a function of one argument that returns the argument.

=> ((zero f) x)
=> ((lambda(x) x) x)
=> x

So, one and two are:

=> (one)
=> (lambda (f) (lambda (x) (f x)))

=> (two)
=> (add-1 two)
=> (lambda (f) (lambda (x) (f (f x))))

Thus,

(define one (lambda (f) (lambda (x) (f x))))

(define two (lambda (f) (lambda (x) (f (f x)))))

And add using the same approach in add-1:

(define (add a b)
	(lambda (f)
		(lambda (x) (a f) ((b f) x))
	)
)

Exercise 2.7. Alyssa’s program is incomplete because she has not specified the implementation of the interval abstraction. Here is a definition of the interval constructor:

(define (make-interval a b) (cons a b))

Define selectors upper-bound and lower-bound to complete the implementation.

Answer 2.7.

(define (upper-bound interval)
	(max (car interval) (cdr interval))
)

(define (lower-bound interval)
	(min (car interval) (cdr interval))
)

Exercise 2.8. Using reasoning analogous to Alyssa’s, describe how the difference of two intervals may be computed. Define a corresponding subtraction procedure, called sub-interval.

Answer 2.8.

(define (sub-interval x y)
	(make-interval (- (lower-bound x) (upper-bound y))
				   (- (upper-bound x) (lower-bound y)))
)

Exercise 2.9. The width of an interval is half of the difference between its upper and lower bounds. The width is a measure of the uncertainty of the number specified by the interval. For some arithmetic operations the width of the result of combining two intervals is a function only of the widths of the argument intervals, whereas for others the width of the combination is not a function of the widths of the argument intervals. Show that the width of the sum (or difference) of two intervals is a function only of the widths of the intervals being added (or subtracted). Give examples to show that this is not true for multiplication or division.

Answer 2.9. For multiplication and division, the story is different. If the width of the result was a function of the widths of the inputs, then multiplying different intervals with the same widths should give the same answer. For example, multiplying a width 5 interval with a width 1 interval.

Exercise 2.10. Ben Bitdiddle, an expert systems programmer, looks over Alyssa’s shoulder and comments that it is not clear what it means to divide by an interval that spans zero. Modify Alyssa’s code to check for this condition and to signal an error if it occurs.

Answer 2.10. We should guarantee:

$$ R_p = \frac{1}{1/R_1+1/R_2} = \frac{R_1+R_2}{R_1 R_2}, \text{where } R_1 R_2 \neq 0. $$

(define (div-interval x y)
	(if (>= 0 (* (lower-bound y) (upper-bound y)))
		(error "Divison 0 error")
		(mul-interval x (make-interval (/ 1 (upper-bound y))
							(/ 1 (lower-bound y))
						))
	)
)

Exercise 2.11. In passing, Ben also cryptically comments: “By testing the signs of the endpoints of the intervals, it is possible to break mul-interval into nine cases, only one of which requires more than two multiplications.” Rewrite this procedure using Ben’s suggestion.

After debugging her program, Alyssa shows it to a potential user, who complains that her program solves the wrong problem. He wants a program that can deal with numbers represented as a center value and an additive tolerance; for example, he wants to work with intervals such as $3.5 \pm 0.15$ rather than $[3.35, 3.65]$. Alyssa returns to her desk and fixes this problem by supplying an alternate constructor and alternate selectors:

(define (make-center-width c w)
  (make-interval (- c w) (+ c w)))
(define (center i)
  (/ (+ (lower-bound i) (upper-bound i)) 2))
(define (width i)
  (/ (- (upper-bound i) (lower-bound i)) 2))

Unfortunately, most of Alyssa’s users are engineers. Real engineering situations usually involve measurements with only a small uncertainty, measured as the ratio of the width of the interval to the midpoint of the interval. Engineers usually specify percentage tolerances on the parameters of devices, as in the resistor specifications given earlier.

Formulating Abstractions with Higher-Order Procedures

Sun, 25 Dec 2016 00:00:00 +0000

Section 1.3 Formulating Abstractions with Higher-Order Procedures

Exercises in this section of SCIP, and Merry Xmas.

Exercise 1.29. Simpson’s Rule is a more accurate method of numerical integration than the method illustrated above. Using Simpson’s Rule, the integral of a function $f$ between $a$ and $b$ is approximated as

$$ \frac{h}{3}[y_0+4y_1+2y_2+4y_3+…+2y_{n-2}+4y_{n-1}+y_n] $$

where $h = (b - a)/n$, for some even integer $n$, and $y_k = f(a + kh)$. (Increasing $n$ increases the accuracy of the approximation.) Define a procedure that takes as arguments $f$, $a$, $b$, and $n$ and returns the value of the integral, computed using Simpson’s Rule. Use your procedure to integrate cube between $0$ and $1$ (with $n = 100$ and $n = 1000$), and compare the results to those of the integral procedure shown above.

Answer 1.29. The Simpson’s Rule can also be written as follow:

$$ \frac{h}{3}[y_0+4y_1+2y_2+4y_3+…+2y_{n-2}+4y_{n-1}+y_n] = \frac{h}{3}\sum_{j=2,4…}^{n}[y_{j-2} + 4y_{j-1} + y_{j}] $$

(define (sum term a next b)
    (if (> a b)
        0
        (+ (term a)
           (sum term (next a) next b)
        )
    )
)

(define (simpson-rule f a b n)
    (define (simpson-next x)
        (+ x 2)
    )
    
    (define h (/ (- b a) n))
    
    (define (y k)
        (f (+ a (* k h)))
    )

    (define (simpson-term x)
        (+
            (y x)
            (* 4 (y (+ x 1)))
            (y (+ x 2))
        )
    )

    (* (sum simpson-term 0 simpson-next n ) (/ h 3))
)

(define (cub x)
    (* x x x)
)

(exact->inexact(simpson-rule cub 0 1 100))
(exact->inexact(simpson-rule cub 0 1 1000))

Exercise 1.30. The sum procedure above generates a linear recursion. The procedure can be rewritten so that the sum is performed iteratively. Show how to do this by filling in the missing expressions in the following definition:

(define (sum term a next b)
  (define (iter a result)
      (if 
	      
		  (iter  ))
  (iter  )

Answer 1.30.

(define (sum term a next b)
	(define (iter a result)
		(if (> a b)
			result
			(iter (next a) (+ result (term a)))
		)
	)
	(iter a 0)
)

Exercise 1.31.

a. The sum procedure is only the simplest of a vast number of similar abstractions that can be captured as higher-order procedures. Write an analogous procedure called product that returns the product of the values of a function at points over a given range. Show how to define factorial in terms of product. Also use product to compute approximations to $\pi$ using the formula

$$ \frac{\pi}{4}=\frac{2 \cdot 4 \cdot 4 \cdot 6 \cdot 6 \cdot 8 …}{3 \cdot 3 \cdot 5 \cdot 5 \cdot 7 \cdot 7 …} $$

b. If your product procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

Answer 1.31.

$$ \frac{\pi}{4}=\frac{2 \cdot 4 \cdot 4 \cdot 6 \cdot 6 \cdot 8 …}{3 \cdot 3 \cdot 5 \cdot 5 \cdot 7 \cdot 7 …} = \frac{1}{n+1}\prod_{i=1}^{n}[(\frac{2(i+1)}{2i})^2] $$

(define (product term a next b)
    (if (> a b)
        1
        (* (term a) (product term (next a) next b))
    )
)

(define (factorial n)
    (define (identity x)
        x
    )
    (define (next x)
        (+ x 1)
    )
    (product identity 1 next n)
)

(define (product term a next b)
    (define (iter a result)
        (if (> a b)
            result
            (iter (next a) (* result (term a)))
        )
    )
    (iter a 1)
)

(define (square x)
    (* x x)
)

(define (pi-product a b)
    (define (pi-term x)
       (square (/ (* 2 (+ x 1)) (+ (* 2 x) 1)))
    )
    (define (pi-next x)
        (+ x 1)
    )
    (* 4 (/ (product-iter pi-term a pi-next b) (+ b 1)))
)

(exact->inexact(pi-product 1 10000))

Exercise 1.32.

a. Show that sum and product (exercise 1.31) are both special cases of a still more general notion called accumulate that combines a collection of terms, using some general accumulation function:

(accumulate combiner null-value term a next b)

Accumulate takes as arguments the same term and range specifications as sum and product, together with a combiner procedure (of two arguments) that specifies how the current term is to be combined with the accumulation of the preceding terms and a null-value that specifies what base value to use when the terms run out. Write accumulate and show how sum and product can both be defined as simple calls to accumulate.

b. If your accumulate procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

Answer 1.32.

(define (accumulate combiner null-value term a next b)
    (if (> a b)
        null-value
        (combiner (term a) (accumulate combiner null-value term (next a) next b))
    )
)

(define (accumlate-iter combiner null-value term a next b)
    (define (iter a result)
        (if (> a b) res
            (iter (next a) (combiner res (term a)))
        )
    )
    (iter a null-value)
)

(define (sum term a next b)
    (accumulate + 0 term a next b)
)

(define (product term a next b)
    (accumlate * 1 term a next b)
)

Exercise 1.33. You can obtain an even more general version of accumulate (exercise 1.32) by introducing the notion of a filter on the terms to be combined. That is, combine only those terms derived from values in the range that satisfy a specified condition. The resulting filtered-accumulate abstraction takes the same arguments as accumulate, together with an additional predicate of one argument that specifies the filter. Write filtered-accumulate as a procedure. Show how to express the following using filtered-accumulate:

a. the sum of the squares of the prime numbers in the interval $a$ to $b$ (assuming that you have a prime? predicate already written)

b. the product of all the positive integers less than $n$ that are relatively prime to $n$ (i.e., all positive integers $i < n$ such that $GCD(i,n) = 1)$.

Answer 1.33.

(define (filtered-accumulate combiner null-value term a next b filter)
    (if (> a b)
        null-value
        (if (filter a)
            (combiner (term a) (filtered-accumulate combiner null-value (next a) next b filter))
            (combiner null-value (filtered-accumulate combiner null-value (next a) next b filter))
        )
    )
)

Exercise 1.34. Suppose we define the procedure

(define (f g)
  (g 2))

Then we have

(f square)
4

(f (lambda (z) (* z (+ z 1))))
6

What happens if we (perversely) ask the interpreter to evaluate the combination (f f)? Explain.

Answer 1.34.

=> (f f)
=> (f 2)
=> (2 2)

The third invocation will attempt to apply its argument, 2, to 2, resulting in error.

Exercise 1.35. Show that the golden ratio $\phi$ (section 1.2.2) is a fixed point of the transformation $x \mapsto 1 + 1/x$, and use this fact to compute $\phi$ by means of the fixed-point procedure.

Answer 1.35.

(define tolerance 0.00001)

(define (fixed-point f first-guess)
    (define (close-enough? v1 v2)
        (< (abs (- v1 v2)) tolerance)
    )

    (define (try guess)
        (let ((next (f guess)))
            (if (close-enough? guess next)
                next
                (try next)
            )
        )
    )

    (try first-guess)
)

(fixed-point (lambda (x) (+ 1 (/ 1 x))) 1.0)

Exercise 1.36. Modify fixed-point so that it prints the sequence of approximations it generates, using the newline and display primitives shown in exercise 1.22. Then find a solution to $x^x = 1000$ by finding a fixed point of $x \mapsto \log(1000)/\log(x)$. (Use Scheme’s primitive log procedure, which computes natural logarithms.) Compare the number of steps this takes with and without average damping. (Note that you cannot start fixed-point with a guess of $1$, as this would cause division by $\log(1) = 0$.)

Answer 1.36.

(define tolerance 0.00001)

(define (fixed-point f first-guess)
    (define (close-enough? v1 v2)
        (< (abs (- v1 v2)) tolerance)
    )

    (define (try guess)
        (display guess)
        (newline)
        (let ((next (f guess)))
            (if (close-enough? guess next)
                next
                (try next)
            )
        )
    )

    (try first-guess)
)

(fixed-point (lambda(x) (/ (log 1000.0) (log x))) 2.0)

Exercise 1.37.

a. An infinite continued fraction is an expression of the form

$$ f=\frac{N_1}{D_1+\frac{N_2}{D_2+\frac{N_3}{D_3+…}}} $$

As an example, one can show that the infinite continued fraction expansion with the $N_i$ and the $D_i$ all equal to $1$ produces $1/\phi$, where $\phi$ is the golden ratio (described in section 1.2.2). One way to approximate an infinite continued fraction is to truncate the expansion after a given number of terms. Such a truncation – a so-called $k$-term finite continued fraction – has the form

$$ \frac{N_1}{D_1+\frac{N_2}{…+\frac{N_k}{D_k}}} $$

Suppose that n and d are procedures of one argument (the term index $i$) that return the $N_i$ and $D_i$ of the terms of the continued fraction. Define a procedure cont-frac such that evaluating (cont-frac n d k) computes the value of the $k$-term finite continued fraction. Check your procedure by approximating $1/\phi$ using

(cont-frac (lambda (i) 1.0)
           (lambda (i) 1.0)
           k)

for successive values of k. How large must you make k in order to get an approximation that is accurate to $4$ decimal places?

b. If your cont-frac procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process.

Answer 1.37.

(define (con-frac n d k)
    (define (frac i)
        (if (< i k)
            (/ (n i) (+ (d i) (frac (+ i 1))))
            (/ (n i) (d i))
        )
    )
    (frac 1)
)

(define (con-frac-iter n d k)
    (define (frac-iter i result)
        (if (= i 0)
            result
            (frac-iter (- i 1) (/ (n i) (+ (d i) result)))
        )
        (frac-iter (- k 1) (/ (n k) (d k)))
    )
)

(con-frac (lambda(i) 1.0) (lambda(i) 1.0) 10)

Exercise 1.38. In 1737, the Swiss mathematician Leonhard Euler published a memoir De Fractionibus Continuis, which included a continued fraction expansion for $e - 2$, where $e$ is the base of the natural logarithms. In this fraction, the $E_i$ are all $1$, and the $D_i$ are successively $1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, …$. Write a program that uses your cont-frac procedure from exercise 1.37 to approximate $e$, based on Euler’s expansion.

Answer 1.38.

$$ D_i= \begin{cases} 2(i+1)/3, & \text{if } i\bmod 3 = 2;
1, & \text{if } i\bmod 3 \neq 2. \end{cases} $$

(define (con-frac n d k)
    (define (frac i)
        (if (< i k)
            (/ (n i) (+ (d i) (frac (+ i 1))))
            (/ (n i) (d i))
        )
    )
    (frac 1)
)

(define (eular k)
    (+ 2.0 (con-frac 
        (lambda(i) 1)
        (lambda(i)
            (if (= (remainder i 3) 2)
                (/ (+ i 1) 1.5)
                1
            )
        )
        k
    ))
)

(eular 100)

Exercise 1.39. A continued fraction representation of the tangent function was published in 1770 by the German mathematician J.H. Lambert:

$$ \tan x = \frac{x}{1-\frac{x^2}{3-\frac{x^2}{5-…}}} $$

where $x$ is in radians. Define a procedure (tan-cf x k) that computes an approximation to the tangent function based on Lambert’s formula. K specifies the number of terms to compute, as in exercise 1.37.

Answer 1.39.

(define (con-frac n d k)
    (define (frac i)
        (if (< i k)
            (/ (n i) (- (d i) (frac (+ i 1))))
            (/ (n i) (d i))
        )
    )
    (frac 1)
)

(define (tan-cf x k)
    (con-frac 
        (lambda (i) (
            if (= i 1)
                x
                (* x x)
        ))
        (lambda (i) (
            - (* 2 i) 1
        ))
        k
    )
)

Exercise 1.40. Define a procedure cubic that can be used together with the newtons-method procedure in expressions of the form

(newtons-method (cubic a b c) 1)

to approximate zeros of the cubic $x^3 + ax^2 + bx + c$.

Answer 1.40.

(define (cubic a b c)
    (lambda(x)
        (+
            (cube x)
            (* a (square x))
            (* b x)
            c
        )
    )
)

(define (cube x)
    (* x x x)
)

(define (square x)
    (* x x)
)

Exercise 1.41. Define a procedure double that takes a procedure of one argument as argument and returns a procedure that applies the original procedure twice. For example, if inc is a procedure that adds $1$ to its argument, then (double inc) should be a procedure that adds $2$. What value is returned by

(((double (double double)) inc) 5)

Answer 1.41.

We guess the procedure double is:

(define (double f)
	(lambda (x) (f (f x)))
)

Then:

=> (((double (double double)) inc) 5) 
=> (((double (lambda (x) (double (double x)))) inc) 5) 
=> ((double (double (double (double inc)))) 5)

Since there are 4 double procedures, call procedure is invoked $2^4 = 16$ times. Thus, result is $5 + 16 = 21$

Exercise 1.42. Let $f$ and $g$ be two one-argument functions. The composition $f$ after $g$ is defined to be the function $x \mapsto f(g(x))$. Define a procedure compose that implements composition. For example, if inc is a procedure that adds $1$ to its argument,

((compose square inc) 6)
49

Answer 1.42.

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

Exercise 1.43. If $f$ is a numerical function and $n$ is a positive integer, then we can form the $n$th repeated application of $f$, which is defined to be the function whose value at $x$ is $f(f(…(f(x))…))$. For example, if $f$ is the function $x \mapsto x + 1$, then the $n$th repeated application of $f$ is the function $x \mapsto x + n$. If $f$ is the operation of squaring a number, then the $n$th repeated application of $f$ is the function that raises its argument to the $2^n$th power. Write a procedure that takes as inputs a procedure that computes $f$ and a positive integer $n$ and returns the procedure that computes the $n$th repeated application of $f$. Your procedure should be able to be used as follows:

((repeated square 2) 5)
625

Hint: You may find it convenient to use compose from exercise 1.42.

Answer 1.43.

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

(define (repeated f n)
   (if (< n 1)
        (lambda(x) x)
        (compose f (repeated f (- n 1)))
   ) 
)

Exercise 1.44. The idea of smoothing a function is an important concept in signal processing. If $f$ is a function and $dx$ is some small number, then the smoothed version of $f$ is the function whose value at a point $x$ is the average of $f(x - dx)$, $f(x)$, and $f(x + dx)$. Write a procedure smooth that takes as input a procedure that computes $f$ and returns a procedure that computes the smoothed $f$. It is sometimes valuable to repeatedly smooth a function (that is, smooth the smoothed function, and so on) to obtained the $n$-fold smoothed function. Show how to generate the $n$-fold smoothed function of any given function using $smooth$ and $repeated$ from exercise 1.43.

Answer 1.44.

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

(define (repeated f n)
   (if (< n 1)
        (lambda(x) x)
        (compose f (repeated f (- n 1)))
   ) 
)

(define (smooth f)
    (lambda (x)
        (/ (+
                (f (- x dx))
                (f x)
                (f (+ x dx))
           )
           3 
        )
    )
)

(define (n-fold-smooth f n)
    ((repeated smooth n) f)
)

Exercise 1.45. We saw in section 1.3.3 that attempting to compute square roots by naively finding a fixed point of $y \mapsto x/y$ does not converge, and that this can be fixed by average damping. The same method works for finding cube roots as fixed points of the average-damped $y \mapsto x/y^2$. Unfortunately, the process does not work for fourth roots – a single average damp is not enough to make a fixed-point search for $y \mapsto x/y^3$ converge. On the other hand, if we average damp twice (i.e., use the average damp of the average damp of $y \mapsto x/y^3$) the fixed-point search does converge. Do some experiments to determine how many average damps are required to compute $n$th roots as a fixed-point search based upon repeated average damping of $y \mapsto x/y^{n-1}$. Use this to implement a simple procedure for computing nth roots using fixed-point, average-damp, and the repeated procedure of exercise 1.43. Assume that any arithmetic operations you need are available as primitives.

Answer 1.45. Here reference SICP 1.45: Computing nth roots

To fix the problem, we need to increase the number of times invoking average-damp. And we find out the number of average damps, $a$, we can say:

$$ n_{\text{max}} = 2^{a+1} - 1 \ a = \lfloor \log _2{n} \rfloor $$

(define (nth-root x n)
    (fixed-point
        ((repeated average-damp (floor (/ (log x) (log 2))))
            (lambda (y) (/ x (expt y (- n 1))))
        )
        1.0
    )
)

(define (compose f g)
    (lambda(x)
        (f (g x))
    )
)

(define (repeated f n)
   (if (< n 1)
        (lambda(x) x)
        (compose f (repeated f (- n 1)))
   ) 
)

(define tolerance 0.00001)

(define (fixed-point f first-guess)
    (define (close-enough? v1 v2)
        (< (abs (- v1 v2)) tolerance)
    )

    (define (try guess)
        (let ((next (f guess)))
            (if (close-enough? guess next)
                next
                (try next)
            )
        )
    )

    (try first-guess)
)

(define (average-damp f)
    (define (average x y)
        (/ (+ x y) 2)
    )
    (lambda (x) (average x (f x)))
)

(define (expt b n)
    (define (even? n) (= (remainder n 2) 0))
    (define (square x) (* x x))
    (cond 
        ((= n 0) 1)
        ((even? n) (square (expt b (/ n 2))))
        (else (* b (expt b (- n 1))))
    )
)

Exercise 1.46. Several of the numerical methods described in this chapter are instances of an extremely general computational strategy known as iterative improvement. Iterative improvement says that, to compute something, we start with an initial guess for the answer, test if the guess is good enough, and otherwise improve the guess and continue the process using the improved guess as the new guess. Write a procedure iterative-improve that takes two procedures as arguments: a method for telling whether a guess is good enough and a method for improving a guess. Iterative-improve should return as its value a procedure that takes a guess as argument and keeps improving the guess until it is good enough. Rewrite the sqrt procedure of section 1.1.7 and the fixed-point procedure of section 1.3.3 in terms of iterative-improve.

(define (close-enough? v1 v2) 
   (define tolerance 1.e-6) 
   (< (/ (abs (- v1 v2)) v2)  tolerance)) 
  
(define (iterative-improve improve close-enough?) 
   (lambda (x) 
     (let ((xim (improve x))) 
       (if (close-enough? x xim) 
           xim 
         ((iterative-improve improve close-enough?) xim)) 
       ))) 
  
(define (sqrt x) 
   ((iterative-improve   
     (lambda (y) 
       (/ (+ (/ x y) y) 2)) 
     close-enough?) 1.0))

Building Abstractions with Procedures Section 2 - Part 2

Tue, 20 Dec 2016 00:00:00 +0000

Section 1.2 Procedures and the Processes They Generate

Exercises in this section of SCIP.

Exercise 1.20. The process that a procedure generates is of course dependent on the rules used by the interpreter. As an example, consider the iterative gcd procedure given above. Suppose we were to interpret this procedure using normal-order evaluation, as discussed in section 1.1.5. (The normal-order-evaluation rule for if is described in exercise 1.5.) Using the substitution method (for normal order), illustrate the process generated in evaluating (gcd 206 40) and indicate the remainder operations that are actually performed. How many remainder operations are actually performed in the normal-order evaluation of (gcd 206 40)? In the applicative-order evaluation?

Answer 1.20.

Normal-order evaluation: fully expand and then reduce. 18 total remainder.

Applicative-order evaluation: evaluate arguments and then apply operands. 4 total remainder.

Exercise 1.21. Use the smallest-divisor procedure to find the smallest divisor of each of the following numbers: $199$, $1999$, $19999$.

Answer 1.21.

(define (smallest-divisor n)
    (find-divisor n 2)
)

(define (find-divisor n test-divisor)
    (cond ((> (square test-divisor) n) n)
          ((divides? test-divisor n) test-divisor)
          (else (find-divisor n (+ test-divisor 1)))
    )
)

(define (divides? a b)
    (= (remainder b a) 0)
)

(smallest-divisor 199) => 199
(smallest-divisor 1999) => 1999
(smallest-divisor 19999) => 7

Exercise 1.22. Most Lisp implementations include a primitive called runtime that returns an integer that specifies the amount of time the system has been running (measured, for example, in microseconds). The following timed-prime-test procedure, when called with an integer $n$, prints $n$ and checks to see if $n$ is prime. If $n$ is prime, the procedure prints three asterisks followed by the amount of time used in performing the test.

(define (timed-prime-test n)
  (newline)
  (display n)
  (start-prime-test n (runtime)))
(define (start-prime-test n start-time)
  (if (prime? n)
      (report-prime (- (runtime) start-time))))
(define (report-prime elapsed-time)
  (display " *** ")
  (display elapsed-time))

Using this procedure, write a procedure search-for-primes that checks the primality of consecutive odd integers in a specified range. Use your procedure to find the three smallest primes larger than $1000$; larger than $10,000$; larger than $100,000$; larger than $1,000,000$. Note the time needed to test each prime. Since the testing algorithm has order of growth of $\theta(\sqrt n)$, you should expect that testing for primes around $10,000$ should take about $\sqrt{10}$ times as long as testing for primes around $1000$. Do your timing data bear this out? How well do the data for $100,000$ and $1,000,000$ support the $\sqrt n$ prediction? Is your result compatible with the notion that programs on your machine run in time proportional to the number of steps required for the computation?

Answer 1.22.

(define runtime real-time-clock)

(define (timed-prime-test n)
  (newline)
  (display n)
  (start-prime-test n (runtime)))

(define (start-prime-test n start-time)
  (if (prime? n)
      (report-prime (- (runtime) start-time))))

(define (report-prime elapsed-time)
  (display " *** ")
  (display elapsed-time))

(define (find-divisor n test-divisor)
	(cond 
		((> (square test-divisor) n) n)
		((divides? test-divisor n) test-divisor)
		(else (find-divisor n (+ test-divisor 1)))
	)
)

(define (square x)
	(* x x)
)

(define (divides? a b)
	(= (remainder b a) 0)
)

(define (smallest-divisor n)
	(find-divisor n 2)
)

(define (prime? n)
	(= n (smallest-divisor n))
)

(define (search-for-primes start end)
	(if (even? start)
		(search-for-primes (+ start 1) end)
		(cond 
			((< start end) (timed-prime-test start)
			(search-for-primes (+ start 2) end))
		)
	)
)

(search-for-primes 1000000 1000100)

Exercise 1.23. The smallest-divisor procedure shown at the start of this section does lots of needless testing: After it checks to see if the number is divisible by $2$ there is no point in checking to see if it is divisible by any larger even numbers. This suggests that the values used for test-divisor should not be $2, 3, 4, 5, 6, …$, but rather $2, 3, 5, 7, 9, …$. To implement this change, define a procedure next that returns $3$ if its input is equal to $2$ and otherwise returns its input plus $2$. Modify the smallest-divisor procedure to use (next test-divisor) instead of (+ test-divisor 1). With timed-prime-test incorporating this modified version of smallest-divisor, run the test for each of the $12$ primes found in exercise 1.22. Since this modification halves the number of test steps, you should expect it to run about twice as fast. Is this expectation confirmed? If not, what is the observed ratio of the speeds of the two algorithms, and how do you explain the fact that it is different from $2$?

Answer 1.23.

(define (find-divisor n test-divisor)
    (cond
        ((> (square test-divisor) n) n)
        ((divides? test-divisor n) test-divisor)
        (else (find-divisor n (next test-divisor)))
    )
)

(define (next test-divisor)
    (if (= test-divisor 2) (+ test-divisor 1)
                           (+ test-divisor 2)
    )
)

(define (square x)
    (* x x)
)

(define (divides? a b)
    (= (remainder b a) 0)
)

(define (smallest-divisor n)
    (find-divisor n 2)
)

(define (prime? n)
    (= (smallest-divisor n) n)
)

Exercise 1.24. Modify the timed-prime-test procedure of exercise 1.22 to use fast-prime? (the Fermat method), and test each of the $12$ primes you found in that exercise. Since the Fermat test has $\theta (\log n)$ growth, how would you expect the time to test primes near $1,000,000$ to compare with the time needed to test primes near 1000? Do your data bear this out? Can you explain any discrepancy you find?

Answer 1.24.

(define (expmod base exp m)
    (cond 
        ((= exp 0) 1)
        ((even? exp) (remainder (square (expmod base (/ exp 2) m)) m))
        (else (remainder (* base (expmod base (- exp 1) m)) m))
    )
)

(define (fermat-test n)
    (define (try-it a)
        (= (expmod a n n) a)
    )
    (try-it (+ 1 (random (- n 1))))
)

(define (fast-prime? n times)
    (cond
        ((= times 0) true)
        ((fermat-test n) (fast-prime? n (- times 1)))
        (else false)
    )
)

(define (prime? n)
    (fast-prime? n 100 )
)

Exercise 1.25. Alyssa P. Hacker complains that we went to a lot of extra work in writing expmod. After all, she says, since we already know how to compute exponentials, we could have simply written

(define (expmod base exp m)
  (remainder (fast-expt base exp) m))

Is she correct? Would this procedure serve as well for our fast prime tester? Explain.

Answer 1.25. Scheme is able to handle arbitrary-precision arithmetic, but arithmetic with arbitrarily long numbers is computationally expensive. This means that we get the correct results, but it takes considerably longer.

Exercise 1.26. Louis Reasoner is having great difficulty doing exercise 1.24. His fast-prime? test seems to run more slowly than his prime? test. Louis calls his friend Eva Lu Ator over to help. When they examine Louis’s code, they find that he has rewritten the expmod procedure to use an explicit multiplication, rather than calling square:

(define (expmod base exp m)
  (cond ((= exp 0) 1)
        ((even? exp)
         (remainder (* (expmod base (/ exp 2) m)
                       (expmod base (/ exp 2) m))
                    m))
        (else
         (remainder (* base (expmod base (- exp 1) m))
                    m))))

“I don’t see what difference that could make,” says Louis. “I do.” says Eva. “By writing the procedure like that, you have transformed the $\theta (\log n)$ process into a $\theta (n)$ process.’’ Explain.

Answer 1.26. Let $n$ is exponent which can generate a complete binary tree recursion. The depth of the tree is $\log n + 1$, the total number of nodes is $2^{\log n + 1} - 1$, is $2n -1 = \theta (n)$.

Exercise 1.27. Demonstrate that the Carmichael numbers listed in footnote 47 really do fool the Fermat test. That is, write a procedure that takes an integer $n$ and tests whether $a^n$ is congruent to $a$ modulo $n$ for every $a < n$, and try your procedure on the given Carmichael numbers.

Answer 1.27. Carmichael numbers fools Fermat test.

(define (expmod base exp m)
    (cond 
        ((= exp 0) 1)
        ((even? exp) (remainder (square (expmod base (/ exp 2) m)) m))
        (else (remainder (* base (expmod base (- exp 1) m)) m))
    )
)

(define (fermat-test n test-value)
    (define (try-it a)
        (= (expmod a n n) a)
    )
    (try-it test-value)
)

(define (fast-prime? n times)
    (cond
        ((= times 0) true)
        ((fermat-test n times) (fast-prime? n (- times 1)))
        (else false)
    )
)

(define (prime? n)
    (fast-prime? n (- n 1))
)

(prime? 561)
(prime? 1105)
(prime? 1729)
(prime? 2465)

Exercise 1.28. One variant of the Fermat test that cannot be fooled is called the Miller-Rabin test (Miller 1976; Rabin 1980). This starts from an alternate form of Fermat’s Little Theorem, which states that if $n$ is a prime number and $a$ is any positive integer less than $n$, then $a$ raised to the $(n - 1)$st power is congruent to $1$ modulo $n$. To test the primality of a number $n$ by the Miller-Rabin test, we pick a random number $aexpmod procedure. However, whenever we perform the squaring step in expmod, we check to see if we have discovered a “nontrivial square root of $1$ modulo $n$,” that is, a number not equal to $1$ or $n - 1$ whose square is equal to $1$ modulo $n$. It is possible to prove that if such a nontrivial square root of $1$ exists, then $n$ is not prime. It is also possible to prove that if $n$ is an odd number that is not prime, then, for at least half the numbers $aexpmod procedure to signal if it discovers a nontrivial square root of $1$, and use this to implement the Miller-Rabin test with a procedure analogous to fermat-test. Check your procedure by testing various known primes and non-primes. Hint: One convenient way to make expmod signal is to have it return $0$.

Answer 1.28. I got stuck in the exercise for hours. After reading other resources about Miller-Rabin test, I find out we don’t worry about the proof that “if such a nontrivial square root of $1$ exists, then $n$ is not prime”. Just know about the condition apply to the procedure.

(define (expmod base exp m)
    (cond
        ((= exp 0) 1)
        ((even? exp)
            (let ((x (expmod base (/ exp 2) m)))
                (if (non-trivial-sqrt? x m) 0 (remainder (square x) m))
            )
        )
        (else (remainder (* base (expmod base (- exp 1) m)) m))
    )
)

(define (non-trivial-sqrt? n m)
    (cond
        ((= n 1) false)
        ((= n (- m 1)) false)
        (else (= (remainder (square n) m) 1))
    )
)

(define (square x)
    (* x x)
)

(define (miller-rabin-test a n)
    (cond
        ((= a 0) true)
        ((= (expmod a (- n 1) n ) 1) (miller-rabin-test (- a 1) n))
        (else false)
    )
)

(define (prime? n)
    (miller-rabin-test (- n 1) n)
)

(prime? 561)
(prime? 1105)
(prime? 1729)
(prime? 2465)

Building Abstractions with Procedures Section 2 - Part 1

Fri, 16 Dec 2016 00:00:00 +0000

Section 1.2 Procedures and the Processes They Generate

Exercises in this section of SCIP.

Exercise 1.9. Each of the following two procedures defines a method for adding two positive integers in terms of the procedures inc, which increments its argument by 1, and dec, which decrements its argument by 1.

(define (+ a b)
  (if (= a 0)
      b
      (inc (+ (dec a) b))))

(define (+ a b)
  (if (= a 0)
      b
      (+ (dec a) (inc b))))

Using the substitution model, illustrate the process generated by each procedure in evaluating (+ 4 5). Are these processes iterative or recursive?

Answer 1.9.

For the first process, it is recursive:

=> (+ 4 5)
=> (+ 1 ( + 3 5))
=> (+ 1 (+ 1 (+ 2 5)))
=> ...
=> (+ 1 (+ 1 (+ 1 (+ 1 (5)))))
=> (+ 1 (+ 1 (+ 1 (6))))
=> (+ 1 (+ 1 (7)))
=> ...
=> 9

For the second process, it is iterative:

=> (+ 4 5)
=> (+ 3 6)
=> (+ 2 7)
=> ...
=> (+ 0 8)
=> 8

Exercise 1.10. The following procedure computes a mathematical function called Ackermann’s function.

(define (A x y)
  (cond ((= y 0) 0)
        ((= x 0) (* 2 y))
        ((= y 1) 2)
        (else (A (- x 1)
                 (A x (- y 1))))))

What are the values of the following expressions?

(A 1 10)

(A 2 4)

(A 3 3)

Consider the following procedures, where A is the procedure defined above:

(define (f n) (A 0 n))

(define (g n) (A 1 n))

(define (h n) (A 2 n))

Give concise mathematical definitions for the functions computed by the procedures f, g, and h for positive integer values of n.

Answer 1.10.

(A 1 10) = 2^10 = 1024
(A 2 4) = 65536
(A 3 3) = 65536

$$ A(0,n)=f(n)=2n $$

$$ A(1,n)=g(n)=2^n $$

$$ A(2,n)=h(n) = \overbrace{(2^{(2^{(2^{…})})})}^{n ~times} $$

Exercise 1.11. A function f is defined by the rule that f(n) = n if n<3 and f(n) = f(n-1) + 2f(n-2) + 3f(n-3) if n>3. Write a procedure that computes f by means of a recursive process. Write a procedure that computes f by means of an iterative process.

Answer 1.11.

(define (fun-recursive n)
  (if (< n 3)
  n
  (+ (fun-recursive (- n 1))
     (* 2 (fun-recursive (- n 2)))
     (* 3 (fun-recursive (- n 3)))
     )) 
  )

(define (fun-iter n a b cnt)
     (if (= cnt 0)
            n
            (fun-iter (+ n (* 2 a) (* 3 b)) n a (- cnt 1))
     )
)

(define (fun-iterative n)
    (fun-iter 2 1 0 (- n 2))
)

Exercise 1.12. The following pattern of numbers is called Pascal’s triangle.

				1
			1		1
		1		2		1
	1		3		3		1
1		4		6		4		1
			   ...

The numbers at the edge of the triangle are all 1, and each number inside the triangle is the sum of the two numbers above it. Write a procedure that computes elements of Pascal’s triangle by means of a recursive process.

Answer 1.12.

(define (pascal-triangle m n)
    (if (or (= n 1) (= n m))
        1
        (+ (pascal-triangle (- m 1) (- n 1)) 
           (pascal-triangle (- m 1) n))
    )
)

Exercise 1.13. Prove that Fib(n) is the closest integer to $\frac{\phi^{n}}{\sqrt{5}}$, where $\phi=\frac{1 + \sqrt{5}}{2}$.

Answer 1.13.

Theorem 1

$$ Fib(n)=\frac{\phi^n-\psi^n}{\sqrt{5}},\phi=\frac{1+\sqrt{5}}{2}, \psi=\frac{1-\sqrt{5}}{2} $$

Base Case

$$ Fib(0)=0, Fib(1)=1 $$

Induction Step

\begin{align} Fib(n-1)+Fib(n-2)&=\frac{(\phi^{n-1}-\psi^{n-1})+(\phi^{n-2}-\psi^{n-2})}{\sqrt{5}}\ &=\frac{(\phi^{n-1}+\phi^{n-2})-(\psi^{n-1}+\psi^{n-2})}{\sqrt{5}}\end{align}

Meanwhile,

\begin{align} \phi+1=\frac{3+\sqrt{5}}{2}=\frac{6+2\sqrt{5}}{4}=(\frac{1+\sqrt{5}}{2})^2=\phi^2\ \psi+1=\frac{3-\sqrt{5}}{2}=\frac{6-2\sqrt{5}}{4}=(\frac{1-\sqrt{5}}{2})^2=\psi^2 \end{align}

Thus,

\begin{align} Fib(n-1)+Fib(n-2)&=\frac{\phi^{n-2}(\phi+1)-\psi^{n-2}(\psi+1)}{\sqrt{5}}\ &=\frac{\phi^n-\psi^n}{\sqrt{5}}=Fib(n) \end{align}

Theorem 2

\begin{align} \frac{\psi^n}{\sqrt{5}} < \frac{1}{2} \end{align}

Proof

\begin{align} \frac{\psi^0}{\sqrt{5}}&\sim0.4472, \frac{\psi^1}{\sqrt{5}}\sim0.2764,…\ \frac{\psi^n}{\sqrt{5}}&<\frac{1}{2} \end{align}

Therefore,

\begin{align} Fib(n) &= \frac{\phi^n-\psi^n}{\sqrt{5}} = \left[\frac{\phi^n-\psi^n}{\sqrt{5}}\right]\ &=\left[\frac{\phi^n}{\sqrt{5}}\right] \end{align}

Q.E.D.

Exercise 1.14. Draw the tree illustrating the process generated by the count-change procedure of section 1.2.2 in making change for 11 cents. What are the orders of growth of the space and number of steps used by this process as the amount to be changed increases?

Answer 1.14.

Let the number of kinds of coins: $k$; Amount of money: $n$; Denominations: $d_1, d_2, …, d_k$.

Orders of growth of the space

The space required is proportional to the maximum depth of the tree. Clearly, this means the maximum height is going to be linear in the amount $n$, or $\theta(n)$.

Number of steps

Basic case

Let see the recursive tree of (cc n 1), which number of steps is defined as $T(n,1)$. Clearly, we can calculate that $T(n,1)=2n+1=\theta(n)$.

Induction step

Next, we look at the recursive tree of (cc n k). We have:

$$ T(n,k)=\lfloor \frac{n}{d_k} \rfloor (T(n,k-1)+1)+2 $$

We can expand it further:

\begin{align} T(n,k)&=\lfloor \frac{n}{d_k} \rfloor (T(n,k-1)+1)+2 \ &=\lfloor \frac{n}{d_k} \rfloor ((\lfloor \frac{n}{d_k} \rfloor T(n,k-2)+1)+2+1)+2 \ &= \lfloor \frac{n}{d_k} \rfloor (… (\lfloor \frac{n}{d_k} \rfloor T(n,1)+1)+2 … +1)+2 \ &= \theta(n^k) \end{align}

Thus, we have $T(n,5) = \theta(n^5)$.

Exercise 1.15. The sine of an angle (specified in radians) can be computed by making use of the approximation $sin x \approx x$ if $x$ is sufficiently small, and the trigonometric identity

$$ \sin x = 3 \sin \frac{x}{3} - 4 \sin^3 \frac{x}{3} $$

to reduce the size of the argument of sin. (For purposes of this exercise an angle is considered “sufficiently small” if its magnitude is not greater than 0.1 radians.) These ideas are incorporated in the following procedures:

(define (cube x) (* x x x))
(define (p x) (- (* 3 x) (* 4 (cube x))))
(define (sine angle)
   (if (not (> (abs angle) 0.1))
       angle
       (p (sine (/ angle 3.0)))))

a. How many times is the procedure p applied when (sine 12.15) is evaluated?

b. What is the order of growth in space and number of steps (as a function of $a$) used by the process generated by the sine procedure when (sine a) is evaluated?

Answer 1.15.

a. $\lceil \log_3 \frac{12.15}{0.1} \rceil = 5$.

b. The order of growth in space and number of steps are $\theta(\log n)$.

Exercise 1.16. Design a procedure that evolves an iterative exponentiation process that uses successive squaring and uses a logarithmic number of steps, as does fast-expt. (Hint: Using the observation that $(b^{n/2})^2 = (b^2)^{n/2}$, keep, along with the exponent $n$ and the base $b$, an additional state variable $a$, and define the state transformation in such a way that the product $ab^n$ is unchanged from state to state. At the beginning of the process $a$ is taken to be $1$, and the answer is given by the value of $a$ at the end of the process. In general, the technique of defining an invariant quantity that remains unchanged from state to state is a powerful way to think about the design of iterative algorithms.)

Answer 1.16.

(define (square x)
    (* x x)
)

(define (expt-iter b n a)
    (cond
        ((= n 0) a)
        ((even? n) (expt-iter (square b) (/ n 2) a))
        (else (expt-iter b (- n 1) (* a b)))
    )
)

(define (fast-expt a n)
    (expt-iter a n 1)
)

Exercise 1.17. The exponentiation algorithms in this section are based on performing exponentiation by means of repeated multiplication. In a similar way, one can perform integer multiplication by means of repeated addition. The following multiplication procedure (in which it is assumed that our language can only add, not multiply) is analogous to the expt procedure:

(define (* a b)
  (if (= b 0)
      0
      (+ a (* a (- b 1)))))

This algorithm takes a number of steps that is linear in b. Now suppose we include, together with addition, operations double, which doubles an integer, and halve, which divides an (even) integer by $2$. Using these, design a multiplication procedure analogous to fast-expt that uses a logarithmic number of steps.

(define (double x)
    (+ x x)
)

(define (halve x)
    (/ x 2)
)

(define (mult-iter a b )
    (cond
        ((= b 0) 0)
        ((even? b) (mult-iter (double a) (halve b)))
        (else (+ a (mult-iter a (- b 1) )))
    )
)

(define (fast-mult a b)
    (mult-iter a b)
)

Exercise 1.18. Using the results of exercises 1.16 and 1.17, devise a procedure that generates an iterative process for multiplying two integers in terms of adding, doubling, and halving and uses a logarithmic number of steps.

Answer 1.18.

(define (double x)
    (+ x x)
)

(define (halve x)
    (/ x 2)
)

(define (fast-mult a b)
    (define (mult-iter a b acc)
        (cond
            ((= b 0) acc)
            ((even? b) (mult-iter (double a) (halve b) acc))
            (else (mult-iter a (- b 1) (+ acc a)))
        )
    )
    (mult-iter a b 0)
)

Exercise 1.19. There is a clever algorithm for computing the Fibonacci numbers in a logarithmic number of steps. Recall the transformation of the state variables $a$ and $b$ in the fib-iter process of section 1.2.2: $a \rightarrow a + b$ and $b \rightarrow a$. Call this transformation $T$, and observe that applying $T$ over and over again $n$ times, starting with $1$ and $0$, produces the pair $Fib(n + 1)$ and $Fib(n)$. In other words, the Fibonacci numbers are produced by applying $T^n$, the $n$th power of the transformation $T$, starting with the pair $(1,0)$. Now consider $T$ to be the special case of $p = 0$ and $q = 1$ in a family of transformations $T_{pq}$, where $T_{pq}$ transforms the pair $(a,b)$ according to $a \leftarrow bq + aq + ap$ and $b \leftarrow bp + aq$. Show that if we apply such a transformation $T_{pq}$ twice, the effect is the same as using a single transformation $T_{p’q’}$ of the same form, and compute $p’$ and $q’$ in terms of $p$ and $q$. This gives us an explicit way to square these transformations, and thus we can compute $T^n$ using successive squaring, as in the fast-expt procedure. Put this all together to complete the following procedure, which runs in a logarithmic number of steps:

(define (fib n)
  (fib-iter 1 0 0 1 n))
(define (fib-iter a b p q count)
  (cond ((= count 0) b)
        ((even? count)
         (fib-iter a
                   b
                         ; compute p'
                         ; compute q'
                   (/ count 2)))
        (else (fib-iter (+ (* b q) (* a q) (* a p))
                        (+ (* b p) (* a q))
                        p
                        q
                        (- count 1)))))

Answer 1.19.

Define $a’$ and $b’$ by the definition of the transformation $T_{pq}$:

\begin{align} a’ &= qb + qa + pa = (p + q)a + qb \ b’ &= qa + pb \end{align}

Then, let $a’’$ and $b’’$ be the results of the transformation to $a’$ and $b’$ by applying the transformation once:

\begin{align} a’’ &= (p + q)a’ + qb’ = (p^2 + 2pq + 2q^2)a + (2pq + q^2)b \ b’’ &= qa’ + pb’ = (2pq + q^2)a + (p^2 + q^2)b \end{align}

Thus, we get the transformation to $p$ and $q$:

\begin{align} p’ &= p^2 + q^2 \ q’ &= 2pq + q^2 \end{align}

Building Abstractions with Procedures Section 1

Mon, 12 Dec 2016 00:00:00 +0000

Section 1.1 The Elements of Programing

Exercises in this section of SICP.

Exercise 1.1. Below is a sequence of expressions. What is the result printed by the interpreter in response to each expression? Assume that the sequence is to be evaluated in the order in which it is presented.

10
(+ 5 3 4)
(- 9 1)
(/ 6 2)
(+ (* 2 4) (- 4 6))
(define a 3)
(define b (+ a 1))
(+ a b (* a b))
(= a b)
(if (and (> b a) (< b (* a b)))
    b
    a)
(cond ((= a 4) 6)
      ((= b 4) (+ 6 7 a))
      (else 25))
(+ 2 (if (> b a) b a))
(* (cond ((> a b) a)
         ((< a b) b)
         (else -1))
   (+ a 1))

Answer 1.1.

Exercise 1.2. Translate the following expression into prefix form

$$ \frac{5+4+(2-(3-6 + \frac{4}{5}))}{3(6-2)(2-7)} $$

Answer 1.2.

(/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 4 3))))) (* 3 (- 6 2) (- 2 7)))

Exercise 1.3. Define a procedure that takes three numbers as arguments and returns the sum of the squares of the two larger numbers.

Answer 1.3.

(DEFINE (SOS x y) (+ (* x x) (* y y)))
(DEFINE (F x y z)
	(COND ((AND (<= x y) (<= x z)) (SOS y z))
	      ((AND (<= y x) (<= y z)) (SOS x z))
	      ((AND (<= z x) (<= z y)) (SOS x y))
	)	
)

Exercise 1.4. Observe that our model of evaluation allows for combinations whose operators are compound expressions. Use this observation to describe the behavior of the following procedure:

(define (a-plus-abs-b a b)
  ((if (> b 0) + -) a b))

Answer 1.4.

$$ a+|b| $$

a plus the absolute value of b.

Exercise 1.5. Ben Bitdiddle has invented a test to determine whether the interpreter he is faced with is using applicative-order evaluation or normal-order evaluation. He defines the following two procedures:

(define (p) (p))

(define (test x y)
  (if (= x 0)
      0
      y))

Then he evaluates the expression:

(test 0 (p))

What behavior will Ben observe with an interpreter that uses applicative-order evaluation? What behavior will he observe with an interpreter that uses normal-order evaluation? Explain your answer. (Assume that the evaluation rule for the special form if is the same whether the interpreter is using normal or applicative order: The predicate expression is evaluated first, and the result determines whether to evaluate the consequent or the alternative expression.)

Answer 1.5.

The applicative-order evaluation:

=> (test 0 (p))
=> (test 0 ((p)))
=> (test 0 (((p))))

As we see, the evaluation of (test 0 (p)) is infinitive.

The normal-order evaluation:

=> (test 0 (p))
=> (if (= 0 0) 0 (p))
=> (if #t 0 (p))
=> 0

The expression evaluates to 0.

Exercise 1.6. Alyssa P. Hacker doesn’t see why if needs to be provided as a special form. “Why can’t I just define it as an ordinary procedure in terms of cond?” she asks. Alyssa’s friend Eva Lu Ator claims this can indeed be done, and she defines a new version of if:

(define (new-if predicate then-clause else-clause)
  (cond (predicate then-clause)
        (else else-clause)))

Eva demonstrates the program for Alyssa:

(new-if (= 2 3) 0 5)
5

(new-if (= 1 1) 0 5)
0

Delighted, Alyssa uses new-if to rewrite the square-root program:

(define (sqrt-iter guess x)
  (new-if (good-enough? guess x)
          guess
          (sqrt-iter (improve guess x)
                     x)))

What happens when Alyssa attempts to use this to compute square roots? Explain.

Answer 1.6. I believe this program is incorrect, because new-if uses applicative-order evaluation. Thus, it always expands the else-clause and causes an infinite recursion. In contrast, if uses normal-order evaluation.

Exercise 1.7. The good-enough? test used in computing square roots will not be very effective for finding the square roots of very small numbers. Also, in real computers, arithmetic operations are almost always performed with limited precision. This makes our test inadequate for very large numbers. Explain these statements, with examples showing how the test fails for small and large numbers. An alternative strategy for implementing good-enough? is to watch how guess changes from one iteration to the next and to stop when the change is a very small fraction of the guess. Design a square-root procedure that uses this kind of end test. Does this work better for small and large numbers?

Answer 1.7. The results are very inaccurate when calculating sqrt(0.0001) and sqrt(100000000). We can modify good-enough using current guess and previous guess below:

$$ \frac{|G-G_{pre}|}{G}<0.001 $$

(define (good-enough? guess prev-guess)
  (< (/ (abs (- guess prev-guess))
        guess)
     0.001))

(define (sqrt-iter guess prev-guess x)
  (if (good-enough? guess prev-guess)
    guess
    (sqrt-iter (improve guess x)
               guess
               x)))

(define (sqrt x) 
   (sqrt-iter 1.0 0 x))

Exercise 1.8. Newton’s method for cube roots is based on the fact that if y is an approximation to the cube root of x, then a better approximation is given by the value

$$ \frac{x/y^2+2y}{3} $$

Use this formula to implement a cube-root procedure analogous to the square-root procedure.

Answer 1.8.

(define (cub-iter guess prev-guess x)
  (if (good-enough? guess prev-guess)
    guess
    (cub-iter (improve guess x) guess x)
    )
  )

(define (good-enough? guess prev-guess)
  (< (/ (abs (- guess prev-guess)) guess) 0.001)
  )

(define (improve guess x)
  (/ (+ (/ x (square guess)) (* 2 guess)) 3)
  )

(define (square x)
  (* x x)
  )

(define (cubroot x) 
  ((if (< x 0) - +) (cub-iter (improve 1.0 (abs x)) 1 (abs x)))
  )