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

1 / 36

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

מבוא מורחב למדעי המחשב בשפת Scheme. תרגול 4. Outline. Repeated f Accelerating computations Fibonacci Let and let* Recursion examples Palindrome? Log Order of growth. f(x), f(f(x)), f(f(f(x))), … apply f, n times. Repeated f. Compose now Execute later. (define (compose f g)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'מבוא מורחב למדעי המחשב בשפת Scheme' - xiang

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

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

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

תרגול 4

Outline
• Repeated f
• Accelerating computations
• Fibonacci
• Let and let*
• Recursion examples
• Palindrome?
• Log
• Order of growth
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

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

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

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

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?
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?

b a a+b 2a+b 3a+2b …

Double Steps
• Fibonacci Transformation:
• 0 1 1 2 3 5 8 13 21
• Double Transformation:
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
Squaring Transformations
• General Linear Transformation:
• Squared:
Iterative Algorithm
• Initialize:
• Stop condition: If count=0 return b
• Step

count is odd

count is even

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!):
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))

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))))

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>)

let*

(let* ((<var1> <exp1>)…

(<varn> <expn>))

<body>)

Is equivalent to

(let ((<var1> <exp1>))

(let* ((<var2> <exp2>)…

(<varn> <expn>))

<body>))

18

let vs. let*

(let ((x 2) (y 3))

(let ((x 7)

(z (+ x y)))

(* z x))) ==> 35

let vs. let*

(let ((x 2) (y 3))

(let* ((x 7)

(z (+ x y)))

(* z x))) ==> 70

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.
Examples

> (palindrome? 1234567)

#f

> (palindrome? 1234321)

#t

> (palindrome? 56865)

#t

Useful functions

(define(least-significantx)

(remainder x 10))

(define(remove-least-significantx) (quotient x 10))

Implementation
• Construct a new number by reversing the digits of the input (x)
• Test whether these two numbers are equal.
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)))

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)))

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)))

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)))

palindrome?

(define(palindrome?x)

(if (< x 0)

#f

(= x (reverse-num x))))

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⌋.

Recursive process

(define (lg n)

(if (= n 1)

0

(+ (lg (floor (/ n 2))) 1)))

Iterative process

(define (lg n)

(define (helper n result)

(if (= n 1)

result

(helper () ())))

(helper n 0))

Iterative process

(define (lg n)

(define (helper n result)

(if (= n 1)

result

(helper (floor (/ n 2)) ())))

(helper n 0))

Iterative process

(define (lg n)

(define (helper n result)

(if (= n 1)

result

(helper (floor (/ n 2)) (+ result 1))))

(helper n 0))

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)