new

ch1/ex35.scm

@@ -0,0 +1,15 @@
+(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))
+
+;; close enough
+(display (fixed-point (lambda (x) (+ 1 (/ 1 x))) 1.0))

ch1/ex36.scm

@@ -0,0 +1,18 @@
+(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
+        (begin (display guess)
+               (newline)
+               (try next)))))
+  (try first-guess))
+
+(define (x-to-the-x y)
+  (fixed-point (lambda (x) (/ (log y) (log x)))
+               10.0))

ch1/ex37.scm

@@ -0,0 +1,13 @@
+(define (cont-frac n d k)
+  (define (loop res t)
+    (if (eq? t 0)
+      res
+      (loop (/ (n t)
+               (+ (d t) res))
+            (- t 1))))
+  (loop 0 k))
+
+(define (cont-frac-rec n d k)
+  (if (eq? k 0)
+    0
+    (/ (n 1) (+ (d 1) (cont-frac-rec n d (- k 1))))))

ch1/ex38.scm

@@ -0,0 +1,16 @@
+(define (cont-frac n d k)
+  (define (loop res t)
+    (if (eq? t 0)
+      res
+      (loop (/ (n t)
+               (+ (d t) res))
+            (- t 1))))
+  (loop 0 k))
+
+(define (e-euler k)
+  (+ 2.0 (cont-frac (lambda (i) 1.0)
+                    (lambda (i)
+                      (if (eq? (remainder i 3) 2)
+                        (/ (+ i 1) 1.5)
+                        1))
+                    k)))

ch1/ex39.scm

@@ -0,0 +1,17 @@
+(define (cont-frac n d k)
+  (define (loop res t)
+    (if (eq? t 0)
+      res
+      (loop (/ (n t)
+               (+ (d t) res))
+            (- t 1))))
+  (loop 0 k))
+
+(define (tan-cf x k)
+  (cont-frac (lambda (i)
+               (if (eq? i 1)
+                 x
+                 (- (* x x))))
+             (lambda (i)
+               (- (* i 2) 1))
+             k))

ch1/procedures-as-general-methods.scm

@@ -0,0 +1,43 @@
+(define (search f neg-point pos-point)
+  (let ((midpoint (average neg-point pos-point)))
+    (if (close-enough? neg-point pos-point)
+      midpoint
+      (let ((test-value (f midpoint)))
+        (cond ((positive? test-value)
+               (search f neg-point midpoint))
+              ((negative? test-value)
+               (search f midpoint pos-point))
+              (else midpoint))))))
+
+(define (average x y)
+  (/ (+ x y) 2))
+
+(define (close-enough? x y)
+  (< (abs (- x y)) 0.001))
+
+(define (half-interval-method f a b)
+  (let ((a-value (f a))
+        (b-value (f b)))
+    (cond ((and (negative? a-value) (positive? b-value))
+           (search f a b))
+          ((and (negative? b-value) (positive? a-value))
+           (search f b a))
+          (else
+            (error "Values are not of opposite sign" a b)))))
+
+(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 (nice-sqrt x)
+  (fixed-point (lambda (y) (average y (/ x y)))
+               1.0))

ch1/procedures-as-returned-values.scm

@@ -0,0 +1,26 @@
+(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 x y)
+  (/ (+ x y) 2))
+
+(define (average-damp f)
+  (lambda (x) (average x (f x))))
+
+(define (nice-sqrt x)
+  (fixed-point (average-damp (lambda (y) (/ x y)))
+               1.0))
+
+(define (cube-root x)
+  (fixed-point (average-damp (lambda (y) (/ x (square y))))
+               1.0))