;; ************ interface **************
;; On définit partie-reelle, partie-imaginaire, module, angle
;; comme pour la transmission de message sans argument

;; attention il faut redéfinir module au top avant de l'utiliser 
;; dans une fonction

(define (partie-reelle z) 
  ((z 'partie-reelle) z))

(define (partie-imaginaire z) 
  ((z 'partie-imaginaire) z))

(define (angle z) 
  ((z 'angle) z))

(define (module z) 
  ((z 'module) z))

;; On redéfinit +c, -c, *c et /c de la manière suivante :

(define (+c z1 z2) 
  ((z1 '+c)  z1 z2))

(define (-c z1 z2) 
  ((z1 '-c)  z1 z2))

(define (*c z1 z2) 
  ((z1 '*c)  z1 z2))

(define (/c z1 z2) 
  ((z1 '/c)  z1 z2))

(define (displayZ z1)
  ((z1 'display) z1))



(define (no-method nom) (list 'no-method nom))

(define method? procedure?)

(define (creer-rectangulaire x y)
  (lambda(m)
    (cond ;; partie pour créer les sélecteurs
      ((eq? m 'partie-reelle)
       (lambda(self) x))
      ((eq? m 'partie-imaginaire)
       (lambda(self) y))
      ((eq? m 'module)
       (lambda(self)
         (sqrt (+ (* x x) (* y y)))))
      ((eq? m 'angle)
       (lambda(self) (atan y x)))
      ;; partie pour créer les opérations
      ((eq? m '+c)
       (lambda(self c2)
         (creer-rectangulaire
          (+ (partie-reelle self)
             (partie-reelle c2))
          (+ (partie-imaginaire self)
             (partie-imaginaire c2)))))
      ((eq? m '-c)
       (lambda(self c2)
         (creer-rectangulaire
          (- (partie-reelle self)
             (partie-reelle c2))
          (- (partie-imaginaire self)
             (partie-imaginaire c2)))))
      ((eq? m '*c)
       (lambda(self c2)
         (creer-polaire
          (* (module self) (module c2))
          (+ (angle self) (angle c2)))))
      ((eq? m '/c)
       (lambda(self c2)
         (creer-polaire
          (/ (module1 self) (module c2))
          (- (angle self) (angle c2)))))
      ;; utilite
      ((eq? m 'display)
       (lambda (self)
         (format "(~s+~si)" (partie-reelle self) (partie-imaginaire self)))) 
      
      (else (no-method 'rectangulaire)))))

(define (creer-polaire mo a)
  (lambda (m)
    (cond ((eq? m 'partie-reelle) 
           (lambda (self) (* mo (cos a))))
          ((eq? m 'partie-imaginaire) 
           (lambda (self) (* mo (sin a))))
          ((eq? m 'module) 
           (lambda (self) mo))
          ((eq? m 'angle)                 
           (lambda (self) a))
          ;; partie pour créer les opérations
          ((eq? m '+c)
           (lambda(self c2)
             (creer-rectangulaire
              (+ (partie-reelle self)
                 (partie-reelle c2))
              (+ (partie-imaginaire self)
                 (partie-imaginaire c2)))))
          ((eq? m '-c)
           (lambda(self c2)
             (creer-rectangulaire
              (- (partie-reelle self)
                 (partie-reelle c2))
              (- (partie-imaginaire self)
                 (partie-imaginaire c2)))))
          ((eq? m '*c)
           (lambda(self c2)
             (creer-polaire
              (* (module self) (module c2))
              (+ (angle self) (angle c2)))))
          ((eq? m '/c)
           (lambda(self c2)
             (creer-polaire
              (/ (module1 self) (module c2))
              (- (angle self) (angle c2)))))
          ;; utilite
          ((eq? m 'display)
           (lambda (self)
             (format "([~s^~si]" (angle self) (module self))))  
          
          (else (no-method 'rectangulaire)))))

(define z1 (creer-rectangulaire 3 4))
(define z2 (creer-rectangulaire 1 2))

(module z1)
(displayZ (+c z1 z2))
(displayZ (*c z1 z2))