1. Lecture #7
מבוא מורחב

2. The rational number abstraction
Wishful thinking:
Constructor:
Selectors:
(make-rat <n> <d>) Creates a rational number <r>
(numer <r>) Returns the numerator of <r>
(denom <r>) Returns the denominator of <r>
מבוא מורחב

3. A contract (numer (make-rat <n> <d>)) <n> =
(denom (make-rat <n> <d>)) =
<n>
<d>
How do we do it ?
מבוא מורחב

4. Using pairs (define (make-rat n d) (cons n d))
(define (numer x) (car x))
(define (denom x) (cdr x))
מבוא מורחב

5. Alternative implementation
(define (add-rat x y)
(make-rat (+ (* (numer x) (denom y))
(* (numer y) (denom x)))
(* (denom x) (denom y))))
Abstraction
Violation
(define (add-rat x y)
(cons (+ (* (car x) (cdr y))
(* (car y) (cdr x)))
(* (cdr x) (cdr y))))
מבוא מורחב

6. Reducing to lowest terms
(define (make-rat n d)
(let ((g (gcd n d)))
(cons (/ n g) (/ d g))))
מבוא מורחב

7. Programs that use rational numbers
Abstraction barriers
Programs that use rational numbers
add-rat sub-rat …….
make-rat numer denom
car cdr cons
מבוא מורחב

8. How can we implement pairs ?
(define (cons x y)
(lambda (m)
(cond ((= m 0) x)
((= m 1) y)
(else (error "Argument not 0 or CONS" m))))))
(define (car z) (z 0))
(define (cdr z) (z 1))
מבוא מורחב

9. The pair constructed by (cons 6 9) is the procedure
(lambda (m)
(cond ((= m 0) 6)
((= m 1) 9)
(else (error “Argument not 0 or 1 -- CONS” m))))
מבוא מורחב

10. In the book: (define (cons x y) (define (dispatch m) (cond ((= m 0) x)
((= m 1) y)
(else (error "Argument not 0 or CONS" m))))
dispatch)
(define (car z) (z 0))
(define (cdr z) (z 1))
מבוא מורחב

11. Compound data
Ideally want the result of this “gluing” to have the property of closure:
“the result obtained by creating a compound data structure can itself be treated as a primitive object and thus be input to the creation of another compound object”
מבוא מורחב

12. Box and pointer diagram
Note how pairs have the property of closure – we can use the result of a pair as an element of a new pair:
(cons (cons 1 2) 3) 3 2 1
מבוא מורחב

13. Box and pointer diagram
(cons (cons 1 (cons 2 3)) 4) 4 1 3 2
מבוא מורחב

14. Lists
(cons 1 (cons 3 (cons 2 ‘()))) 3 1 2
מבוא מורחב

15. lists A list is either ‘() (The empty list)
A pair whose cdr is a list.
Note that lists are closed under operations of cons and cdr.
מבוא מורחב

16. … Lists (list <el1> <el2> ... <eln>) Same as
(cons <el1>
(cons <el2> (cons … (cons <eln> ‘()))))
<el1>
<el2>
<eln> …
מבוא מורחב

17. Lists
Predicates
; null? anytype -> boolean (null? <z>) ==> #t if <z> evaluates to empty list
; pair? anytype -> boolean (pair? <z>) ==> #t if <z> evaluates to a pair
; atom? anytype -> boolean (define (atom? z)
(and (not (pair? z)) (not (null? z))))
מבוא מורחב

18. Lists -- examples (define one-to-four (list 1 2 3 4))
( ) ==>
error
(car one-to-four) ==> 1
(car (cdr one-to-four)) ==> 2
(cadr one-to-four) ==> 2
(caddr one-to-four) ==> 3
מבוא מורחב

19. Common Pattern #1: cons’ing up a list
(define (enumerate-interval from to)
(if (> from to)
nil
(cons from
(enumerate-interval
(+ 1 from)
to))))
(e-i 2 4)
(if (> 2 4) nil (cons 2 (e-i (+ 1 2) 4)))
(if #f nil (cons 2 (e-i 3 4)))
(cons 2 (e-i 3 4))
(cons 2 (cons 3 (e-i 4 4)))
(cons 2 (cons 3 (cons 4 (e-i 5 4))))
(cons 2 (cons 3 (cons 4 nil)))
(cons 2 (cons ))
(cons )
==> (2 3 4) 4 3 4 2 3 4
מבוא מורחב

20. Common Pattern #2: cdr’ing down a list
(define (list-ref lst n)
(if (= n 0)
(car lst)
(list-ref (cdr lst)
(- n 1))))
(define squares (list ))
(list-ref squares 3) ==> 16
מבוא מורחב

21. Common Pattern #2: cdr’ing down a list
(define (length lst)
(if (null? lst)
(+ 1 (length (cdr lst)))))
(define odds (list ))
(length odds) ==> 4
מבוא מורחב

22. Iterative length (define (length items) (define (length-iter a count)
(if (null? a)
count
(length-iter (cdr a) (+ 1 count))))
(length-iter items 0))
מבוא מורחב

23. Cdr’ing and Cons’ing Examples
(define (append list1 list2)
(cond ((null? list1) list2) ; base
(else
(cons (car list1) ; recursion
(append (cdr list1)
list2)))))
(append (list 1 2) (list 3 4))
(cons 1 (append (2) (3 4)))
(cons 1 (cons 2 (append () (3 4))))
(cons 1 (cons 2 (3 4)))
==> ( )
T(n) = (n)

24. Reverse (reverse (list 1 2 3 4)) ==> (4 3 2 1)
(define (reverse lst)
(cond ((null? lst) lst)
(else (append (reverse (cdr lst)) (list (car lst)))))))
(reverse (list 1 2 3))
(append (reverse (2 3)) (1))
(append (append (reverse (3)) (2)) (1))
(append (append (append (reverse ()) (3)) (2)) (1))
Append: T(n) = c*n  (n)
Reverse: T(n) = c*(n-1) + c*(n-2) … c*1  (n2)

25. Shall we have some real fun ..
Lets write a procedure scramble..
(scramble (list )) ==> ( )
(scramble (list )) ==> ( )
(scramble (list )) ==> ( )
(scramble (list )) ==> ( )
מבוא מורחב

26. Ok ok
Each number in the argument is treated as backword index from its own position to a point earlier in the tup.
The result at each position is found by counting backward from the current position according to this index
==> No number can be greater than its index
מבוא מורחב

27. tup = (0 1 2 1) rev-pre = () (cons 0 ….
tup = (1 2 1) rev-pre = (0) (cons 0 (cons 0
tup = (2 1) rev-pre = (1 0) (cons 0 (cons 0 (cons 0
tup = (1) rev-pre = (2 1 0) (cons 0 (cons 0 (cons 0 (cons 2
tup = ( ) rev-pre = ( ) (cons 0 (cons 0 (cons 0 (cons 2 ()))))
מבוא מורחב

28. (define (scramble-i tup rev-pre) (if (null? tup) '()
(cons ( (cons (car tup) rev-pre)
(car tup))
( (cdr tup)
(cons (car tup) rev-pre)))))
list-ref
scramble-i
(define (scramble tup)
(scramble-b tup '()))
מבוא מורחב