Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #lang racket
- (require "sicp-3-5-streams.rkt") ; for all the book code from 3.5.1 and 3.5.2
- ;;;;;;;;;;
- ;; 3.53 ;;
- ;;;;;;;;;;
- (define powers
- (cons-stream 1
- (add-streams powers powers)))
- (define (display-ten s)
- (for ([i 10])
- (printf "~a " (my-stream-ref s i)))
- (printf "~n"))
- (display-ten powers) ; should be 1 2 4 8 etc
- ;; 1 2 4 8 16 32 64 128 256 512
- ;;;;;;;;;;
- ;; 3.54 ;;
- ;;;;;;;;;;
- (define (mul-streams s1 s2)
- (my-stream-map * s1 s2))
- (define factorials
- (cons-stream 1
- (mul-streams factorials integers)))
- (display-ten factorials)
- ;; 1 1 2 6 24 120 720 5040 40320 362880
- ;;;;;;;;;;
- ;; 3.55 ;;
- ;;;;;;;;;;
- (define(partial-sums s)
- (cons-stream (stream-car s)
- (add-streams (stream-cdr s)
- (partial-sums s))))
- (display-ten (partial-sums integers))
- ;; 1 3 6 10 15 21 28 36 45 55
- ;;;;;;;;;;
- ;; 3.56 ;;
- ;;;;;;;;;;
- (define (merge s1 s2)
- (cond [(stream-null? s1) s2]
- [(stream-null? s2) s1]
- [else
- (define s1car (stream-car s1))
- (define s2car (stream-car s2))
- (cond [(< s1car s2car)
- (cons-stream s1car (merge (stream-cdr s1) s2))]
- [(> s1car s2car)
- (cons-stream s2car (merge s1 (stream-cdr s2)))]
- [else
- (cons-stream s1car
- (merge (stream-cdr s1)
- (stream-cdr s2)))])]))
- (define hamming
- (cons-stream 1
- (merge (scale-stream hamming 2)
- (merge (scale-stream hamming 3)
- (scale-stream hamming 5)))))
- (display-ten hamming)
- ;; 1 2 3 4 5 6 8 9 10 12
- ;; Let's look at the first ten >= 100.
- (display-ten (my-stream-filter (lambda (x) (>= x 100)) hamming))
- ;; 100 108 120 125 128 135 144 150 160 162
- ;;;;;;;;;;
- ;; 3.57 ;;
- ;;;;;;;;;;
- (define (count-fibs n)
- (define num 0)
- (define (plus a b)
- (set! num (add1 num))
- (+ a b))
- (define (count-add-streams s1 s2)
- (my-stream-map plus s1 s2))
- (define fib-stream
- (cons-stream 0
- (cons-stream 1
- (count-add-streams (stream-cdr fib-stream)
- fib-stream))))
- (define result (my-stream-ref fib-stream n))
- (printf "~a ~a ~a ~n" n result num)
- result)
- ;; MEMOIZED
- (for ([i 20]) (count-fibs i))
- ;; n result number of additions
- ;; 0 0 0
- ;; 1 1 0
- ;; 2 1 1
- ;; 3 2 2
- ;; 4 3 3
- ;; 5 5 4
- ;; 6 8 5
- ;; 7 13 6
- ;; 8 21 7
- ;; 9 34 8
- ;; 10 55 9
- ;; 11 89 10
- ;; 12 144 11
- ;; 13 233 12
- ;; 14 377 13
- ;; 15 610 14
- ;; 16 987 15
- ;; 17 1597 16
- ;; 18 2584 17
- ;; 19 4181 18
- ;; NOT MEMOIZED
- ;; n result number of additions
- ;; 0 0 0
- ;; 1 1 0
- ;; 2 1 1
- ;; 3 2 3
- ;; 4 3 7
- ;; 5 5 14
- ;; 6 8 26
- ;; 7 13 46
- ;; 8 21 79
- ;; 9 34 133
- ;; 10 55 221
- ;; 11 89 364
- ;; 12 144 596
- ;; 13 233 972
- ;; 14 377 1581
- ;; 15 610 2567
- ;; 16 987 4163
- ;; 17 1597 6746
- ;; 18 2584 10926
- ;; 19 4181 17690
- ;; Note that the number of additions, and thus the time complexity, is almost
- ;; doubling each time. That is because un-memoized recursive fibonacci is
- ;; O(phi ^ n) as we learned in exercise 1.31.
- ;;;;;;;;;;
- ;; 3.58 ;;
- ;;;;;;;;;;
- (define (expand num den radix)
- (cons-stream
- (quotient (* num radix) den)
- (expand (remainder (* num radix) den) den radix)))
- (display-ten (expand 1 7 10)) ; 1 / 7 = 0.1428571428...
- ;; 1 4 2 8 5 7 1 4 2 8
- (display-ten (expand 3 8 10)) ; 3 / 8 = 0.375
- ;; 3 7 5 0 0 0 0 0 0 0
- ;; Expand produces the digits in the base radix expansion of num / den.
- ;;;;;;;;;;
- ;; 3.59 ;;
- ;;;;;;;;;;
- (define (integrate-series s)
- (my-stream-map / s integers))
- (define exp-series
- (cons-stream 1 (integrate-series exp-series)))
- (display-ten exp-series) ; should be 1 / n!
- ;; 1 1 1/2 1/6 1/24 1/120 1/720 1/5040 1/40320 1/362880
- (define cosine-series ; derivative of cosine is -1 * sine
- (cons-stream 1 (scale-stream
- (integrate-series sine-series)
- -1)))
- (define sine-series ; derivative of sine is cosine
- (cons-stream 0 (integrate-series cosine-series)))
- (display-ten cosine-series) ; 2 * n term should be (-1) ^ n / (2 * n)!
- ;; 1 0 -1/2 0 1/24 0 -1/720 0 1/40320 0
- (display-ten sine-series) ; 2 * n + 1 term should be (-1) ^ n / (2 * n + 1)!
- ;; 0 1 0 -1/6 0 1/120 0 -1/5040 0 1/362880
- ;;;;;;;;;;
- ;; 3.60 ;;
- ;;;;;;;;;;
- (define (mul-series s1 s2)
- (cons-stream (* (stream-car s1)
- (stream-car s2))
- (add-streams (scale-stream (stream-cdr s2) (stream-car s1))
- (mul-series s2 (stream-cdr s1)))))
- ;; The idea is:
- ;; (a0 + a1 * x + a2 * x ^ 2 + ...) * (b0 + b1 * x + b2 * x ^ 2 + ...)
- ;; = a0 * (b0 + b1 * x + b2 * x ^ 2 + ...)
- ;; + (a1 * x + a2 * x ^ 2 + ...) * (b0 + b1 * x + b2 * x ^ 2 + ...)
- (display-ten (add-streams (mul-series cosine-series cosine-series)
- (mul-series sine-series sine-series)))
- ;; 1 0 0 0 0 0 0 0 0 0
- (display-ten (mul-series integers integers)) ; should be 1 4 10 20 35 etc
- ;; 1 4 10 20 35 56 84 120 165 220
- ;;;;;;;;;;
- ;; 3.61 ;;
- ;;;;;;;;;;
- (define (invert-unit-series s)
- (unless (= (stream-car s) 1)
- (error "Constant term must be 1 -- INVERT-UNIT-SERIES" s))
- (cons-stream 1
- (scale-stream (mul-series (stream-cdr s)
- (invert-unit-series s))
- -1)))
- (display-ten (invert-unit-series ones))
- ;; 1 -1 0 0 0 0 0 0 0 0
- ;; This says that the sum of the geometric series 1 + x + x ^ 2 + x ^ 3 + ...
- ;; = 1 / (1 - x) but expressed with inverses.
- ;;;;;;;;;;
- ;; 3.62 ;;
- ;;;;;;;;;;
- (define (div-series s1 s2)
- (when (zero? (stream-car s2))
- (error "Constant term of second series must be non-zero -- DIV-SERIES" s2))
- (scale-stream
- (mul-series s1
- (invert-unit-series (scale-stream s2
- (/ 1 (stream-car s2)))))
- (stream-car s2)))
- (define tangent-series (div-series sine-series cosine-series))
- (display-ten tangent-series) ; should be 0 1 0 1/3 0 2/15 0 17/315 etc
- ;; 0 1 0 1/3 0 2/15 0 17/315 0 62/2835
Add Comment
Please, Sign In to add comment