1. מבוא מורחב למדעי המחשב בשפת Scheme תרגול 12

2. Outline Streams Infinite streams Stream implementation Questions from exams 2

3. Streams 3.5, pages 316-352 Definitions file on web 3

4. cons, car, cdr (define s (cons 9 (begin (display 7) 5))) -> prints 7 The display command is evaluated while evaluating the cons. (car s) -> 9 (cdr s) -> 5 4

5. 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 which prints 7, and then returns 5. 5

6. 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) 6

7. 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. # ) (stream-car (stream-enumerate-interval 2 8)) -> 2 (stream-cdr (stream-enumerate-interval 2 8)) -> (3. # ) 7

8. List map (map ) (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) 8

9. Stream map (map ) (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. # ) 9

10. 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) 10

11. Stream of squares (define stream-squares (stream-map square (stream-enumerate-interval 2 8))) stream-squares -> (4. # ) (stream-car stream-squares) -> 4 (stream-cdr stream-squares) -> (9. # ) 11

12. 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 12

13. 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 13

14. List filter (filter ) (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) 14

15. Stream filter (stream-filter ) (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. # ) 15

16. Generalized list map (generalized-map … ) (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) 16

17. Generalized stream map (generalized-stream-map … ) (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. # ) 17

18. List for each (define (for-each proc s) (if (null? s) 'done (begin (proc (car s)) (for-each proc (cdr s))))) 18

19. 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 19

20. 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 20

21. (list-ref y 7) -> 136 sum -> 210 (display z) -> prints (10 15 45 55 105 120 190 210) sum -> 210 21

22. Streams (define sum 0) (define (acc x) (set! sum (+ x sum)) sum) (define s (stream-map acc (stream-enumerate-interval 1 20))) s -> (1. # )sum -> 1 (define y (stream-filter even? s)) y -> (6. # )sum -> 6 (define z (stream-filter (lambda (x) (= (remainder x 5) 0)) s)) z -> (10. # )sum -> 10 22

23. (stream-ref y 7) -> 136 sum -> 136 (display-stream z) -> prints 10 15 45 55 105 120 190 210 done sum -> 210 23

24. Defining streams implicitly by 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. # ) 24

25. 25 Infinite Streams Formulate rules defining infinite series wishful thinking is key 25

26. 1,ones (define ones (cons-stream 1 ones)) 1,1,1,… = ones = 26

27. 2,twos (define twos (cons-stream 2 twos)) ones + ones adding two infinite series of ones (define twos (stream-map + ones ones)) 2 * ones element-wise operations on an infinite series of ones (define twos (stream-map (lambda (x) (* 2 x)) ones)) or (+ x x) 2,2,2,… = twos = 27

28. 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))) + 28

29. 0,1,1,2,3,… = fibs = 0,1,fibs + (fibs from 2 nd 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))))) + 29

30. 1,doubles + doubles 1,2,4,8,… 2,4,8,16,… (define doubles (cons-stream 1 (stream-map + doubles doubles))) 1,2,4,8,… = doubles = + 30

31. 1,2 * doubles (define doubles (cons-stream 1 (stream-map (lambda (x) (* 2 x)) doubles))) or (+ x x) 1,2,4,8,… = doubles = 31

32. 1,factorials * integers from 2 nd 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 32

33. (1),(1 2),(1 2 3),… = runs = (1), append runs with a list of integers from 2 nd 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 33

34. a0,a0+a1,a0+a1+a2,… = partial sums = a0,partial sums + (stream from 2 nd 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)))) + 34

35. 35 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 35

36. Repeat Input: procedure f of one argument, number of repetitions Output: 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)))) 36

37. Repeat stream f,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 parameter 37

38. Repeat stream f,f*f,f*f*f,… = repeat = f,compose f,f,f,… with repeat (define (make-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) 38

39. 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 2 nd position) (define (interleave s t) (if (stream-null? s) t (cons-stream (stream-car s) (interleave t (stream-cdr s))))) 39

40. מימוש streams

41. מימוש stream מנגנוני force/delay delay הוא special form 41 (delay ) => (lambda () ) (force ) => (( )) => ((lambda () )) =>

42. מימוש stream memoization 42 (define (memo-proc proc) (let ((already-run? #f) (result #f)) (lambda () (if (not already-run?) (begin (set! result (proc)) (set! already-run? #t) result) result))))

43. מימוש stream הגדרה מתוקנת עבור delay: ולכן: 43 (delay ) => (memo-proc (lambda () )) (cons-stream a b) => (cons a (delay b))

44. streams 44 (define ones (cons-stream 1 (begin (set! x (+ x 1)) ones)) GE x:0

45. streams 45 (define ones (cons 1 (delay (begin (set! x (+ x 1)) ones))) GE x:0

46. streams 46 GE x:0 (define ones (cons 1 (memo-proc(lambda ()...)))

47. streams 47 GE x:0 ones: (define ones (cons 1 (memo-proc(lambda ()...))) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…)

48. streams 48 GE x:0 ones: (stream-cdr ones) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…)

49. streams 49 GE x:0 ones: (force (cdr ones)) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…)

50. streams 50 GE x:0 ones: ((cdr ones)) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…)

51. streams 51 GE x:0 ones: (not already-run) is #t => (set! result (proc)) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…)

52. streams 52 GE x:0 ones: (begin (set! x (+ x 1)) ones) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…)

53. streams 53 GE x:01 ones: (begin (set! x (+ x 1)) ones) 1 proc: p:- b:… already-run:#f result: #f p:- b:(begin…) /

54. streams 54 GE x:01 ones: (set! already-run #t) 1 proc: p:- b:… already-run:#f #t result: #f p:- b:(begin…) /

55. streams 55 GE x:01 ones: (stream-cdr ones) 1 proc: p:- b:… already-run:#f #t result: #f p:- b:(begin…) /

56. streams 56 GE x:01 ones: ((cdr ones)) 1 proc: p:- b:… already-run:#f #t result: #f p:- b:(begin…) /

57. streams 57 GE x:01 ones: (not already-run) is #f => result 1 proc: p:- b:… already-run:#f #t result: #f p:- b:(begin…) /

58. streams 58 GE x:01 ones: 1 proc: p:- b:… already-run:#f #t result: #f p:- b:(begin…) /

59. Questions from Exams 59 Extra

60. convert יש לממש את הפונקציה (convert num base). הפונקציה מחזירה רשימה המייצגת את ספרותיו של num בבסיס base בסדר הפוך (ספרת האחדות ראשונה) 60 (define (convert num base) (if (= num 0) '() ______________________________ ______________________________ )) (cons (remainder num base) (convert (quotient num base) base))

61. convert-all - numbers זרם (אולי אינסופי) של מספרים. bases - רשימה של מספרים. ממשו את הפונקציה (convert-all numbers bases) שמחזירה רשימה של זרמים כך שהזרם ה- i ברשימה מכיל את הייצוג של כל המספרים ב-numbers לפי המספר ה-i ב-bases (כל ייצוג כזה הוא רשימה בעצמו). 61 > (define N (cons-stream 5 (cons-stream 11 (cons-stream 35 …)))) > (define B (list 2 3 4)) > (convert-all N B) ([(1 0 1)(1 1 0 1)(1 1 0 0 0 1)…] [(2 1)(2 0 1)(2 2 0 1)…] [(1 1)(3 2)(3 0 2)…])

62. convert-all 62 (define (convert-all numbers bases) __________________________________ __________________________________ ) (map (lambda (base) (stream-map (lambda (x) (convert x base)) numbers)) bases))

63. common-digits-all ממשו את הפונקציה (common-digits-all numbers bases). הפונקציה מחזירה רשימה של זרמים המכילים #t ו-#f לפי הכלל הבא: במקום ה-k בזרם ה-i יופיע #t אם בייצוג לפי בסיס base i שלnumbers k ו- numbers k+1 יש סיפרה משותפת. אחרת יופיע #f. ניתן להשתמש בפונקצית העזר (common-digit? L1 L2) המחזירה #t אם יש ספרה משותפת ל-L1 ו- L2,ו-#f אחרת. 63

64. common-digit-all 64 (define (common-digit-all nums bases) __________________________________ __________________________________ __________________________________ ) (map (lambda (base) (stream-map (lambda (n1 n2) (common-digit? (convert n1 base) (convert n2 base))) (stream-cdr numbers) numbers)) bases))

65. in-sorted? ממשו את הפונקצייה in-sorted? המקבלת מספר ו-stream אינסופי של מספרים ממוינים בסדר עולה. הפונקציה מחזירה #t אם המספר שהיא מקבלת נמצא בתוך ה-stream ו- #f אחרת. לדוגמא: (in-sorted? 13 fibs) צריך להחזיר #t כי 13 הינו מספר פיבונצ'י ו- (in-sorted? 14 stream-of-fibs) צריך להחזיר #f כי 14 איננו מספר פיבונצ'י. 65

66. in-sorted? 66 (define in-sorted? (lambda (x stream) (let ((e (__________ stream))) (or (= x e) (______ (____ x e) (__________ x (__________ stream)) ))))) stream-car and > in-sorted? stream-cdr

67. merge-inc ממשו את הפונקצייה merge-inc המקבלת שני streams אינסופיים של מספרים ממוינים בסדר עולה. הפונקציה מחזירה stream אינסופי ממוין בסדר עולה המתקבל ממיזוגם של ה- streams הנתונים. אם ישנו מספר המשותף לשני ה-streams אזי הוא יופיע פעמיים ב-stream התוצאה. לדוגמא: (merge-inc fibs (stream-map (lambda (x) (* x 10)) fibs))) צריך להחזיר [0 0 1 1 2 3 5 8 10 10 ] 67

68. merge-inc 68 (define (merge-inc s1 s2) (let ((e1 (__________ s1)) (e2 (__________ s2))) (if (___ e1 e2) (___________ e1 (merge-inc (__________ s1) s2)) (___________ e2 (merge-inc s1 (__________ s2)) ))))) stream-car < cons-stream stream-cdr cons-stream stream-cdr

69. stream-conv נגדיר קונבולוציה בין רשימת מספרים(a 1 a 2.. a n ) ו-stream אינסופי של מספרים [b 1 b 2 b 3 …] להיות stream אינסופי של מספרים[c 1 c 2 c 3 … ] כך ש- c i = a 1 *b i +a 2 *b i+1... a n *b i+n ממשו את הפונקצייהstream-conv המחשבת את זרם הקונבולוציה עפ"י ההגדרה הנ"ל. לדוגמא: (stream-conv ‘(1 2) fibs) צריך להחזיר [2 3 5 8 13 21 34 55 89……] 69

70. stream-conv 70 (define (stream-conv lst str) (define (first-term lst str) (if (null? lst) ___ (___ (* (car lst) (__________ str)) (first-term (__________ lst) (__________ str) )))) (___________ (first-term lst str) (stream-conv lst (__________ str)) )) 0 + stream-car cdr stream-cdr cons-stream stream-cdr

71. stream-conv מהם ערכי x1 ו - x2 בסוף השערוך? 71 (define x1 0) (define x2 0) (define str1 (cons-stream 1 (begin (set! x1 (+ x1 1)) str1))) (define (integers n) (cons-stream n (begin (set! x2 (+ x2 1)) (integers (+ n 1))))) (define str2 (integers 1)) (define c1 (stream-conv '(1 1) str1)) (define c2 (stream-conv '(1 1) str2)) / 1 / 2

72. מודל הסביבות ציירו את מהלך השערוך של הביטוי הבא במודל הסביבות. מהי תוצאת השערוך? 72 (let ((f (lambda (x) (+ x 3)))) (define y (lambda (g) (lambda (y) (f (g y))))) ((y f) 3))

73. מודל הסביבות 73 (let ((f (lambda (x) (+ x 3))))...) => ((lambda (f)...) (lambda (x) (+ x 3) GE

74. מודל הסביבות 74 ((lambda (f)...) (lambda (x) (+ x 3) GE p: f b: (define y … L1

75. מודל הסביבות 75 (L1 (lambda (x) (+ x 3) GE p: f b: (define y … L1 p: x b:(+ x 3) L2

76. מודל הסביבות 76 (L1 L2) GE p: x b:(+ x 3) p: f b: (define y … L2L1

77. מודל הסביבות 77 (L1 L2) GE p: x b:(+ x 3) p: f b: (define y … f: L2L1 E1

78. מודל הסביבות 78 (define y (lambda (g) (lambda (y) (f (g y))))) | E1 GE p: x b:(+ x 3) p: f b: (define y … f: y: p: g b:(lambda…) L2L1 L3 E1

79. מודל הסביבות 79 ((y f) 3) | E1 GE p: x b:(+ x 3) p: f b: (define y … f: y: p: g b:(lambda…) L2L1 L3 E1

80. מודל הסביבות 80 GE p: x b:(+ x 3) p: f b: (define y … f: y: p: g b:(lambda…) L2L1 L3 E1 ((L3 f) 3) | E1

81. מודל הסביבות 81 GE p: x b:(+ x 3) p: f b: (define y … f: y: p: g b:(lambda (y) (f (g y))) g: L2L1 L3 E1E2 ((L3 f) 3) | E1

82. מודל הסביבות 82 GE p: x b:(+ x 3) p: f b: (define y … f: y: p: g b:(lambda (y) (f (g y))) g: L2L1 L3 E1E2 (lambda (y) (f (g y)) | E2

83. מודל הסביבות 83 (L4 3) | E1 GE p: x b:(+ x 3) p: f b: (define y … f: y: p: g b:(…) g: p: y b:(f (g y)) L2L1 L3 L4 E1E2

84. מודל הסביבות 84 (L4 3) | E1 GE p: x b:(+ x 3) p: f b: … f: y: p: g b:(…) g: p: y b:(f (g y)) L1L2 L3 L4 y:3 E1E2E3

85. מודל הסביבות 85 (f (g y)) | E3 => (f 6) | E3 => 9 GE p: x b:(+ x 3) p: f b: … f: y: p: g b:(…) g: p: y b:(f (g y)) L1L2 L3 L4 y:3 E1E2E3