1. מבוא מורחב 1 Your turn (Review) What does a lambda expression return when it is evaluated? the value of a lambda expression is a procedure What three things are in the code of every recursive algorithm? a recursive case a base case a test Which of the following is a use of lambda? 1. (define fred +) 2. (define (fred x) (+ x x)) only 2: (define fred (lambda (x) (+ x x)))

2. מבוא מורחב 2 (define (sqrt x) (sqrt-iter 1.0 x)) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (define (good-enough? guess x) (< (abs (- (square guess) x)) 0.001)) (define (improve guess x) (average guess (/ x guess)))

3. מבוא מורחב 3 Block Structure (define (sqrt x) (define (good-enough? guess x) (< (abs (- (square guess) x)) 0.001)) (define (improve guess x) (average guess (/ x guess))) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (sqrt-iter 1.0 x))

4. 4 Binding names קשירת שמות A procedure F binds a name x if either 1. x is a formal parameter of F 2. x is a name defined internally in F (define (F x y z) (define (h y) (* y y) (+ (h x) (h y) (h z))) h, x, y, z are bound in F y is bound in h

5. מבוא מורחב 5 עידון מודל ההצבה When replacing a formal parameter by the corresponding argument, do not substitute for occurences that are bound by an internal definition. An occurrence of a name is bound by the innermost procedure that binds the name and contains the occurrence in its body.

6. מבוא מורחב 6 refining the substitution model (define (sqrt x) (define (good-enough? guess x) (< (abs (- (square guess) x)) 0.001)) (define (improve guess x) (average guess (/ x guess))) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (sqrt-iter 1.0 x)) (sqrt 2)

7. מבוא מורחב 7 (sqrt 2) (define (good-enough? guess x) (< (abs (- (square guess) x)) 0.001)) (define (improve guess x) (average guess (/ x guess))) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (sqrt-iter 1.0 2)

8. מבוא מורחב 8 Scheme uses Lexical Scoping ערך משתנה חופשי בפונקציה F נקבע על פי מקום הגדרת F. (ולא על פי מקןם הפעלת F) פונקציה המכילה את הגדרת F תקבע את ערכו.

9. מבוא מורחב 9 (define (sqrt x) (define (good-enough? guess x) (< (abs (- (square guess) x)) 0.001)) (define (improve guess x) (average guess (/ x guess))) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (sqrt-iter 1.0 x))

10. מבוא מורחב 10 Taking advantage of Lexical Scoping (define (sqrt x) (define (good-enough? guess) (< (abs (- (square guess) x)) 0.001)) (define (improve guess) (average guess (/ x guess))) (define (sqrt-iter guess) (if (good-enough? guess) guess (sqrt-iter (improve guess)))) (sqrt-iter 1.0)) (sqrt 2)

11. מבוא מורחב 11 (sqrt 2) (define (good-enough? guess) (< (abs (- (square guess) 2)) 0.001)) (define (improve guess) (average guess (/ 2 guess))) (define (sqrt-iter guess) (if (good-enough? guess) guess (sqrt-iter (improve guess)))) (sqrt-iter 1.0) (if (good-enough? 1.0) 1.0 (sqrt-iter (improve 1.0)))

12. מבוא מורחב 12 (define (h x) (define (f y) (+ x y)) (define (g x) (f x)) (g (* 2 x))) => (h 1) (define (f y) (+ 1 y)) (define (g x) (f x)) (g (* 2 1)) (f 2) (+ 1 2) 3

13. מבוא מורחב 13 Applicative order evaluation Combination … ( …… ) Evaluate to get the procedure and evaluate to get the arguments If is primitive: do whatever magic it does If is compound: evaluate body with formal parameters replaced by arguments

14. מבוא מורחב 14 Normal order evaluation Combination … ( …… ) Evaluate to get the procedure and evaluate to get the arguments If is primitive: do whatever magic it does If is compound: evaluate body with formal parameters replaced by arguments

15. מבוא מורחב 15 Applicative ((lambda (x) (+ x x)) (* 3 4)) ((lambda (x) (+ x x)) 12) (+ 12 12) 24 Normal ((lambda (x) (+ x x)) (* 3 4)) (+ (* 3 4) (* 3 4)) (+ 12 12) 24 This may matter in some cases: ((lambda (x y) (+ x 2)) 3 (/ 1 0))

16. מבוא מורחב 16 Compute a b (exp-1 2 2) ==> 4 wishful thinking : base case : a * a (b-1) a 0 = 1 (define exp-1 (lambda (a b) (if (= b 0) 1 (* a (exp-1 a (- b 1))))))

17. מבוא מורחב 17 exp-1 is a recursive algorithm In a recursive algorithm, bigger operands => more space (define exp-1 (lambda (a b) (if (= b 0) 1 (* a (exp-1 a (- b 1))))))(fact 4) (exp-1 2 3) (if (= 3 0) 1 (* 2 (exp-1 2 (- 3 1)))) (* 2 (exp-1 2 2)).. (* 2 (* 2 (exp-1 2 1))).. (* 2 (* 2 (* 2 (exp-1 2 0)))) An iterative algorithm uses constant space

18. מבוא מורחב 18 Intuition for iterative a b same as you would do if calculating 2 4 by hand: 1. start with 1 (4 more to go) 1. multiply 1 by 2gives 2 (3 more to go) 2. multiply 2 by 2gives 4 (2 more to go) 3. multiply 4 by 2gives 8 (1 more to go) 4. multiply 8 by 2gives 16 (0 more to go) At each step, only need to remember: current product, how many times has yet to multiply Therefore, constant space

19. מבוא מורחב 19 In scheme: (define (exp-2 a b) (define (exp-iter a b product) (if (= b 0) product (exp-iter a (- b 1) (* a product)))) (exp-iter a b 1)

20. מבוא מורחב 20 A trace (define (exp-2 a b) (define (exp-iter a b product) (if (= b 0) product (exp-iter a (- b 1) (* a product)))) (exp-iter a b 1) (exp-2 3 4) (exp-iter 3 4 1) (exp-iter 3 3 3) (exp-iter 3 2 9) (exp-iter 3 1 27) (exp-iter 3 0 81) 81

21. 21 Recursive = pending operations when procedure calls itself Recursive exponentiation: (define exp-1 (lambda (a b) (if (= b 0) 1 (* a (exp-1 a (- b 1)))))) (exp-1 2 3) (if (= 3 0) 1 (* 2 (exp-1 2 (- 3 1)))) (* 2 (exp-1 2 2)).. (* 2 (* 2 (exp-1 2 1))).. (* 2 (* 2 (* 2 (exp-1 2 0))))(fact 4) operation pending Pending ops make the expression grow continuously

22. 22 Iterative = no pending operations Iterative exponentiation: (define (exp-2 a b) (define (exp-iter a b product) (if (= b 0) product (exp-iter a (- b 1) (* a product)))) (exp-iter a b 1)) (exp-2 3 4) (exp-iter 3 4 1) (exp-iter 3 3 3) (exp-iter 3 2 9) (exp-iter 3 1 27) (exp-iter 3 0 81) 81 Fixed size because no pending operations no pending operations

23. מבוא מורחב 23 Summary Iterative algorithms have constant space Using substitution the expression doesn’t grow. Iterative algorithms have no pending operations when the procedure calls itself How to develop an iterative algorithm figure out a way to accumulate partial answers translate rules into scheme code

24. מבוא מורחב 24 Rules for evaluation ``Elementary expressions'' are left alone: Elementary expressions are Numerals initial names of primitive procedures lambda expressions, naming procedures A name bound by DEFINE: Rewrite the name as the value it is associated with by the definition IF: If the evaluation of the predicate expression terminates in a non-false value then rewrite the IF expression as the value of the consequent, otherwise, rewrite the IF expression as the value of the alternative. Combination: Evaluate the operator expression to get the procedure, and evaluate the operand expressions to get the arguments, If the operator names a primitive procedure, do whatever magic the primitive procedure does. If the operator names a compound procedure, evaluate the body of the compound procedure with the arguments substituted for the formal parameters in the body.

25. מבוא מורחב 25 Orders of growth of processes Suppose n is a parameter that measures the size of a problem Let R(n) be the amount of resources needed to compute a procedure of size n. Two common resources are space, measured by the number of deferred operations, and time, measured by the number of primitive steps. Want to estimate the “order of growth” of R(n): R 1 (n)=100n 2 R 2 (n)=2n 2 +10n+2 R 3 (n) = n 2 Are all the same in the sense that if we multiply the input by a factor of 2, the resource consumption increase by a factor of 4

26. מבוא מורחב 26 Orders of growth of processes We say R(n) has order of growth  f(n)  if there are constants k 1 and k 2 such that k 1 f(n) <= R(n) <= k 2 f(n) for all n R(n)  O(f(n)) if there is a constant k such that R(n) <= k f(n) for all n R(n)   (f(n)) if there is a constant k such that k f(n) <= R(n) for all n   x x 100n 2  O(n) 100n 2   (n) 100n 2   (n) 100n 2   (n 2 ) k 1, k 2, k  0

27. מבוא מורחב 27 Resources consumed by exp-1 In a recursive algorithm, bigger operands => more space (define exp-1 (lambda (a b) (if (= b 0) 1 (* a (exp-1 a (- b 1))))))(fact 4) (exp-1 2 3) (if (= 3 0) 1 (* 2 (exp-1 2 (- 3 1)))) (* 2 (exp-1 2 2)).. (* 2 (* 2 (exp-1 2 1))).. (* 2 (* 2 (* 2 (exp-1 2 0)))) Space  b  Time  b 

28. מבוא מורחב 28 Resources consumed by exp-2 (define (exp-2 a b) (define (exp-iter a b product) (if (= b 0) product (exp-iter a (- b 1) (* a product)))) (exp-iter a b 1) (exp-2 3 4) (exp-iter 3 4 1) (exp-iter 3 3 3) (exp-iter 3 2 9) (exp-iter 3 1 27) (exp-iter 3 0 81) 81 Space  1  Time  b 