WXME0106 ## wxtextwxtabwxmediawximage$(lib "comment-snip.ss" "framework")+(lib "collapsed-snipclass.ss" "framework")drscheme:sexp-snipdrscheme:syntax-snipclass%drscheme:number,(lib "number-snip.ss" "drscheme" "private")drscheme:bindings-snipclass%drscheme:lambda-snip%drscheme:define-snip%java-comment-box%java-interactions-box%"drscheme:vertical-separator-snip%wxbaddrscheme:xml-snip(lib "xml-snipclass.ss" "xml")drscheme:scheme-snip"(lib "scheme-snipclass.ss" "xml")test-case-box%wxloc*K ZÁÿZÁÿÁÿ€ÿ€ÿ€ÿÁÿ StandardK Courier New ZÁÿZÁÿÁÿ€ÿ€ÿ€ÿÁÿÁÿ?ð\ÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð"€‹"ÁÿÁÿMatching Parenthesis StyleÁÿ?ð\ÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð"€‹"ÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð&&€€ÁÿÁÿ(framework:syntax-coloring:scheme:symbolÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð&&€€ÁÿÁÿ)framework:syntax-coloring:scheme:keywordÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð&&€€ÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€ÂtÁÿÁÿ)framework:syntax-coloring:scheme:commentÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€ÂtÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð)€€&ÁÿÁÿ(framework:syntax-coloring:scheme:stringÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð)€€&ÁÿÁÿ*framework:syntax-coloring:scheme:constantÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð)€€&ÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€„<$ÁÿÁÿ-framework:syntax-coloring:scheme:parenthesisÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€„<$ÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€ø@ÁÿÁÿ'framework:syntax-coloring:scheme:errorÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€ø@ÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðÁÿÁÿ'framework:syntax-coloring:scheme:otherÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðQp€ËÁÿÁÿ1drscheme:check-syntax:lexically-bound-identifierÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðQp€ËÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðD€ËÁÿÁÿ*drscheme:check-syntax:imported-identifierÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðD€ËÁÿÁÿ%profj:syntax-coloring:scheme:keywordÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð"€‹"ÁÿÁÿ$profj:syntax-coloring:scheme:stringÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð"€‹"ÁÿÁÿ%profj:syntax-coloring:scheme:literalÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð"€‹"ÁÿÁÿ%profj:syntax-coloring:scheme:commentÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€ÂtÁÿÁÿ#profj:syntax-coloring:scheme:errorÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€ø@ÁÿÁÿ(profj:syntax-coloring:scheme:identifierÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð&&€€ÁÿÁÿ%profj:syntax-coloring:scheme:defaultÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðÁÿÁÿF?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð?ð?ð?ðÁÿÁÿXMLF?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð?ð?ð?ðÁÿÁÿK Courier New ZÁÿZÁÿÁÿ€ÿ€ÿ€ÿÁÿG?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð?ð?ð?ðÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðPP€øÁÿÁÿG?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðPP€øÁÿÁÿG?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ðdÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€¯ÁÿÁÿÁÿ?ðÁÿÁÿÁÿÁÿÁÿÁÿ?ð?ð?ð€–€–ÁÿÁÿÁÿ?ð\ÁÿÁÿÁÿÁÿÁÿ€ÿ€ÿÁÿÁÿÁÿ?ðÁÿÁÿ^ÁÿÁÿÁÿ?ð?ð?ð€ÿÁÿÁÿˆë 4; Scheme Files associated with Lecture 21 -- Streams  0; takes a number and returns a list of digits in ; the number in reverse order (define ( rev-digits n)  (if (< n 10)  (list n)  (let ((d ( remainder n 10)))  (cons d ( rev-digits (/ (- n d) 10))))))  4; takes a number and returns #t if that number is a   ; palindrome (define ( palindrome? n)  (let ((dd ( rev-digits n)))  (equal? dd (reverse dd))))  '; compare two different implementations  3; takes two integers a < b and returns a sum of all ); palindromes in the interval from a to b (define (sum-palindromes-1 a b)  (define (sum-iter count sum)  (cond ((> count b) sum)  (( palindrome? count)  (sum-iter (+ count 1) (+ count sum)))  (else (sum-iter (+ count 1) sum))))  (sum-iter a 0))  3; takes two integers a < b and returns a sum of all ); palindromes in the interval from a to b 8; uses sequence operations (clear but significantly less  ; efficient) (define (sum- palindromes-2 a b)  ( accumulate + 0 (filter  palindrome?  (enumerate-interval a b))))   :;;;;;; FILTER/ACCUMULATE/ENUMERATE IMPLEMENTATIONS ;;;;;;; !; returns a list containing those (; elements of lst that return non-#f for ; test (define (filter test lst)  (cond ((null? lst) ())  ((test (car lst))  (cons (car lst)  (filter test (cdr lst))))  (else (filter test (cdr lst)))))   (; put together the elements of lst using  ; binary-op (define ( accumulate  binary-op   init-val   lst)  (if (null? lst)  init-val  ( binary-op (car lst)  ( accumulate  binary-op  init-val  (cdr lst)))))  &; makes a list out of elements between  ; lo and hi (define (enumerate-interval lo hi)  (if (> lo hi)  ()  (cons lo   (enumerate-interval (+ lo 1) ! hi)))) <;; END;; FILTER/ACCUMULATE/ENUMERATE IMPLEMENTATIONS ;;;;;;;  %; return first palindrome in interval (define (first-palindrome a b)  (car (filter  palindrome?  (enumerate-interval a b))))  (first-palindrome 123 10000)  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;; ; ; ; ; (define  test-promise  (delay (display 'hi)))  (force  test-promise)   #; empty stream is a special element (define the-empty-stream ())  +; can think of stream-null? just like null? (define ( stream-null? x) (null? x))  2; macro for cons – creates new object with promise "; of delayed function call for cdr ( define-syntax  cons-stream  ( syntax-rules ()  (( cons-stream  value-expr  call-expr)  (cons  value-expr (delay  call-expr)))))  .; takes a stream and returns its first element (define ( stream-car stream) (car stream))  1; takes a stream and returns the rest after first 6; element – this means the next element is forced, but $; remaining elements remain implicit (define ( stream-cdr stream) (force (cdr stream)))  :; it is possible to define most list functions for streams :; takes a stream and a positive number and returns the nth ; element of the stream (define ( stream-ref stream n)  (if (= n 0)  ( stream-car stream)  ( stream-ref ( stream-cdr stream) (- n 1))))  ); takes two integers where low < high and ); returns a stream containing the numbers ; from low to high (define (stream-enumerate-interval low high)  (if (> low high)  the-empty-stream  ( cons-stream  low  (stream-enumerate-interval (+ low 1) # high))))  ,; takes a predicate and a stream and returns *; a stream whose elements are the original .; elements of stream for which pred returns #t (define ( stream-filter pred stream)  (cond (( stream-null? stream) the-empty-stream) ((pred ( stream-car stream))  ( cons-stream ( stream-car stream)  ( stream-filter  pred  ( stream-cdr stream))))  (else ( stream-filter  pred  ( stream-cdr stream)))))  -; efficient palindrome function using streams (define palnums  ( stream-filter   palindrome?  (stream-enumerate-interval  123   100000000)))  (define palnums2  ( stream-filter   palindrome?  (stream-enumerate-interval  123  5 0 0)))   ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;  U s e f u l  S t r e a m  F u n c t i o n s  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;  0; takes a procedure of one argument and a stream 2; returns the stream that is the procedure applied /; to the first element of the stream, and whose /; remaining elements are the procedure applied  ; to the next and so on (define ( stream-map proc stream)  (if ( stream-null? stream)  the-empty-stream  ( cons-stream   (proc ( stream-car stream))  ( stream-map proc ( stream-cdr stream)))))  *; takes a procedure that has a side effect &; and a stream. Applies the procedure  ; to each element of the stream. (define (stream-for-each proc stream)  (if ( stream-null? stream)  'done  (begin  (proc ( stream-car stream))  (stream-for-each proc  ( stream-cdr stream)))))  7G ;  d i s p l a y  f u n c t i o n  f r o m  t e x t  $; a function that takes a stream and  ; displays it (define (display-stream stream)  (stream-for-each  (lambda (x)  (newline)  (display x))  stream))  $; a function that takes a stream and  ; displays it (define (display-stream stream)  (display " [ ")  (stream-for-each  (lambda (x)  (display x)  (display " "))  stream)  (display " ] "))  Ý- 0; delays the evaluation of its argument -- macro ( define-syntax delay  ( syntax-rules ()  ((delay expr) (lambda () expr))))  3; forces the evaluation of a delayed procedure call (define (force delayed-proc-call)  (delayed-proc-call))  -; takes a procedure and if it has already run +; saves its value – otherwise, the value is ; kept implicit (define ( memo-proc proc)  (let (( already-run? #f) (result #f))  (lambda ()  (if  already-run?  result  (begin (set! result (proc))  (set!  already-run? #t)  result)))))  (define (factorial n)  (if (eq? n 1)  1  (* n (factorial (- n 1)))))  (define fact-3 (lambda () ( factorial 3))) (define memoized-fact-3 (memo-proc fact-3))  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;; ; ; ; ; ; ;  I N F I N I T E  S E Q U E N C E S  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; +; infinite stream of integers starting at n (define ( integers-from n)  ( cons-stream n ( integers-from (+ n 1))))  2; an infinite stream of integers starting from 100 (define large-integers ( integers-from 100))  "; filter to leave just palindromes (define large-palindromes  ( stream-filter  palindrome? large-integers))  5; pull the 11th palindrome from the infinite sequence ( stream-ref large-palindromes 11)   ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ); generates a stream of Fibonacci Numbers ,; given two numbers in the sequence, creates (; a sequence of the rest starting from a (define (fibgen a b)  ( cons-stream a (fibgen b (+ a b))))  ); fibs is a pair whose car is 0 and whose +; cdr is a promise to evaluate (fibgen 1 1) (define fibs (fibgen 0 1))  ( stream-ref fibs 10)  ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; $; generate an infinite stream of 7’s (define lucky ( cons-stream 7 lucky))   ; ; ; ; ; ;  E x e r c i s e  3 . 5  - -  G e n e r a l i z e d  s t r e a m - m a p  F u n c t i o n ;  t a ke s  a  p r o c e d u r e  t h a t  t a k e s  a n y  n u m b e r  o f  s t r e a m ;  a r g u m e n t s  a n d  t h a t  n u m b e r  o f  s t r e a m s .   G e n e r a t e s ;  a  n e w  s t r e a m  w h o s e  s t r e a m - c a r  i s  t h e  a p p l i c a t i o n  o f ;  t h e  p r o c e d u r e  t o  t h e  c a r s  a n d  s o  o n . . . (define (gen -stream-map proc .  argstreams)  (if ( stream-null? (car  argstreams))  the-empty-stream  (cons  (apply proc (map  stream-car  argstreams))  (delay (apply gen -stream-map  (cons proc (map  stream-cdr  argstreams)))))))  (; takes two streams and returns a stream '; that is the pairwise addition of the  ; individual streams (define ( add-stream stream1 stream2)  (gen -stream-map + stream1 stream2))  ;  a  r e c u r s i v e  v e r s i o n  o f  f i b s (define rfibs  ( cons-stream 0  ( cons-stream 1  ( add-stream  ( stream-cdr rfibs)  rfibs))))  '; returns a stream that is the original (; stream with each element multiplied by ; factor (define ( scale-stream stream factor)  ( stream-map (lambda (x) (* x factor))  stream))   ; takes a stream and g e n e r a t e s  p o s e r s  o f  3 (define triple  ( cons-stream 1  ( scale-stream triple  3)))