1 / 46

CS220 Programming Principles

CS220 Programming Principles. 프로그래밍의 이해 2002 가을학기 Class 13: Streams 한 태숙. Stream Data Abstraction. ; stream - a sequence of state in time ; list with delayed evaluation ; Delayed List ; recursive process with list (define (sum-prime a b) (accumulate + 0

jereni
Download Presentation

CS220 Programming Principles

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS220Programming Principles 프로그래밍의 이해 2002 가을학기 Class 13: Streams 한 태숙

  2. Stream Data Abstraction ; stream - a sequence of state in time ; list with delayed evaluation ; Delayed List ; recursive process with list (define (sum-prime a b) (accumulate + 0 (filter prime? (enumerate-interval a b)))) ; requires many copies of list

  3. List with Iterative Style (define sum-primes a b) (define (iter count accum) (cond ((> count b) accum) ((prime? count) (iter (+ count 1)(+ count accum))) (else (iter (+ count 1) accum)))) (iter a 0)) ; no need to copy the list ; necessary part of the list are traversed ; no intermediate storage are required

  4. Inefficiency in using list ; get the second prime in the interval given (car (cdr (filter prime? (enumerate-interval 10000 1000000)))) ;With Streams ;We can formulate programs elegantly as ; sequence manipulations ; while attaining the efficiency of ; incremental computation. (stream-car (cons-stream x y)) == x (stream-cdr (cons-stream x y)) == y the-empty-stream, stream-null?

  5. List HOPs to Stream HOPs (I) (define (list-ref lst n) (if (= n 0) (car lst) (list-ref (cdr lst) (- n 1)))) (define (stream-ref s n) (if (= n 0) (stream-car s) (stream-ref (stream-cdr s) (- n 1))))

  6. List HOPs to Stream HOPs (II) (define (map proc lst) (if (null? lst) ’() (cons (proc (car lst)) (map proc (cdr lst))))) (define (stream-map proc s) (if (stream-null? s) the-empty-stream (cons-stream (proc (stream-car s)) (stream-map proc (stream-cdr s)))))

  7. List HOPs to Stream HOPs (III) (define (filter pred lst) (cond ((null? lst) ’()) ((pred (car lst)) (cons (car lst) (filter pred (cdr lst)))) (else (filter pred (cdr lst))))) (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)))))

  8. List HOPs to Stream HOPs (IV) (define (enum-interval low high) (if (> low high) ’() (cons low (enum-interval (+ low 1) high)))) (define (enumerate-interval low high) (if (> low high) the-empty-stream (cons-stream low (enumerate-interval (+ low 1) high))))

  9. List HOPs to Stream HOPs (V) (define (stream-for-each proc s) (if (stream-null? s) ’done (begin (proc (stream-car s)) (stream-for-each proc (stream-cdr s))))) (define (display-stream s) (stream-for-each display-line s)) (define (display-line x) (newline) (display x))

  10. List HOPs to Stream HOPs (VI) (define (accumulate-stream combiner init s) (if (stream-null? s) init (combiner (stream-car s) (accumulate-stream combiner init (stream-cdr s)))))

  11. Program without Iteration (define (sum-odd-square from to) (accumulate-stream + 0 (stream-map square (stream-filter odd? (enumerate-interval from to))))) (define (integral f lo hi dx) (* dx (accumulate-stream + 0 (stream-map f (stream-map (lambda (x) (+ lo x)) (stream-scale dx (enumerate-interval 0 (ceiling (/ (- hi lo) dx))))))))

  12. Stream Implementation ;Arrange so that the cdr of a stream ; is evaluated when it is accessed ; by the stream-cdr rather than when ; the stream is constructed (cons-stream <x> <y>) === (cons <x> (delay <y>)) (define (stream-car s)(car s)) (define (stream-cdr s)(force (cdr s)))

  13. (delay <exp>) • special form: not evaluating <exp> • returns an object that will later evaluate exp when that object is given to a procedure force as its argument : delayed object (“promise”) • force takes a delayed object as argument and perform evaluation. • (force (delay <exp>)) == <exp> • (define (cons-stream a b) (cons a (delay b))) is not feasible.

  14. Stream : “Demand-driven” programming (stream-car (stream-cdr (stream-filter prime? (enumerate-interval 10 1000)))) -> (cons 10 (delay (enumerate... 11..))

  15. Implementing delay and force • (delay <exp>) is syntactic sugar for (lambda () <exp>) (define (force delayed-object) (delay-object)) • Inefficiency in recursive program • Call-by-need • once evaluated, remember the value. • returns remembered value when called again. • (memo-proc proc)

  16. (memo-proc proc) (define (memo-proc proc) (let ((already-run? false)(result false)) (lambda () (if (not already-run?) (begin (set! result (proc)) (set! already-run? true) result) result)))) (delay <exp>) is equivalent to (memo-proc (lambda () <exp>))

  17. cons-stream :macro ;(define (cons-stream <x> <y>) ; (cons <x> (delay <y>))) (define ones (cons-stream 1 ones)) ;(define ones (cons 1 (delay ones))) (define (stream-car stream) (car stream)) (define (stream-cdr stream) (force (cdr stream))) (define-macro cons-stream (lambda (x . y) `(cons ,x (delay ,@y))))

  18. Some Simple Streams ;;Recursive definition (define (integers-from n) (cons-stream n (integers-from (+ 1 n)))) ;; infiniite streams (define integers (integers-from 1)) (define fibgen a b) (cons-stream a (fibgen b (+ a b)))) (define fibs (fibgen 0 1))

  19. Stream using HOP ;; Examples using stream HOP (define no-sevens (stream-filter (lambda (x) (not (divisible? x 7))) integers)) (define (divisible? x y) (= (remainder x y) 0)) (stream-ref no-sevens 100) ; => Value 117

  20. Sieve of Eratosthenes ;manipulate just like a finite sized object (define (sieve s) (cons-stream (stream-car s) (sieve (stream-filter (lambda (x) (not (divisible? x (stream-car s)))) (stream-cdr s))))) (define primes (sieve (integer-from 2))) (stream-ref primes 200) ; Value: 1229

  21. More Stream Utilities (define (add-streams s1 s2) (cond ((stream-null? s1) s2) ((stream-null? s2) s1) (else (cons-stream (+ (stream-car s1) (stream-car s2)) (add-streams (stream-cdr s1) (stream-cdr s2)))))) (define (show-stream s n) (cond ((= n 0) ’done) (else (newline) (display (stream-car s)) (show-stream (stream-cdr s) (- n 1)))))

  22. More More Stream Utilities (define (stream-map2 proc s1 s2) (if (stream-null? s1) the-empty-stream (cons-stream (proc (stream-car s1) (stream-car s2)) (stream-map2 proc (stream-cdr s1) (stream-cdr s2))))) ; (define ones (cons-stream 1 ones)) (define integers (cons-stream 1 (add-streams ones integers)))

  23. Stream of Fibonacci numbers (define fibs (cons-stream 0 (cons-stream 1 (add-streams (stream-cdr fibs) fibs)))) (show-stream fibs 9) 0 1 ; 0 1 1 2 3 5 8 13 21

  24. More Example (define (scale-stream s factor) (stream-map (lambda (x)(* x factor)) s)) ; 1 2 4 8 16 32 ......... (define double (cons-steam 1 (scale-stream double 2))) ;Exercise 3.53 (define s (cons-stream 1 (add-streams s s)))

  25. Prime Numbers (define primes (cons-stream 2 (stream-filter prime? (integers-from 3)))) (define (prime? n) (define (iter ps) (cond ((> (square (stream-car ps)) n) #t) ((divisible? n (stream-car ps)) #f) (else (iter (stream-cdr ps))))) (iter primes))

  26. Square Roots ;;Previous procedural implementation (define (sqrt x) (define (try guess) (if (good-enough? guess) guess (try (improve guess)))) (define (improve guess) (average guess (/ x guess))) (define (good-enough? guess) (close? (* guess guess) x)) (try 1))

  27. Stream of Square Roots (define (sqrt-improve guess x) (average guess (/ x guess))) (define (average a b) (/ (+ a b) 2)) (define (sqrt-stream x) (cons-stream 1.0 (stream-map (lambda (g) (sqrt-improve g x)) (sqrt-stream x))))

  28. Running square-root (show-stream (sqrt-stream 2) 7) 1. 1.5 1.4166666666666665 1.4142156862745097 1.4142135623746899 1.414213562373095 1.414213562373095 ;Value: done

  29. Ex 3.63 (define (sqrt-stream x) (define guesses (cons-stream 1.0 (stream-map (lambda (g) (sqrt-improve g x)) guesses))) guesses) ;;Ex. 3.63 difference in efficiency?

  30. Stream to Desired Tolerance Limit (define (stream-limit s tol) ; Exercise 3.64 (define (iter s) (let ((f1 (stream-car s)) (f2 (stream-car (stream-cdr s)))) (if (close-enuf? f1 f2 tol) f2 (iter (stream-cdr s))))) (iter s)) (define (close-enuf? x y tol) (< (abs (- x y)) tol)) (stream-limit (sqrt-stream 2) 1.e-5) ;Value: 1.4142135623746899

  31. Witch of Agnesi The bell-shaped witch of Maria Agnesi can be constructed in the following way. Start with a circle of diameter a , centered at the point (0,a/2) on the y-axis. Choose a point A on the line y=a and connect it to the origin with a line segment. Call the point where the segment crosses the circle B. Let P be the point where the vertical line through A crosses the horizontal line through B. The witch is the curve traced by P as A over along the line y=a. A y=a C B P(x,y) a3 y= x2+a2 0

  32. Trapezoidal Integration ;Trapezoidal Integration (define (trapezoid f a b h) (let ((dx (* (- b a) h)) (n (/ 1 h))) (define (iter i sum) (let ((x (+ a (* i dx)))) (if (>= i n) sum (iter (+ i 1) (+ sum (f x)))))) (* dx (iter 1 (+ (/ (f a) 2) (/ (f b) 2))))))

  33. Caculation of p ;The Witch of Agnesi and Approximation to p (define (witch x) (/ 4 (+ 1 (* x x)))) (trapezoid witch 0. 1. .1) 3.1399259889071587 (trapezoid witch 0. 1. .01) 3.141575986923129 ; see http://www.agnesscott.edu/lriddle/women/agnesi.htm

  34. Stream of Approximation to p ; Stream of Approximation to pi (define (keep-halving R h) (cons-stream (R h) (keep-halving R (/ h 2)))) (show-stream (keep-halving (lambda (h) (trapezoid witch 0 1 h)) 0.1) 9) (stream-limit (keep-halving (lambda (h) (trapezoid witch 0 1 h)) 0.5) 1.e-9)

  35. Result 3.1399259889071587 3.1411759869541287 3.1414884869236115 3.141566611923134 3.1415861431731273 3.1415910259856252 3.1415922466887523 3.1415925518645325 3.1415926281584774 done 3.1415926534345684 ; after 65549 evaluation of witch

  36. 2pR(h/2)-R(h) 2p-1 Accelerating the Approximation • Suppose we want to approximate a function R(0). Given a sequence of values: R(h), R(h/2), R(h/4), ..... If we know that R has the form R(h)= A + Bhp + Ch2p + Dh3p + .... Then = A + C2h2p + D2h3p + ...

  37. Accelerating the Stream • This new sequence converges to the same value as the original, but it converges faster. (define (accel-halving-seq s p) (let ((2**p (expt 2 p))) (let ((2**p-1 (- 2**p 1))) (stream-map2 (lambda (Rh Rh/2) (/ (- (* 2**p Rh/2) Rh) 2**p-1)) s (stream-cdr s)))))

  38. Rapid Acceleration ;Make a table, where each row is the ; accelerated version of the previous row. (define (make-tableau s p) (define (rows s order) (cons-stream s (rows (accel-halving-seq s order) (+ order p)))) (rows s p))

  39. Richardson acceleration ;take just the first element of each row ; "Richardson acceleration" of the original ; series (define (richardson-accel s p) (stream-map stream-car (make-tableau s p)))

  40. ; test (show-stream (richardson-accel (keep-halving (lambda (h)(trapezoid witch 0 1 h)) .1) 2) 5) 3.1399259889071587 3.1415926529697855 3.1415926536207945 3.141592653589793 3.1415926535897944

  41. (stream-limit (richardson-accel (keep-halving (lambda (h) (trapezoid witch 0 1 h)) .1) 2) 1.e-9) 3.1415926536207945 ;This requires only 73 evaluations of the ;witch!

  42. scale:dt add cons Streams as signals • integrator • input stream x = (xi) • initial value C increment dt • output stream S = (Si) Si = C + Sij=1 xj dt input C integral

  43. (define (integral intergrand initial-value dt) (define int (cons-stream initial-value (add-stream (scale-stream integrand dt) int))) int)

  44. Solving dy/dt=f(y) (define (solve f y0 dt) (define y (integral dy y0 dt)) (define dy (stream-map f y)) y) y0 y dy map: f integral

  45. Integral with delayed argument ; Streams and Delayed Evaluation (define (integral delayed-integrand initial-value dt) (define int (cons-stream initial-value (let ((integrand (force delayed-integrand))) (add-streams (scale-stream integrand dt) int)))) int) ;estimating e (stream-ref (solve (lambda (y) y) 1 0.001) 1000) 2.716923932235896

  46. Normal-Order Evaluation • We sometimes need delayed arguments. • Why don’t we make all arguments are evaluated when necessary? • normal order evaluation • Evaluation overhead • “call by need”, strictness analysis • hard to read programs

More Related