Principles of Programming Languages Practice session 2 define

Principles of Programming Languages Practice session 2

תהליך איטרטיבי לעומת תהליך רקורסיבי : גרסה איטרטיבית (define exp-iter (lambda (b e acc) (cond ((= e 0) acc) (else (exp-iter b (- e 1) (* b acc)))))) (define exp (lambda (b e) (exp-iter b e 1))) Time(b, e) = O(e) Space(b, e) = O(1)

תהליך איטרטיבי לעומת תהליך רקורסיבי : pi ניזכר בטור לחישוב : גרסה רקורסיבית ; ; ; ; � � Signature: pi-sum(n) Type: [Number -> Number] Purpose: to compute the sum of the series up to its n-th element. Pre-conditions: n>=0, natural. Tests: (test (pi-sum 0) => 0. 33333333) (test (pi-sum 1) => 0. 3619047619) (test (pi-sum 2) => 0. 372005772) (define pi-sum (lambda (n) (if (= n 0) (/ 1. 0 3) (+ (pi-sum (- n 1)) (/ 1 (* (+ (* n 4) 1) (+ (* n 4) 3)))))))

תהליך איטרטיבי לעומת תהליך רקורסיבי : גרסה איטרטיבית � (define pi-sum-iter (lambda (n acc) (if (= n 0) (+ acc (/ 1. 0 3)) (pi-sum-iter (- n 1) (+ acc (/ 1 (* (+ (* n 4) 1) (+ (* n 4) 3 )))) (define pi-sum (lambda (n) (pi-sum-iter n 0))) >(* 8 (pi-sum 1000)) 3. 141093153121449 Time(n) = O(n) Space(n) = O(1)

פרוצדורות מסדר גבוה : נכתוב פרוצדורה הבודקת האם שורש וריבוע הן פונקציות הפוכות ; ; ; Signature: sqrt-of-sqr (n) Type: [Number -> Boolean] Purpose: check if functions sqrt and sqr are inverted for n. Pre-conditions: n >= 0 Post-condition: result = #t iff sqrt(sqr(n))=n. Tests: (test (sqrt-of-sqr 2) => #t) (define sqrt-of-sqr (lambda (n) (= (sqrt (sqr n))) �

פרוצדורות מסדר גבוה , מקומיות כלשהן - נבדוק עבור פונקציות חד : נכליל את הרעיון : האם הן הפוכות , אשר מקבלות מספרים כפרמטר � ; Signature: inverse-test (f 1 f 2 n) ; Type: [[T -> Number] * [Number ->T] * Number -> Boolean] ; Purpose: check if functions f 1 and f 2 are inverted for a number n. ; Pre-conditions: true ; Post-condition: result = #t iff f 1(f 2(n)) = n. ; Tests: (inverse-test square sqrt 4) expected value #t (define inverse-test (lambda (f 1 f 2 n) (= (f 1 (f 2 n)))

פרוצדורות מסדר גבוה : דוגמאות ריצה > (define test-inverse-inc-dec (make-inverse-test (lambda (x) (+ x 1)) (lambda (x) (- x 1))) >(test-inverse-inc-dec 5) #t >(define test-inverse-log-exp (make-inverse-test log exp)) >(test-inverse-log-exp 1) #t

פרוצדורות מסדר גבוה : פונקציות ומרכיבה אחת על השנייה 2 נבחן פרוצדורה המקבלת ; signature: compose 2 (f g) ; type: [[T -> T] * [T -> T] -> [T -> T]] ; purpose: compose 2 procedures … ; tests: (test ((compose 2 (lambda(x)(+ x 1)) ; (lambda(x)(* x 2))) 1) ; => 3) (define compose 2 (lambda(f g) (lambda(x) (f (g x)))))

פרוצדורות מסדר גבוה כעת נרצה בצורה דומה לבצע הרכבה של פונקציה על עצמה מספר נתון של . פעמים : החוזה ייראה כך ; signature: compose-self-n (f n) ; type: [[T -> T] * Number -> [T -> T]] ; purpose: compose f on f, n times, using compose 2 procedure. ; the calls to compose 2 are done eagerly right ; when compose-self-n is called, and only once. … ; tests: (test ((compose-self-n (lambda(n) (* n 2)) 10) 1) ; => 2048), ; (test ((compose-self-n (lambda(n) (* n 2)) 0) 10) ; => 20)

פרוצדורות מסדר גבוה . ניזכר בפרוצדורת העלאה בחזקה לפי המימוש הרקורסיבי שראינו קודם ; Signature: exp(b e) ; Type: [Number * Number -> Number] ; Purpose: to compute the function be. ; Pre-conditions: b >= 0, e is natural. ; Tests: (test (exp 2 3) => 8) ; (test (exp 2 4) => 16) ; (test (exp 3 4) => 81) (define exp (lambda (b e) (cond ((= e 0) 1) (else (* b (exp b (- e 1)))))))