 Download Presentation מבוא מורחב למדעי המחשב בשפת Scheme

# מבוא מורחב למדעי המחשב בשפת Scheme - PowerPoint PPT Presentation Download Presentation ## מבוא מורחב למדעי המחשב בשפת Scheme

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Outline • Repeated f • Accelerating computations • Fibonacci • Let and let* • Recursion examples • Palindrome? • Log • Order of growth

2. f(x), f(f(x)), f(f(f(x))), … apply f, n times Repeated f Compose now Execute later (define (compose f g) (lambda (x) (f (g x)))) (= n 1) f (repeated f (- n 1)) (define (repeated f n) (if (compose f ))) ((repeated inc 5) 100) => 105 ((repeated square 2) 5) => 625 3

3. Repeated f - iterative Do nothing until called later (define (repeated-iter f n x) (if (= n 1) (f x) (repeated-iter f (- n 1) (f x)))) (define (repeated f n) (lambda (x) (repeated-iter f n x))) 4

4. Repeated f – Iterative II (define (repeated f n) (define (repeated-iter count accum) (if (= count n) accum (repeated-iter (+ count 1) (compose f accum)))) (repeated-iter 1 f)) Compose now Execute later 5

5. Smooth a function f: g(x) = (f(x – dx) + f(x) + f(x + dx)) / 3 Repeatedly smooth a function (define (repeated-smooth f n) ) (define (smooth f) (let ((dx 0.1)) )) (define (average x y z) (/ (+ x y z) 3)) (lambda (x) (average (f (- x dx)) (f x) (f (+ x dx)))) ((repeated smooth n) f) 6

6. AcceleratingComputations

7. Iterative Fibonacci (define (fib n) (define (fib-iter a b count) (if (= count 0) b (fib-iter (+ a b) a (- count 1))) (fib-iter 1 0 n)) • Computation time: (n) • Much better than Recursive implementation, but… • Can we do better?

8. Slow vs Fast Expt • Slow (linear) • b0=1 • bn=bbn-1 • Fast (logarithmic) • bn=(b2)n/2if n is even • bn=bbn-1if n is odd • Can we do the same with Fibonacci?

9. b a a+b 2a+b 3a+2b … Double Steps • Fibonacci Transformation: • 0 1 1 2 3 5 8 13 21 • Double Transformation:

10. A Squaring Algorithm • If we can square (or multiply) linear transformations, we have an algorithm: • Apply Tn on (a,b), where: • Tn=(T2)n/2 If n is even • Tn=TTn-1 If n is odd

11. Squaring Transformations • General Linear Transformation: • Squared:

12. Iterative Algorithm • Initialize: • Stop condition: If count=0 return b • Step count is odd count is even

13. Representing Transformations • We need to remember x, y, z, w • Fibonacci Transformations belong to a simpler family: • T01 is the basic Fibonacci transformation • Squaring (verify on your own!):

14. Implementation (finally) (define fib n) (fib-iter 1 0 0 1 n)) (define (fib-iter a b p q count) (cond ((= count 0) b) ((even? count) (fib-iter a b (/ count 2) (else (fib-iter p q (- count 1)))) (+ (square p) (square q)) (+ (* 2 p q) (square q)) (+ (* b q) (* a q) (* a p)) (+ (* b p) (* a q))

15. The syntactic sugar “Let” (define (f x y) ((lambda (a b) (+ (* x (square a)) (* y b) (* a b))) (+ 1 (* x y)) (- 1 y))) (define (f x y) (define (f-helper a b) (+ (* x (square a)) (* y b) (* a b))) (f-helper (+ 1 (* x y)) (- 1 y))) (define (f x y) (let ((a (+ 1 (* x y))) (b (- 1 y))) (+ (* x (square a)) (* y b) (* a b))))

16. bindings The syntactic sugar “Let” (Let ((<var1> <exp1>) (<var2> <exp2>) .. (<varn> <expn>)) <body>) Is defined to be equivalent to: ((lambda (<var1> ….. <varn>) <body>) <exp1> <exp2> … <expn>)

17. let* (let* ((<var1> <exp1>)… (<varn> <expn>)) <body>) Is equivalent to (let ((<var1> <exp1>)) (let* ((<var2> <exp2>)… (<varn> <expn>)) <body>)) 18

18. let vs. let* (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x))) ==> 35

19. let vs. let* (let ((x 2) (y 3)) (let* ((x 7) (z (+ x y))) (* z x))) ==> 70

20. palindrome? • Palindromes are (positive) numbers that read the same in both directions (e.g. left to right and right to left). • Write a procedure (palindrome? x) that gets an integer as parameter and returns true (#t) if the number is a palindrome and false (#f) otherwise.

21. Examples > (palindrome? 1234567) #f > (palindrome? 1234321) #t > (palindrome? 56865) #t

22. Useful functions (define(least-significantx) (remainder x 10)) (define(remove-least-significantx) (quotient x 10))

23. Implementation • Construct a new number by reversing the digits of the input (x) • Test whether these two numbers are equal.

24. reverse-num (define(reverse-numx) (define(helperxfactor) (if (< x 10) x (+ (* () factor) (helper () (/ factor 10))))) (define(factorx) (if (< x 10) 1 (*10 (factor ())))) (helper x (factor x)))

25. reverse-num (define(reverse-numx) (define(helperxfactor) (if (< x 10) x (+ (* (least-significant x) factor) (helper () (/ factor 10))))) (define(factorx) (if (< x 10) 1 (*10 (factor ())))) (helper x (factor x)))

26. reverse-num (define(reverse-numx) (define(helperxfactor) (if (< x 10) x (+ (* (least-significant x) factor) (helper (remove-least-significant x) (/ factor 10))))) (define(factorx) (if (< x 10) 1 (*10 (factor ())))) (helper x (factor x)))

27. reverse-num (define(reverse-numx) (define(helperxfactor) (if (< x 10) x (+ (* (least-significant x) factor) (helper (remove-least-significant x) (/ factor 10))))) (define(factorx) (if (< x 10) 1 (*10 (factor (remove-least-significant x))))) (helper x (factor x)))

28. palindrome? (define(palindrome?x) (if (< x 0) #f (= x (reverse-num x))))

29. log Consider the function deﬁned as follows: lg(1) = 0 lg(n) = lg(⌊n/2⌋) + 1, n > 1 *Do not use mathematical functions not shown here, such as exptor sqrt. *You may use (floor x) to compute ⌊x⌋.

30. Recursive process  (define (lg n) (if (= n 1) 0 (+ (lg (floor (/ n 2))) 1)))

31. Iterative process (define (lg n) (define (helper n result) (if (= n 1) result (helper () ()))) (helper n 0))

32. Iterative process (define (lg n) (define (helper n result) (if (= n 1) result (helper (floor (/ n 2)) ()))) (helper n 0))

33. Iterative process (define (lg n) (define (helper n result) (if (= n 1) result (helper (floor (/ n 2)) (+ result 1)))) (helper n 0))

34. Order of Growth • For each of the following statements, determine whether it is true or false. If it is true, provide a proof, if false, provide a counterexample. • Θ(2^n) = Θ(3^n) • 2^(3*lg n+2) = O(n^3)

35. Order of Growth