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
h
- (y_0 + 4y_1 + 2y_2 + 4y_3 + 2y_4 + ... + 2y_(n-2) + 4y_(n-1) + y_n)
3
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.

(define (simpson-integral f a b n)
  (define h (/ (- b a) n))
  (define (y k)
    (f (+ a (* k h))))
  (define (term k)
    (cond ((or (= k 0) (= k n))
           (y k))
          ((even? k)
           (* 2 (y k)))
          (else
           (* 4 (y k)))))
  (* (/ h 3.0) (sum term a 1+ b)))

运行：
scheme@(guile-user)> (simpson-integral cube 0 1 100) 
0.25 
scheme@(guile-user)> (simpson-integral cube 0 1 1000) 
0.25

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

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

The sum procedure is only the simplest of a vast number of similar abstractions that can be captured
as higher-order procedures.3 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 formula4
pi   2 * 4 * 4 * 6 * 6 * 8 ...
-- = -------------------------
 4   3 * 3 * 5 * 5 * 7 * 7 ...
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.

a:
(define (produce term a next b)
  (if (> a b)
      1
      (* (term a)
         (produce term (next a) next b))))

(define (factorial n)
  (produce identity 1 1+ n))

(define (pi-produce n)
  (define (pi-term n)
    (/ (* (- n 1)
          (+ n 1))
       (* n n)))
  (define (pi-next n)
    (+ n 2))
  (* 4 (produce pi-term 3 pi-next n)))

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

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.
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.

a.
(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 (sum term a next b)
  (accumulate + 0 term a next b))

(define (produce term a next b)
  (accumulate * 1 term a next b))
b.
(define (accumulate combiner null-value term a next b)
  (define (iter acc count)
    (if (> count b)
        acc
        (iter (combiner acc (term count))
              (next count))))
  (iter null-value a))

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: the sum of the squares of the prime numbers in the interval a to b
(assuming that you have a prime? predicate already written) 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).

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

(define (sum-of-prime-squares a b)
  (filtered-accumulate prime? + 0 square 2 1+ 10))


(define (produce-of-relatively-primes n)
  (define (relatively-prime? i)
    (= (gcd i n)))
  (filtered-accumulate relatively-prime? * 1 identity 1 1+ (1- n)))

• SICP-2.3.4节练习
• SICP-2.3.3节练习
• SICP-2.3.2节练习
• SICP-2.3.1节练习
• SICP-2.2.4节-wave代码

• 魔法书1.1补充：平方根算法的论证
• sicp 1.2.2 迭代的费波那契
• sicp 1.11
• 正则序和应用序
• 立方根程序