;; Dato astratto "vettore"
;;
;; Operazioni:
;;
;;   (unit-vector)                      :  -> vettore
;;
;;   (vector-length <vector>)           :  vettore -> reale
;;
;;   (add-vectors <vector> <vector>)    :  vettore x vettore -> vettore
;;
;;   (rotate <vector> <angle>)          :  vettore x reale -> vettore
;;
;;   (rescale <vector> <scale-factor>)  :  vettore x reale -> vettore


;; Una terna di vettori si chiude triangolarmente?

(define triangle?
  (lambda (a b c)  ;; a, b, c vettori nel piano
    (< (vector-length (add-vectors (add-vectors a b) c))
       epsylon)
    ))


(define epsylon 1e-10)  ;; precisione desiderata


;; Dato un poligono  regolare  di n lati di lunghezza unitaria,
;; determinare la lunghezza della corda che congiunge i vertici
;; estremi di k lati consecutivi.  Soluzione vettoriale:

(define cord-length
  (lambda (k n)  ;; n > 2, i <= n naturali
    (if (= k 0)
        0
        (vector-length (sum-of-side-vectors k (/ 360 n)))
        )
    ))

(define sum-of-side-vectors
  (lambda (k theta)          ;; k > 0 naturale, theta reale
    (if (= k 1)
        (unit-vector)
        (add-vectors (unit-vector)
             (rotate (sum-of-side-vectors (- k 1) theta) theta))
        )
    ))


;; Il rapporto phi e' la sezione aurea?

(define golden-section?        ;; soluzione "vettoriale" (per esempio)
  (lambda (phi)                ;; phi reale
    (let ((v1 (unit-vector)))
      (let ((v2 (rotate (rescale v1 phi) 90)))
        (let ((v3 (rotate (rescale v2 phi) 90)))
          (triangle? (add-vectors v1 v2)
                     v3
                     (rotate (rescale v2 sqrt2) 135)
                     )
          )))
    ))


(define sqrt2 (sqrt 2))


;; Qual'e' l'interpretazione vettoriale di questa soluzione?
;; Perche' e' corretta?


;; Dato astratto "vettore"
;;
;; Operazioni:
;;
;;   (unit-vector)                      :  -> vettore
;;
;;   (vector-length <vector>)           :  vettore -> reale
;;
;;   (add-vectors <vector> <vector>)    :  vettore x vettore -> vettore
;;
;;   (rotate <vector> <angle>)          :  vettore x reale -> vettore
;;
;;   (rescale <vector> <scale-factor>)  :  vettore x reale -> vettore


;; Prima realizzazione: i vettori sono rappresentati da funzioni
;;
;;   { 'x, 'y } -> reale


(define pi 3.141592654)  ;; pi greco

(define build-vector  ;; procedura di supporto
  (lambda (x y)
    (lambda (coord)   ;; valore funzionale
      (cond ((equal? coord 'x) x)
            ((equal? coord 'y) y)
            (else "?")
            ))
    ))

(define unit-vector
  (lambda ()  ;; funzione di 0 argomenti
    (build-vector 1 0)
  ))

(define vector-length
  (lambda (v)  ;; v vettore
    (let ((x (v 'x)) (y (v 'y)))
      (sqrt (+ (* x x) (* y y)))
    )))

(define add-vectors
  (lambda (u v)  ;; u, v vettori
    (build-vector (+ (u 'x) (v 'x)) (+ (u 'y) (v 'y)))
    ))

(define rotate
  (lambda (v theta)  ;; v vettore, theta reale
    (let ((x (v 'x)) (y (v 'y)) (phi (/ (* theta pi) 180)))
      (let ((alpha (cos phi)) (beta (sin phi)))
        (build-vector (- (* alpha x) (* beta y))
                      (+ (* beta x) (* alpha y))
                      )
    ))))

(define rescale
  (lambda (v s)  ;; v vettore, s reale
    (build-vector (* s (v 'x)) (* s (v 'y)))
    ))


;; Variante:  { "x", "y" } -> reale


(define build-vector  ;; procedura di supporto
  (lambda (x y)
    (lambda (coord)   ;; valore funzionale
      (cond ((equal? coord "x") x)
            ((equal? coord "y") y)
            (else "?")
            ))
    ))

(define vector-length
  (lambda (v)  ;; v vettore
    (let ((x (v "x")) (y (v "y")))
      (sqrt (+ (* x x) (* y y)))
    )))

(define add-vectors
  (lambda (u v)  ;; u, v vettori
    (build-vector (+ (u "x") (v "x")) (+ (u "y") (v "y")))
    ))

(define rotate
  (lambda (v theta)  ;; v vettore, theta reale
    (let ((x (v "x")) (y (v "y")) (phi (/ (* theta pi) 180)))
      (let ((alpha (cos phi)) (beta (sin phi)))
        (build-vector (- (* alpha x) (* beta y))
                      (+ (* beta x) (* alpha y))
                      )
    ))))

(define rescale
  (lambda (v s)  ;; v vettore, s reale
    (build-vector (* s (v "x")) (* s (v "y")))
    ))


;; Altra variante:  { 1, 2 } -> reale
;; Esercizio: scrivere questa versione.


;; Seconda realizzazione:
;; i vettori sono rappresentati da coppie di coordinate cartesiane


(define pi 3.141592654)  ;; pi greco

(define unit-vector
  (lambda ()  ;; funzione di 0 argomenti
    (cons 1 0)
  ))

(define vector-length
  (lambda (v)  ;; v vettore
    (let ((x (car v)) (y (cdr v)))
      (sqrt (+ (* x x) (* y y)))
    )))

(define add-vectors
  (lambda (u v)  ;; u, v vettori
    (cons (+ (car u) (car v)) (+ (cdr u) (cdr v)))
    ))

(define rotate
  (lambda (v theta)  ;; v vettore, theta reale
    (let ((x (car v)) (y (cdr v)) (phi (/ (* theta pi) 180)))
      (let ((alpha (cos phi)) (beta (sin phi)))
        (cons (- (* alpha x) (* beta y))
              (+ (* beta x) (* alpha y))
              )
    ))))

(define rescale
  (lambda (v s)  ;; v vettore, s reale
    (cons (* s (car v)) (* s (cdr v)))
    ))


;; Esercizio: realizzazione basata su coppie di coordinate polari.


;; Terza realizzazione: i vettori sono rappresentati da numeri complessi


(define pi 3.141592654)  ;; pi greco

(define unit-vector
  (lambda ()  ;; funzione di 0 argomenti
    1
  ))

(define vector-length
  (lambda (v)  ;; v vettore
    (magnitude v)
    ))

(define add-vectors
  (lambda (u v)  ;; u, v vettori
    (+ u v)
    ))

(define rotate
  (lambda (v theta)  ;; v vettore, theta reale
    (let ((phi (/ (* theta pi) 180)))
      (* v (exp (* 0+1i phi)))
      )))

(define rescale
  (lambda (v s)  ;; v vettore, s reale
    (* s v)
    ))