Date post: | 17-Jan-2016 |
Category: |
Documents |
Upload: | amelia-parks |
View: | 224 times |
Download: | 0 times |
מבוא מורחב למדעי המחשב Scheme בשפת
10תרגול
Streams
3.5, pages 316-352
definitions file on web
2
cons, car, cdr
(define s (cons 9 (begin (display 7) 5)))-> prints 7
The display command is evaluated whileevaluating the cons.
(car s) -> 9(cdr s) -> 5
3
cons-stream, stream-car, stream-cdr
(define s (cons-stream 9 (begin (display 7) 5)))
Due to the delay of the second argument, cons-stream does not activate the display command
(stream-car s) -> 9(stream-cdr s) -> prints 7 and returns 5 stream-cdr activates the display whichprints 7, and then returns 5.
4
List enumerate(define (enumerate-interval low high)
(if (> low high) nil
(cons low
(enumerate-interval
(+ low 1) high))))
(enumerate-interval 2 8)
-> (2 3 4 5 6 7 8)
(car (enumerate-interval 2 8))
-> 2
(cdr (enumerate-interval 2 8))
-> (3 4 5 6 7 8)5
Stream enumerate(define (stream-enumerate-interval low high)
(if (> low high) the-empty-stream
(cons-stream low
(stream-enumerate-interval
(+ low 1) high))))
(stream-enumerate-interval 2 8)
-> (2 . #<promise>)
(stream-car (stream-enumerate-interval 2 8))
-> 2
(stream-cdr (stream-enumerate-interval 2 8))
-> (3 . #<promise>)6
List map
(map <proc> <list>)
(define (map proc s) (if (null? s) nil (cons (proc (car s)) (map proc (cdr s)))))
(map square (enumerate-interval 2 8))
-> (4 9 16 25 36 49 64)
7
Stream map
(map <proc> <stream>)
(define (stream-map proc s) (if (stream-null? s) the-empty-stream (cons-stream (proc (stream-car s)) (stream-map proc (stream-cdr s)) )))
(stream-map square (stream-enumerate-interval 2 8))-> (4 . #<promise>)
8
List of squares
(define squares
(map square
(enumerate-interval 2 8)))
squares
-> (4 9 16 25 36 49 64)
(car squares)
-> 4
(cdr squares)
-> (9 16 25 36 49 64)9
Stream of squares
(define stream-squares
(stream-map square
(stream-enumerate-interval 2 8)))
stream-squares
-> (4 . #<promise>)
(stream-car stream-squares)
-> 4
(stream-cdr stream-squares)
-> (9 . #<promise>)10
List reference
(define (list-ref s n)
(if (= n 0) (car s)
(list-ref (cdr s) (- n 1))))
(define squares
(map square
(enumerate-interval 2 8)))
(list-ref squares 3)
-> 25
11
Stream reference
(define (stream-ref s n)
(if (= n 0) (stream-car s)
(stream-ref (stream-cdr s) (- n 1))))
(define stream-squares
(stream-map square
(stream-enumerate-interval 2 8)))
(stream-ref stream-squares 3)
-> 25
12
List filter
(filter <predicate> <list>)
(define (filter pred s) (cond ((null? s) nil) ((pred (car s)) (cons (car s) (filter pred (cdr s)))) (else (filter pred (cdr s)))))
(filter even? (enumerate-interval 1 20))-> (2 4 6 8 10 12 14 16 18 20)
13
Stream filter(stream-filter <predicate> <stream>)
(define (stream-filter pred s) (cond ((stream-null? s) the-empty-stream) ((pred (stream-car s)) (cons-stream (stream-car s) (stream-filter pred (stream-cdr s)))) (else (stream-filter pred (stream-cdr s))))))(stream-filter even?
(stream-enumerate-interval 1 20)) -> (2 . #<promise>)
14
Generalized list map
(generalized-map <proc> <list1> … <listn>)
(define (generalized-map proc . arglists) (if (null? (car arglists)) nil (cons (apply proc (map car arglists)) (apply generalized-map (cons proc (map cdr arglists))))))
(generalized-map + squares squares squares)
-> (12 27 48 75 108 147 192)
15
Generalized stream map
(generalized-stream-map <proc> <stream1> … <streamn>)
(define (generalized-stream-map proc . argstreams) (if (stream-null? (car argstreams)) the-empty-stream (cons-stream (apply proc (map stream-car argstreams)) (apply generalized-stream-map (cons proc (map stream-cdr argstreams))))))
(generalized-stream-map + stream-squares stream-squares stream-squares)-> (12 . #<promise>)
16
List for each
(define (for-each proc s)
(if (null? s) 'done
(begin
(proc (car s))
(for-each proc (cdr s)))))
17
Stream for each
(define (stream-for-each proc s) (if (stream-null? s) 'done (begin (proc (stream-car s)) (stream-for-each proc (stream-cdr s)))))
useful for viewing (finite!) streams(define (display-stream s) (stream-for-each display s))
(display-stream (stream-enumerate-interval 1 20)) -> prints 1 … 20 done
18
Lists(define sum 0)(define (acc x) (set! sum (+ x sum)) sum)
(define s (map acc (enumerate-interval 1 20)))s -> (1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210) sum -> 210(define y (filter even? s))y -> (6 10 28 36 66 78 120 136 190 210)
sum -> 210
(define z (filter (lambda (x) (= (remainder x 5) 0)) s))z -> (10 15 45 55 105 120 190 210) sum -> 210
19
(list-ref y 7)
-> 136 sum -> 210
(display z)
-> prints (10 15 45 55 105 120 190 210)
sum -> 210
20
Streams
(define sum 0)(define (acc x) (set! sum (+ x sum)) sum)
(define s (stream-map acc (stream-enumerate-interval 1 20)))s -> (1 . #<promise>) sum -> 1
(define y (stream-filter even? s))y -> (6 . #<promise>) sum -> 6
(define z (stream-filter (lambda (x) (= (remainder x 5) 0)) s))z -> (10 . #<promise>) sum -> 10
21
(stream-ref y 7)
-> 136 sum -> 136
(display-stream z)
-> prints 10 15 45 55 105 120 190 210 done
sum -> 210
22
Defining streams implicitlyby delayed evaluation
Suppose we needed an infinite list of Dollars.We can(define bill-gates (cons-stream ‘dollar bill-gates))
If we need a Dollar we can take the car
(stream-car bill-gates) -> dollar
The cdr would still be an infinite list of
Dollars.
(stream-cdr bill-gates)->(dollar . #<promise>)23
24
Infinite Streams
Formulate rules defining
infinite series
wishful thinking is key
24
1,ones
(define ones
(cons-stream 1 ones))
1,1,1,… = ones =
25
2,twos(define twos (cons-stream 2 twos))
ones + onesadding two infinite series of ones(define twos (stream-map + ones ones))
2 * oneselement-wise operations on an infinite series of ones(define twos (stream-map (lambda (x) (* 2 x)) ones)) or (+ x x)
2,2,2,… = twos =
26
1,2,3,… = integers =
1,ones + integers
1,1,1…
1,2,3,…
2,3,4,…
(define integers
(cons-stream 1
(stream-map + ones integers)))
+
27
0,1,1,2,3,… = fibs =
0,1,fibs + (fibs from 2nd position) 0,1,1,2,… 1,1,2,3,… 1,2,3,5,…
(define fibs (cons-stream 0 (cons-stream 1 (stream-map + fibs (stream-cdr fibs)))))
+
28
1,doubles + doubles
1,2,4,8,…
1,2,4,8,…
2,4,8,16,…
(define doubles (cons-stream 1
(stream-map + doubles doubles)))
1,2,4,8,… = doubles =
+
29
1,2 * doubles
(define doubles (cons-stream 1
(stream-map (lambda (x) (* 2 x)) doubles)))
or (+ x x)
1,2,4,8,… = doubles =
30
1,factorials * integers from 2nd
position 1, 1*2, 1*2*3,… 2, 3, 4,… 1*2,1*2*3,1*2*3*4,…
(define factorials (cons-stream 1 (stream-map * factorials (stream-cdr integers))))
1,1x2,1x2x3,... = factorials =
x
31
(1),(1 2),(1 2 3),… = runs =
(1), append runs with a list of integers from 2nd position
(1), (1 2), (1 2 3),… (2), (3), (4),… (1 2),(1 2 3),(1 2 3 4),…
(define runs (cons-stream (list 1) (stream-map append runs (stream-map list (stream-cdr integers)))))
append
32
a0,a0+a1,a0+a1+a2,… = partial sums =
a0,partial sums + (stream from 2nd pos) a0, a0+a1, a0+a1+a2,… a1, a2, a3,… a0+a1,a0+a1+a2,a0+a1+a2+a3,…
(define (partial-sums a) (cons-stream (stream-car a) (stream-map + (partial-sums a) (stream-cdr a))))
+
33
34
Partial Sums (cont.)
(define (partial-sums a)(define sums
(cons-stream (stream-car a) (stream-map + sums (stream-cdr a)))) sums)
This implementation is more efficient since it uses the stream itself rather than recreating it recursively
34
Approximating the natural logarithm of 2
1,-1,1,-1,…(define alternate
(cons-stream 1 (stream-map - alternate)))
1/1,-1/2,1/3,…(define ln2-series (stream-map / alternate integers))
4
1
3
1
2
112ln
35
Approximating the natural logarithm of 2
(define ln2 (partial-sums ln2-series))1,1/2,5/6,7/12,…
using Euler’s sequence acceleration(define ln2-euler (euler-transform ln2))7/10,29/42,25/36,457/660,…
using super acceleration(define ln2-accelerated (accelerated-sequence euler-transform ln2))1,7/10,165/238,380522285/548976276,…
4
1
3
1
2
112ln
36
Power series
2345234232
15432
xxxxxex
2342
1cos42 xx
x
234523
sin53 xx
xx
37
Power series
The series
is represented as the stream whoseelements are the coefficient
a0,a1,a2,a3…
33
2210 xaxaxaa
38
Power series integral
The integral of the series
is the series
where c is any constant
33
2210 xaxaxaa
43
32
210 4
1
3
1
2
1xaxaxaxac
39
Power series integral
Input: representing a powerseries
Output: coefficients of the
non-constant term of the integral of theseries
(define (integrate-series a) (stream-map / a integers))
,4
1,
3
1,
2
1, 3210 aaaa
,,,, 3210 aaaa
40
Exponent seriesThe function is its own derivative and the integral of are the sameexcept for the constant term
According to this rule, a definition ofthe exponent series is:(define exp-series (cons-stream 1 (integrate-series exp-series)))
which results in 1,1,1/2,1/6,1/24,1/120…as expected
xexxe xe
10 e
2345234232
15432
xxxxxex
41
Sine and cosine seriesThe derivate of sine is cosineThe derivate of cosine is (- sine)
(define cosine-series (cons-stream 1 (stream-map – (integrate-series sine-series))))
(define sine-series (cons-stream 0
(integrate-series cosine-series)))
Which results incosine-series: 1,0,-1/2,0,1/24,…sine-series: 0,1,0,-1/6,0,1/120,…As expected
2342
1cos42 xx
x
234523
sin53 xx
xx42
RepeatInput: procedure f of one argument, number of repetitionsOutput: f*…*f, n times
(define (repeated f n) (if (= n 1) f (compose f (repeated f (- n 1)))))
(define (compose f g) (lambda (x) (f (g x))))
43
Repeat streamf,f*f,f*f*f,… = repeat =f,compose f,f,f,… with repeat
(define f-series (cons-stream f f-series))
(define stream-repeat (cons-stream f (stream-map compose f-series stream-repeat)))
We would like f to be a parameter44
Repeat streamf,f*f,f*f*f,… = repeat =f,compose f,f,f,… with repeat
(define (repeated f) (define f-series (cons-stream f f-series)) (define stream-repeat (cons-stream f (stream-map compose f-series stream-repeat))) stream-repeat)
45
Interleave
1,1,1,2,1,3,1,4,1,5,1,6,…(interleave ones integers)
s0,t0,s1,t1,s2,t2,… interleave =s0,interleave (t, s from 2nd position)(define (interleave s t) (if (stream-null? s) t (cons-stream (stream-car s) (interleave t (stream-cdr s)))))
46