<SICP> 1.3

1.3.scm

#lang scheme
(define (average . numbers)  
    (/ (apply + numbers) (length numbers)))

(define tolerance 0.000001)

(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 (fixed-point-avg f first-guess)
  (define (close-enough? v1 v2)
    (< (abs (- v1 v2)) tolerance))
  (define (try guess)
    (newline)
    (display guess)
    (let ((next (f guess)))
      (if (close-enough? guess next)
          next
          (try (average next guess)))))
  (try first-guess))

(define dx 0.000001)

(define (deriv g)
  (lambda (x)
    (/ (- (g (+ x dx)) (g x))
       dx)))

(define (newton-transform g)
  (lambda (x)
    (- x (/ (g x) ((deriv g) x)))))

(define (newtons-method g guess)
  (fixed-point (newton-transform g) guess))

(define (fi x)
  (+ 1 (/ 1.0 x)))

(define (f x)
  (/ (log 1000) (log x)))

(define (sf y)
  (/ 2 y))

#! (fixed-point f 1.1)
#! (fixed-point-avg f 1.1)


(define (cont-frac n d k)
  (define (iter current result)
    (if (<= current 0)
        result
        (iter (- current 1) (frac current result))))
  (define (frac current laster)
    (/ (n current) (+ (d current) laster)))
  (iter k (d k)))
(cont-frac (lambda (i) 1.0)
           (lambda (i) 1.0)
           100)
#! 1.40

(cont-frac (lambda (i) 1.0)
           (lambda (i) (if (= (remainder i 3) 2) (* (+ (floor (/ i 3)) 1) 2) 1))
           100)

#! 1.41
(define (double f)
  (lambda (x)
    (f (f x))))

(((double (double double)) add1) 5)

#! 1.42
(define (compose f g)
  (lambda (x)
    (f (g x))))

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

((compose square add1) 6)

#! 1.43
(define (repeated f time)
  (define (iter f-result now)
    (if (<= now 1)
        f-result
        (iter (compose f f-result) (- now 1))))
  (iter f time))
((repeated square 2) 5)

#! 1.46
(define (iterative-improve good-enough? improve)
  (define (f guess)
    (if (good-enough? guess)
        guess
        (f (improve guess))))
  f)
#! 重写平方根
(define (sqrt-improve y)
  (define (good-enough? x)
    (< (abs (- (square x) y)) 0.00001))
  (define (improve guess)
    (average guess (/ y guess)))
  ((iterative-improve good-enough? improve) y))

(sqrt-improve 2.0)

#! 重写不动点
(define (fixed-point-improve f y)
  (define (close-enough? v)
    (< (abs (- v (f v))) 0.00001))
  ((iterative-improve
    close-enough?
    (lambda (x)
      (f x))) y))



(fixed-point cos 1.0)
(fixed-point-improve cos 1.0)