Lecture 11: Multiple representations of abstract data Message passing Overloading Section 2.4, pages 169-187 2.5.1,2.5.2 pages 187-197 מבוא מורחב

Complex numbers a+bi = r(cos  + i sin ) = r ei r=  =atan(2/3) 13  =atan(2/3) = r(cos  + i sin ) = r ei r= imaginary real מבוא מורחב

Complex numbers arithmetic (a + bi) + (c + di) = (a+c) + (b+d)i (a + bi) * (c + di) = (ac-bd)+(ad+bc)i r1 e(i) * r2 e(i) = (r1r2) e(i(+)) מבוא מורחב

המימוש שמדמיין אריאל Constructor: (define (make-complex x y) (cons x y)) Selectors: (define (real-part z) (car z)) (define (imag-part z) (cdr z)) Metohds: (define (add-complex z1 z2) (make-complex (+ (real-part z1) (real-part z2)) (+ (imag-part z1) (imag-part z2)))) (define (sub-complex z1 z2) (make-complex (- (real-part z1) (real-part z2)) (- (imag-part z1) (imag-part z2)))) מבוא מורחב

המימוש מהזווית של מני Constructors: (define (make-complex r a) (cons r a)) Selectors: (define (magnitude z) (car z)) (define (angle z) (cdr z)) (define (real-part z) (* (magnitude z) (cos (angle z)))) (define (imag-part z) (* (magnitude z) (sin (angle z)))) Methods: (define (mul-complex z1 z2) (make-complex (* (magnitude z1) (magnitude z2)) (+ (angle z1) (angle z2)))) מבוא מורחב

How do we have them both ? We tag the data: ('rectangular 3 2) ('polar (sqrt 13) (atan 2 3)) (define (attach-tag type-tag contents) (cons type-tag contents)) (define (type-tag datum) (if (pair? datum) (car datum) (error "Bad tagged datum -- TYPE-TAG" datum))) (define (contents datum) (cdr datum) (error "Bad tagged datum -- CONTENTS" datum))) The way we really tag the data: (cons ‘rectangular (cons 3 2)) מבוא מורחב

Complex numbers: having both reps. (define (rectangular? z) (eq? (type-tag z) 'rectangular)) (define (polar? z) (eq? (type-tag z) 'polar)) (define (real-part z) (cond ((rectangular? z) (real-part-rectangular (contents z))) ((polar? z) (real-part-polar (contents z))) (else (error "Unknown type" z)))) מבוא מורחב

Complex numbers: having both reps. (define (magnitude z) (cond ((rectangular? z) (magnitude-rectangular (contents z))) ((polar? z) (magnitude-polar (contents z))) (else (error "Unknown type“ z)))) angle, imag-part are similar Net effect: we can have the same methods in both representation. Regardless of how we implement the object. מבוא מורחב

and we have to rename (define (real-part-rectangular z) (car z)) (define (imag-part-rectangular z) (cdr z)) (define (magnitude-rectangular z) (sqrt (+ (square (real-part-rectangular z)) (square (imag-part-rectangular z))))) (define (angle-rectangular z) (atan (imag-part-rectangular z) (real-part-rectangular z))) (define (make-rectangular-comlex x y) (attach-tag 'rectangular (cons x y))) מבוא מורחב

and we have to rename (define (real-part-polar z) (* (magnitude-polar z) (cos (angle-polar z)))) (define (imag-part-polar z) (* (magnitude-polar z) (sin (angle-polar z)))) (define (magnitude-polar z) (car z)) (define (angle-polar z) (cdr z)) (define (make-polar-complex r a) (attach-tag 'polar (cons r a))) מבוא מורחב

Two data types vs. One tagged data-type We could have implemented two different data types: rectangulr-complex and polar-complex Instead we implement one data type: complex And we tag both representations. We implement the methods so that they work for both representations. As a result: whatever way we choose to represent the object, we see the same picture of the world. מבוא מורחב

Tagged data as an abstraction barrier. Outer world applications Methods: add-complex, sub-complex real-part imag-part magnitude angle Interface: polar representation Rectangular Representation: מבוא מורחב

Difficulties The system is Not modular Bureacratic The generic selectors must know about all reps. If we want to add a new representation we need to Add it to each of the methods, Be careful with name clashes. (define (real-part z) (cond ((rectangular? z) … real_part_polar … ((polar? z) … real_part_rectangular … (else …))) מבוא מורחב

Data directed programming work with a table: types Polar Rectangular real-part imag-part magnitude angle real-part-rectangular imag-part-rectangular magnitude-rectangular angle-rectangular operations real-part-polar imag-part-polar magnitude-polar angle-polar מבוא מורחב

Data-directed programming (Cont) Assume we have (put <op> <type> <item>) (get <op> <type>) will do them later in the course. Put and get work on a global table. It’s not a good way to write a code, but it will simplify things for us. The table associates labels to rows and vectors. We don’t describe how to implement it, but still we give one possible way of doing it, so that we have a concrete way to think of it. We keep list of pairs, each pair is a column name (tag) and a column. A column is a list of pairs, each pair is a row name and a value. מבוא מורחב

Rectangular implementation (define (install-rectangular-package) ;; internal procedures (define (real-part z) (car z)) (define (imag-part z) (cdr z)) ... (define (make-from-mag-ang r a) (cons (* r (cos a)) (* r (sin a)))) (define (tag x) (attach-tag 'rectangular x)) ;; interface to the rest of the system (put 'real-part '(rectangular) real-part) (put 'imag-part '(rectangular) imag-part) (put 'magnitude '(rectangular) magnitude) (put 'angle '(rectangular) angle) (put 'make-from-real-imag 'rectangular (lambda (x y) (tag (make-from-real-imag x y)))) (put 'make-from-mag-ang 'rectangular (lambda (r a) (tag (make-from-mag-ang r a)))) 'done) Why do we sometimes put the type in a list??? Constructors are a special case- We tag them according to the output type rather than the input type.

Polar implementation (define (install-polar-package) ;; internal procedures (define (magnitude z) (car z)) (define (angle z) (cdr z)) ... (define (make-from-real-imag x y) (cons (sqrt (+ (square x) (square y))) (atan y x))) (define (tag x) (attach-tag 'polar x)) ;; interface to the rest of the system (put 'real-part '(polar) real-part) (put 'imag-part '(polar) imag-part) (put 'magnitude '(polar) magnitude) (put 'angle '(polar) angle) (put 'make-from-real-imag 'polar (lambda (x y) (tag (make-from-real-imag x y)))) (put 'make-from-mag-ang 'polar (lambda (r a) (tag (make-from-mag-ang r a)))) 'done)

Generic selectors Methods: (define (real-part z) (apply-generic 'real-part z)) (define (imag-part z) (apply-generic 'imag-part z)) (define (magnitude z) (apply-generic 'magnitude z)) (define (angle z) (apply-generic 'angle z)) (define (simple-apply-generic op arg) (let ((type-tag (type-tag arg))) (let (proc (get op (list type-tag))) (if proc (proc (contents arg)) (error "No method for these types -- APPLY-GENERIC" (list op type-tag))))) מבוא מורחב

apply-generic f(complex-polar ,complex-rect , complex-polar) (define (apply-generic op . args) (let ((type-tags (map type-tag args))) (let (proc (get op type-tags))) (if proc (apply proc (map contents args)) (error "No method for these types -- APPLY-GENERIC" (list op type-tags)))))) f(complex-polar ,complex-rect , complex-polar) Will look for the function f stored for tag (polar,rectangular,number) מבוא מורחב

Finally Constructors are a special case- We tag them according to the output type rather than the input type. They require special handling. (define (make-from-real-imag x y) ((get 'make-from-real-imag 'rectangular) x y)) (define (make-from-mag-ang r a) ((get 'make-from-mag-ang 'polar) r a)) מבוא מורחב

Data directed programming. The data (arguments) trigger the right method based on the data type. Data directed programming is more modular: To add a representation, we only need to write a package for the new representation without affecting the other source code. Changes are local. install-polar-package install-rectangular-package מבוא מורחב

Overloading So far: Generic methods that deal with different representations. Next step: Generic methods that deal with different types of arguments. (+ int int) (+ real real) (+ int real) Overloading מבוא מורחב

Operations on mixed types What about (+ complex real) ? We can add new methods to handle mixed types. Cumbersome Not modular. 2. Coercion. For the arithmetic example we can translate more specific types to the more general types. E.g. given (+ complex real) , view the real number as complex And apply (+ complex complex). מבוא מורחב