1 / 22

Understanding Multiple Representations of Data: Complex Numbers and Data-Directed Programming

This lecture introduces the concept of multiple representations of data, focusing on complex numbers using both rectangular and polar forms. It covers how to tag data effectively and perform operations such as addition, subtraction, multiplication, and division in a data-directed programming paradigm. The lecture includes the implementation of generic arithmetic operations for real, rational, and complex numbers, along with examples to illustrate the principles of message passing and intelligent data objects. This foundational knowledge prepares students for further exploration in programming concepts.

calder
Télécharger la présentation

Understanding Multiple Representations of Data: Complex Numbers and Data-Directed Programming

An Image/Link below is provided (as is) to download presentation 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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. Multiple representations of data מבוא מורחב

  3. Complex numbers imaginary 3 + 2i 2 13 atan(2/3) real 3 מבוא מורחב

  4. How do we have them both ? We tag the data: ('rectangular 3 2) ('polar (sqrt 13) (atan 2 3)) מבוא מורחב

  5. How do we have them both ? We tag the data: (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) (if (pair? datum) (cdr datum) (error "Bad tagged datum -- CONTENTS" datum))) מבוא מורחב

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

  7. Data-directed programming (Cont) Assume we have (put <op> <type> <item>) (get <op> <type>) (put 'real-part '(rectangular) foo) => undef (get 'real-part '(rectangular)) => foo (put 'a '(a b c) foo1) => undef (get 'a '(a b c)) => foo1 will do them later in the course. מבוא מורחב

  8. Generic selectors (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 (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)))))) מבוא מורחב

  9. Example (real-part ’(rectangular 3 2)) (apply-generic ’real-part ’(rectangular 3 2)) (let ((type-tags (map type-tag ((’rectangular 3 2))))) (let ((proc (get ’real-part type-tags))) (if proc (apply proc (map contents ((’rectangular 3 2)))) (error . . .)))) (let ((proc (get ’real-part (’rectangular)))) (if proc (apply proc ((3 2))) (error . . .))) מבוא מורחב

  10. 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)))) ;; interface to the rest of the system (define (tag x) (attach-tag 'rectangular x)) (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)

  11. Finally (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)) מבוא מורחב

  12. Alternative -- message passing style Make “intelligent” data objects. decompose the table by column types Polar Rectangular real-part imag-part magnitude angle real-part-rectangular imag-part-rectangular magnitude-rectangular angle-rectangular real-part-polar imag-part-polar magnitude-polar angle-polar operations מבוא מורחב

  13. Message passing style (define (make-from-real-imag x y) (lambda (op) (cond ((eq? op 'real-part) x) ((eq? op 'imag-part) y) ((eq? op 'magnitude) (sqrt (+ (square x) (square y)))) ((eq? op 'angle) (atan y x)) (else (error . . . ))))) (define (real-part z) (z 'real-part)) (define (imag-part z) (z 'imag-part)) (define (magnitude z) (z 'magnitude)) (define (angle z) (z 'angle)) מבוא מורחב

  14. Example (message passing) (define x (make-from-real-imag 3 2)) (define x(lambda (op) (cond ((eq? op 'real-part) 3) ((eq? op 'imag-part) 2) ((eq? op 'magnitude) (sqrt (+ (square 3) (square 2)))) ((eq? op 'angle) (atan 2 3)) (else (error . . . ))))) (real-part x) (x 'real-part) ==> 3 מבוא מורחב

  15. Message passing style (define (make-from-mag-ang r a) (lambda (op) (cond ((eq? op 'real-part) (* r (cos a))) ((eq? op 'imag-part) (* r (sin a))) ((eq? op 'magnitude) r) ((eq? op 'angle) a) (else (error . . . ))))) מבוא מורחב

  16. Another example for data directed prog. מבוא מורחב

  17. add sub mul div add-complex sub-complex mul-complex div-complex add-rat sub-rat mul-rat div-rat Generic arithmetic operations real-part imag-part magnitude angle rectangular polar

  18. Generic arithmetic operations (’rational 1 2) (’complex ’rectangular 3 2) (’complex ’polar 2 2) מבוא מורחב

  19. Generic arithmetic operations (define (add x y) (apply-generic 'add x y)) (define (sub x y) (apply-generic 'sub x y)) (define (mul x y) (apply-generic 'mul x y)) (define (div x y) (apply-generic 'div x y)) (add (’rational 3 4) (’rational 1 2)) (apply-generic 'add (’rational 3 4) (’rational 1 2)) (let ((type-tags (map type-tag ((’rat. 3 4) (’rat. 1 2))))) (let ((proc (get 'add type-tags))) (if proc (apply proc (map contents ((’rat. 3 4) (’rat. 1 2)))) (error . . . )))) (let ((proc (get 'add ((’rat. 3 4) (’rat. 1 2))))) (if proc (apply proc (map contents ((’rat. 3 4) (’rat. 1 2)))) (error . . . )))

  20. Generic arithmetic operations (define (install-rational-package) ;; internal procedures (define (numer x) (car x)) (define (denom x) (cdr x)) (define (make-rat n d) . . .) (define (add-rat x y) . . .) . . . ;; interface to rest of the system (define (tag x) (attach-tag 'rational x)) (put 'add '(rational rational) (lambda (x y) (tag (add-rat x y)))) (put 'sub '(rational rational) (lambda (x y) (tag (sub-rat x y)))) . . . (put 'make 'rational (lambda (n d) (tag (make-rat n d)))) 'done)

  21. Generic arithmetic operations (define (install-complex-package) (define (make-from-real-imag x y) ((get 'make-from-real-imag 'rectangular) x y)) (define (make-from-mag-ang x y) .. ) ;; internal procedures (define (add-complex z1 z2) . . .) (define (sub-complex z1 z2) . . .) . . . ;; interface to rest of the system (define (tag z) (attach-tag 'complex z)) (put 'add '(complex complex) (lambda (z1 z2) (tag (add-complex z1 z2)))) (put 'sub '(complex complex) (lambda (z1 z2) (tag (sub-complex z1 z2)))) (put 'make-from-real-imag 'complex (lambda (x y) (tag (make-from-real-imag x y)))) (put 'make-from-mag-ang 'complex ….) 'done)

  22. Generic arithmetic operations (define (make-rational n d) ((get 'make 'rational) n d)) (define (make-complex-from-real-imag x y) ((get 'make-from-real-imag 'complex) x y)) (define (make-complex-from-mag-ang r a) ((get 'make-from-mag-ang 'complex) r a))

More Related