From 206628f1658559c63672585d845d698f10ce6b52 Mon Sep 17 00:00:00 2001 From: Correl Roush Date: Sun, 29 Jun 2014 21:33:26 -0400 Subject: [PATCH] Section 2.2.3 --- 2-2.org | 307 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 307 insertions(+) diff --git a/2-2.org b/2-2.org index c07f7c0..404d980 100644 --- a/2-2.org +++ b/2-2.org @@ -684,3 +684,310 @@ layout: org (let ((rest (subsets (cdr s)))) (append rest (map (lambda (x) (cons (car s) x)) rest))))) #+end_src +* Sequences as Conventional Interfaces +** Sequence Operations + #+begin_src scheme :tangle yes + ;; =================================================================== + ;; Section 2.2.3: Sequences as Conventional Interfaces + ;; =================================================================== + (define (filter predicate sequence) + (cond ((null? sequence) nil) + ((predicate (car sequence)) + (cons (car sequence) + (filter predicate (cdr sequence)))) + (else (filter predicate (cdr sequence))))) + + (define (accumulate op initial sequence) + (if (null? sequence) + initial + (op (car sequence) + (accumulate op initial (cdr sequence))))) + + #+end_src +*** Exercise 2.33 + Fill in the missing expressions to complete the + following definitions of some basic list-manipulation operations + as accumulations: + + #+begin_src scheme + (define (map p sequence) + (accumulate (lambda (x y) ) nil sequence)) + + (define (append seq1 seq2) + (accumulate cons )) + + (define (length sequence) + (accumulate 0 sequence)) + #+end_src + + ---------------------------------------------------------------------- + + #+begin_src scheme :tangle yes + ;; ------------------------------------------------------------------- + ;; Exercise 2.33 + ;; ------------------------------------------------------------------- + + (define (map p sequence) + (accumulate (lambda (x y) (cons (p x) y)) '() sequence)) + + (define (append seq1 seq2) + (accumulate cons seq2 seq1)) + + (define (length sequence) + (accumulate (lambda (e acc) (+ 1 acc)) 0 sequence)) + #+end_src + +*** Exercise 2.34 + Evaluating a polynomial in x at a given value of + x can be formulated as an accumulation. We evaluate the polynomial + + #+begin_example + a_n r^n | a_(n-1) r^(n-1) + ... + a_1 r + a_0 + #+end_example + + using a well-known algorithm called "Horner's rule", which + structures the computation as + + #+begin_example + (... (a_n r + a_(n-1)) r + ... + a_1) r + a_0 + #+end_example + + In other words, we start with a_n, multiply by x, add a_(n-1), + multiply by x, and so on, until we reach a_0.(3) + + Fill in the following template to produce a procedure that + evaluates a polynomial using Horner's rule. Assume that the + coefficients of the polynomial are arranged in a sequence, from + a_0 through a_n. + + #+begin_src scheme + (define (horner-eval x coefficient-sequence) + (accumulate (lambda (this-coeff higher-terms) ) + 0 + coefficient-sequence)) + #+end_src + + For example, to compute 1 + 3x + 5x^3 + x^(5) at x = 2 you would + evaluate + + #+begin_src scheme + (horner-eval 2 (list 1 3 0 5 0 1)) + #+end_src + + ---------------------------------------------------------------------- + + #+begin_src scheme :tangle yes + ;; ------------------------------------------------------------------- + ;; Exercise 2.34 + ;; ------------------------------------------------------------------- + + (define (horner-eval x coefficient-sequence) + (accumulate (lambda (this-coeff higher-terms) + (+ this-coeff (* higher-terms x))) + 0 + coefficient-sequence)) + #+end_src + +*** Exercise 2.35 + Redefine `count-leaves' from section *Note 2-2-2:: as an + accumulation: + + #+begin_src scheme + (define (count-leaves t) + (accumulate (map ))) + #+end_src + + ---------------------------------------------------------------------- + + #+begin_src scheme :tangle yes + ;; ------------------------------------------------------------------- + ;; Exercise 2.35 + ;; ------------------------------------------------------------------- + + (define (count-leaves t) + (accumulate + 0 (map + (lambda (node) + (if (pair? node) + (count-leaves node) + 1)) + t))) + #+end_src + +*** Exercise 2.36 + The procedure `accumulate-n' is similar to `accumulate' except + that it takes as its third argument a sequence of sequences, which + are all assumed to have the same number of elements. It applies + the designated accumulation procedure to combine all the first + elements of the sequences, all the second elements of the + sequences, and so on, and returns a sequence of the results. For + instance, if `s' is a sequence containing four sequences, `((1 + 2 3) (4 5 6) (7 8 9) (10 11 12)),' then the value of + `(accumulate-n + 0 s)' should be the sequence `(22 26 30)'. Fill + in the missing expressions in the following definition of + `accumulate-n': + + #+begin_src scheme + (define (accumulate-n op init seqs) + (if (null? (car seqs)) + nil + (cons (accumulate op init ) + (accumulate-n op init )))) + #+end_src + + ---------------------------------------------------------------------- + + #+begin_src scheme :tangle yes + ;; ------------------------------------------------------------------- + ;; Exercise 2.36 + ;; ------------------------------------------------------------------- + + (define (accumulate-n op init seqs) + (if (null? (car seqs)) + '() + (cons (accumulate op init (map car seqs)) + (accumulate-n op init (map cdr seqs))))) + #+end_src + +** Exercise 2.37 + Suppose we represent vectors v = (v_i) as sequences of numbers, and + matrices m = (m_(ij)) as sequences of vectors (the rows of the matrix). + For example, the matrix + + #+begin_example + +- -+ + | 1 2 3 4 | + | 4 5 6 6 | + | 6 7 8 9 | + +- -+ + #+end_example + + is represented as the sequence `((1 2 3 4) (4 5 6 6) (6 7 8 9))'. With + this representation, we can use sequence operations to concisely + express the basic matrix and vector operations. These operations + (which are described in any book on matrix algebra) are the following: + + #+begin_example + __ + (dot-product v w) returns the sum >_i v_i w_i + + (matrix-*-vector m v) returns the vector t, + __ + where t_i = >_j m_(ij) v_j + + (matrix-*-matrix m n) returns the matrix p, + __ + where p_(ij) = >_k m_(ik) n_(kj) + + (transpose m) returns the matrix n, + where n_(ij) = m_(ji) + #+end_example + + We can define the dot product as(4) + + #+begin_src scheme + (define (dot-product v w) + (accumulate + 0 (map * v w))) + #+end_src + + Fill in the missing expressions in the following procedures for + computing the other matrix operations. (The procedure `accumulate-n' + is defined in *Note Exercise 2-36::.) + + #+begin_src scheme + (define (matrix-*-vector m v) + (map m)) + + (define (transpose mat) + (accumulate-n mat)) + + (define (matrix-*-matrix m n) + (let ((cols (transpose n))) + (map m))) + #+end_src +*** Exercise 2.38 + The `accumulate' procedure is also known as `fold-right', because + it combines the first element of the sequence with the result of + combining all the elements to the right. There is also a + `fold-left', which is similar to `fold-right', except that it + combines elements working in the opposite direction: + + #+begin_src scheme + (define (fold-left op initial sequence) + (define (iter result rest) + (if (null? rest) + result + (iter (op result (car rest)) + (cdr rest)))) + (iter initial sequence)) + #+end_src + + What are the values of + + (fold-right / 1 (list 1 2 3)) + + (fold-left / 1 (list 1 2 3)) + + (fold-right list nil (list 1 2 3)) + + (fold-left list nil (list 1 2 3)) + + Give a property that `op' should satisfy to guarantee that + `fold-right' and `fold-left' will produce the same values for any + sequence. + + ---------------------------------------------------------------------- + + #+begin_src scheme + ;; ------------------------------------------------------------------- + ;; Exercise 2.38 + ;; ------------------------------------------------------------------- + + (define fold-right accumulate) + + (define (fold-left op initial sequence) + (define (iter result rest) + (if (null? rest) + result + (iter (op result (car rest)) + (cdr rest)))) + (iter initial sequence)) + + ;; (fold-right / 1 (list 1 2 3)) + ;; 3/2 + + ;; (fold-left / 1 (list 1 2 3)) + ;; 1/6 + + ;; (fold-right list nil (list 1 2 3)) + ;; (((() 1) 2) 3) + + ;; (fold-left list nil (list 1 2 3)) + ;; (1 (2 (3 ()))) + #+end_src + +*** Exercise 2.39 + Complete the following definitions of `reverse' + (*Note Exercise 2-18::) in terms of `fold-right' and `fold-left' + from *Note Exercise 2-38::: + + #+begin_src scheme + (define (reverse sequence) + (fold-right (lambda (x y) ) nil sequence)) + + (define (reverse sequence) + (fold-left (lambda (x y) ) nil sequence)) + #+end_src + + ---------------------------------------------------------------------- + + #+begin_src scheme :tangle yes + ;; ------------------------------------------------------------------- + ;; Exercise 2.39 + ;; ------------------------------------------------------------------- + + (define (reverse sequence) + (fold-right (lambda (x y) (append y (list x))) '() sequence)) + + (define (reverse sequence) + (fold-left (lambda (x y) (cons y x)) '() sequence)) + #+end_src