Lecture 7

1 / 36

# Lecture 7 - PowerPoint PPT Presentation

Lecture 7. Data Abstraction. Pairs and Lists. (Sections 2.1.1 – 2.2.1). Export only what is needed. Interface. Implementation. Procedural abstraction. Publish: name, number and type of arguments (and conditions they must satisfy)

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

## PowerPoint Slideshow about 'Lecture 7' - harvey

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

### Lecture 7

Data Abstraction.

Pairs and Lists.

(Sections 2.1.1 – 2.2.1)

מבוא מורחב שיעור 7

Export only what is needed.

Interface

Implementation

Procedural abstraction
• Publish: name, number and type of arguments
• (and conditions they must satisfy)
• type of procedure’s return value
• Guarantee: the behavior of the procedure
• Hide: local variables and procedures,
• way of implementation,
• internal details, etc.

מבוא מורחב שיעור 7

Export only what is needed.

Interface

Implementation

Data-object abstraction
• Publish:constructors, selectors
• Guarantee: the behavior
• Hide: local variables and procedures,
• way of implementation,
• internal details, etc.

מבוא מורחב שיעור 7

An example: Rational numbers

We would like to represent rational numbers.

A rational number is a quotient a/b of two integers.

Constructor: (make-rat a b)

Selectors: (numer r)

(denom r)

Guarantee:(numer (make-rat a b)) = a

(denom (make-rat a b)) = b

מבוא מורחב שיעור 7

An example: Rational numbers

We would like to represent rational numbers.

A rational number is a quotient a/b of two integers.

Constructor: (make-rat a b)

Selectors: (numer r)

(denom r)

A betterGuarantee:

(numer (make-rat a b))

a

=

b

(denom (make-rat a b))

A weaker condition, but still sufficient!

מבוא מורחב שיעור 7

We can now use the constructors and selectors to implement operations on rational numbers:

(sub-rat x y)

(mul-rat x y)

(div-rat x y)

(equal-rat? x y)

(print-rat x)

A form of wishful thinking: we don’t know how make-ratnumer anddenom are implemented, but we use them.

מבוא מורחב שיעור 7

Implementing the operations

(define (add-rat x y);n1/d1 + n2/d2 = (n1.d2 + n2.d1) / (d1.d2)

(make-rat (+ (* (numer x) (denom y))

(* (numer y) (denom x)))

(* (denom x) (denom y))))

(define (sub-rat x y) …

(define (mul-rat x y)

(make-rat (* (numer x) (numer y))

(* (denom x) (denom y))))

(define (div-rat x y)

(make-rat (* (numer x) (denom y))

(* (denom x) (numer y))))

(define (equal-rat? x y)

(= (* (numer x) (denom y))(* (numer y) (denom x))))

מבוא מורחב שיעור 7

Using the rational package

(define (print-rat x)

(newline)

(display (numer x))

(display ”/”)

(display (denom x)))

(define one-half (make-rat 1 2))

(print-rat one-half)  1/2

(define one-third (make-rat 1 3))

(print-rat (add-rat one-half one-third))  5/6

(print-rat (add-rat one-third one-third))  6/9

מבוא מורחב שיעור 7

Programs that use rational numbers

make-rat numer denom

Abstraction barriers

rational numbers in problem domain

rational numbers as numerators and denumerators

מבוא מורחב שיעור 7

Gluing things together

We still have to implement numer, denom, and make-rat

We need a way to glue things together…

A pair:

(define x (cons 1 2))

(car x)  1

(cdr x)  2

מבוא מורחב שיעור 7

Pair: A primitive data type.

Constructor: (cons a b)

Selectors: (car p)

(cdr p)

Guarantee:(car (cons a b)) = a

(cdr (cons a b)) = b

Abstraction barrier: We say nothing about the

representation or implementation of pairs.

מבוא מורחב שיעור 7

Pairs

(define x (cons 1 2))

(define y (cons 3 4))

(define z (cons x y))

(car (car z))  1 ;(caar z)

(car (cdr z))  3 ;(cadr z)

מבוא מורחב שיעור 7

Implementing make-rat, numer, denom

(define (make-rat n d) (cons n d))

(define (numer x) (car x))

(define (denom x) (cdr x))

מבוא מורחב שיעור 7

Programs that use rational numbers

make-rat numer denom

cons car cdr

Abstraction barriers

rational numbers in problem domain

rational numbers as numerators and denumerators

rational numbers as pairs

מבוא מורחב שיעור 7

Abstraction

Violation

(cons (+ (* (car x) (cdr y))

(* (car y) (cdr x)))

(* (cdr x) (cdr y))))

If we bypass an abstraction barrier,

changes to one level may affect many levels above it.

Maintenance becomes more difficult.

מבוא מורחב שיעור 7

Rationals - Alternative Implementation

• In our current implementation we keep 10000/20000
• as such and not as 1/2.
• This:
• Makes the computation more expensive.
• Prints out clumsy results.

A solution: change the constructor

(define (make-rat a b)

(let ((g (gcd a b)))

(cons (/ a g) (/ b g))))

No other changes are required!

מבוא מורחב שיעור 7

Reducing to lowest terms, another way

(define (make-rat n d)

(cons n d))

(define (numer x)

(let ((g (gcd (car x) (cdr x))))

(/ (car x) g)))

(define (denom x)

(let ((g (gcd (car x) (cdr x))))

(/ (cdr x) g)))

מבוא מורחב שיעור 7

How can we implement pairs? (first solution)

(define (cons x y)

(lambda (f) (f x y)))

(define (car z)

(z (lambda (x y) x)))

(define (cdr z)

(z (lambda (x y) y)))

מבוא מורחב שיעור 7

Name Value

p

(lambda(f) (f 1 2))

( (lambda(f) (f 1 2)) (lambda (x y) x))

( (lambda(x y) x) 1 2 )

> 1

How can we implement pairs? (first solution, cont’)

> (define p (cons 1 2))

> (car p)

(define (cons x y)

(lambda (f) (f x y)))

(define (car z)

(z (lambda (x y) x)))

(define (cdr z)

(z (lambda (x y) y)))

מבוא מורחב שיעור 7

(define (cons x y)

(lambda (m)

(cond ((= m 0) x)

((= m 1) y)

(else (error "Argument not 0 or 1 -- CONS" m))))))

(define (car z) (z 0))

(define (cdr z) (z 1))

מבוא מורחב שיעור 7

((lambda(m) (cond ..)) 0)

(cond ((= 0 0) 3) ((= 0 1) 4) (else ...)))

> 3

Implementing pairs (second solution, cont’)

Name Value

> (define p (cons 3 4))

p

(lambda(m)

(cond ((= m 0) 3)

((= m 1) 4)

(else ..)))

> (car p)

(define (cons x y)

(lambda (m)

(cond ((= m 0) x)

((= m 1) y)

(else ...)))

(define (car z)

(z 0))

(define (cdr z)

(z 1))

מבוא מורחב שיעור 7

Implementation of Pairs -The way it is really done
• Scheme provides an implementation of pairs, so we do not need to use these “clever” implementations.
• The natural implementation is by using storage.
• The two solutions we presented show that the distinction between storage and computation is not always clear.
• Sometimes we can trade data for computation.
• The solutions we showed have their own significance:
• The first is used to show that lambda calculus can simulate other models of computation (theoretical importance).
• The second – message passing – is the basis for Object Oriented Programming. We will return to it later.

מבוא מורחב שיעור 7

a

2

1

Box and Pointer Diagram
• (define a (cons 1 2))
• A pair can be implemented directly using two “pointers”.
• Originally on IBM 704:
• (car a)Contents of Address part of Register
• (cdr a)Contents of Decrement part of Register

מבוא מורחב שיעור 7

4

3

1

2

Box and pointer diagrams (cont.)
• (cons (cons 1 (cons 2 3)) 4)

מבוא מורחב שיעור 7

Pairs have the closure property:

• We can pair pairs, pairs of pairs etc.
• (cons (cons 1 2) 3)

3

2

1

Compound Data

A closure property: 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.

מבוא מורחב שיעור 7

3

1

2

Lists

The empty list (a.k.a. null or nill)

• (cons 1 (cons 3 (cons 2 ’())))
• Syntactic sugar:(list 1 3 2)

מבוא מורחב שיעור 7

Formal Definition of a List

A list is either

• ’() -- The empty list
• A pair whose cdr is a list.

Lists are closed under the operations consand cdr:

• If lst is a non-empty list, then (cdr lst) is a list.
• If lst is a list and x is arbitrary, then (cons x lst) is a list.

מבוא מורחב שיעור 7

<x1>

<x2>

<xn>

Lists

(list <x1> <x2> ... <xn>)

is syntactic sugar for

(cons <x1> (cons <x2> ( … (cons <xn> ’() ))))

מבוא מורחב שיעור 7

1

3

2

2

3

Lists (examples)

The following expressions all result in the same structure:

(cdr (list 1 2 3))

(cdr (cons 1 (cons 2 (cons 3 ’() ))))

(cons 2 (cons 3 ’() ))

(list 2 3)

(cons 3 (list 1 2))

(cons 3 (cons 1 (cons 2 ’() )))

(list 3 1 2)

and similarly the following

מבוא מורחב שיעור 7

1

4

3

2

4

3

1

2

4

3

1

2

More Elaborate Lists

(list 1 2 3 4)

(cons (list 1 2) (list 3 4))

(list (list 1 2) (list 3 4))

• Prints as (1 2 3 4)
• Prints as ((1 2) 3 4)
• Prints as ((1 2) (3 4))

מבוא מורחב שיעור 7

p1

3

p

1

2

p2

Yet More Examples
• (define p (cons 1 2))
• p2

( (1 . 2) (1 . 2) )

• p

(1 . 2)

• (define p1 (cons 3 p)
• p1

(3 1 . 2)

• (define p2 (list p p))

מבוא מורחב שיעור 7

The Predicate Null?

null? : anytype -> boolean

(null? <z>)

#t if <z> evaluates to empty list

#f otherwise

(null? 2)  #f

(null? (list 1))  #f

(null? (cdr (list 1)))  #t

(null? ’())  #t

(null? null)  #t

מבוא מורחב שיעור 7

The Predicate Pair?

pair? : anytype -> boolean

(pair? <z>) #tif <z> evaluates to a pair

#f otherwise.

(pair? (cons 1 2))  #t

(pair? (cons 1 (cons 1 2)))  #t

(pair? (list 1))  #t

(pair? ’())  #f

(pair? 3)  #f

(pair? pair?)  #f

מבוא מורחב שיעור 7

The Predicate Atom?

atom? : anytype -> boolean

(define (atom? z)

(and (not (pair? z))

(not (null? z))))

(define (square x) (* x x))

(atom? square)  #t

(atom? 3)  #t

(atom? (cons 1 2))  #f

מבוא מורחב שיעור 7

(define digits1 (cons 0 digits))

• digits1
• (define l (list 0 digits))
• l

?

More examples
• (define digits (list 1 2 3 4 5 6 7 8 9))

?

(0 1 2 3 4 5 6 7 8 9)

(0 (1 2 3 4 5 6 7 8 9))

מבוא מורחב שיעור 7

The procedurelength
• (define digits (list 1 2 3 4 5 6 7 8 9))
• (length digits)

9

• (define l null)
• (length l)

0

• (define l (cons 1 l))
• (length l)

1

(define (length l)

(if (null? l) 0

(+ 1 (length (cdr l)))))

מבוא מורחב שיעור 7