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

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

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

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

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

;; si on veut retrouver l'interface scheme habituelle il faut 
;; définir +c, -c, *c et /c de la façon suivante

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

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

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

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

(define (displayZ z1)
  (z1))
;;---------------------------------------
(define (creer-rectangulaire x y)
  (define (carre z) 
    (* z z))
  (define (norme reel imag)
    (sqrt (+ (carre reel) (carre imag))))
  (define (theta reel imag)
    (atan imag reel))
  (lambda args
    (if (null? args)
        (format "(~s+~si)" x y)
        (let ((m (car args))
              (reste (cdr args)))
          (cond ;; partie pour créer les sélecteurs
            ((eq? m 'partie-reelle) 
             x)
            ((eq? m 'partie-imaginaire) 
             y)
            ((eq? m 'module) 
             (norme x y))
            ((eq? m 'angle) 
             (theta x y))
;; partie pour cr?er les opérations
            ((eq? m '+c)
             (if (null? reste)
                 (creer-rectangulaire x y)
                 (let ((c2 (car reste)))
                   (creer-rectangulaire
                    (+ x
                       (partie-reelle c2))
                    (+ y
                       (partie-imaginaire c2))))))
            ((eq? m '-c)
             (if (null? reste)
                 (creer-rectangulaire x y)
                 (let ((c2 (car reste)))
                   (creer-rectangulaire
                    (- x
                       (partie-reelle c2))
                    (- y
                       (partie-imaginaire c2))))))
            ((eq? m '*c)
             (if (null? reste)
                 (creer-rectangulaire x y)
                 (let ((c2 (car reste)))
                   (creer-polaire
                    (* (norme x y) (module c2))
                    (+ (theta x y) (angle c2))))))
            ((eq? m '/c)
             (if (null? reste)
                 (creer-rectangulaire x y)
                 (let ((c2 (car reste)))
                   (creer-polaire
                    (/ (norme x y) (module c2))
                    (- (theta x y) (angle c2))))))
            
            (else (error "pas de methode" m 'dans 'la 'classe 'rectangulaire)))))))

(define (creer-polaire mo a)
  (lambda args
    (let* ((show (null? args))
           (m (if (not show) (car args)))
           (c2 (if (and (pair? args) (pair? (cdr args))) (cadr args)))
           (reel (* mo (cos a)))
           (imag (* mo (sin a))))
      (if show 
          (format "(~s _expi_ ~s)" mo a)
          (cond((eq? m 'partie-reelle) reel)
               ((eq? m 'partie-imaginaire) imag)
               ((eq? m 'module) mo)
               ((eq? m 'angle) a)
               ;; partie pour créer les opérations
               ((eq? m '+c)
                (if (not c2)
                    (creer-polaire mo a)
                    (creer-rectangulaire
                     (+ reel
                        (partie-reelle c2))
                     (+ imag
                        (partie-imaginaire c2)))))
               ((eq? m '-c)
                (if (not c2)
                    (creer-polaire mo a)
                    (creer-rectangulaire
                     (- reel (partie-reelle c2))
                     (- imag (partie-imaginaire c2)))))
               ((eq? m '*c)
                (if (not c2)
                    (creer-polaire mo a)
                    (creer-polaire
                     (* mo (module c2))
                     (+ a (angle c2)))))
               ((eq? m '/c)
                (if (not c2)
                    (creer-polaire mo a)
                    (creer-polaire
                     (/ m (module c2))
                     (- a (angle c2)))))
               
               (else (error "pas de methode" m 'dans 'la 'classe 'rectangulaire)))))))



(define z1 (creer-rectangulaire 1 2))
'z1
z1
'(z1)
(z1)
(define z2 (creer-polaire 5 (atan 4 3)))
'z2
z2
'(z2)
(z2)
'(partie-reelle z1)
(partie-reelle z1)
'((*c (+c z1 z1) z2))
((*c (+c z1 z1) z2))
(define z3 (/c z1 z1))
'z3
z3
'(z3)
(z3)
'((+c z2 z3))
((+c z2 z3))
'((z1 '/c z2))
((z1 '/c z2))