;insert: (X + X -> boolean) + X + lista di X ->
;lista di X
(define (insert le n l)
  (cond
    [(empty? l) (list n)]
    [else
     (local ((define primo (first l)))
       (cond
         [(le n primo) (cons n l)]
         [else (cons primo (insert le n (rest l)))]))]))
;sort: (X + X -> boolean) + lista di X -> lista di X
(define (sort le l)
  (cond
    [(empty? l) empty]
    [else (insert le (first l) (sort le (rest l)))]))


;per rappresentare una sequenza uso una funzione avente come
;prototipo (naturale -> numero)
;dato in input un naturale i, restituisce l'i-esimo numero
;della sequenza (N.B. il primo numero della sequenza ha
;indice 0)

(define even-seq (lambda (x) (* 2 x)))
(define odd-seq (lambda (x) (+ (* 2 x) 1)))

;sum: (naturale -> numero) + naturale -> numero
;data una sequenza somma i primi n numeri della sequenza, dove
;n e' fornito in input
(define (sum seq n)
  (cond
    [(= n 0) (seq 0)]
    [else (+ (seq n) (sum seq (- n 1)))]))

;mk-exp-taylor: numero -> (naturale -> numero)
(define (mk-exp-taylor x);x e' il numero del quale vogliamo e^x
  (local ((define (power x i)
            (cond
              [(= i 0) 1]
              [else (* x (power x (- i 1)))]))
          (define (fact x)
            (cond
              [(= x 0) 1]
              [else (* x (fact (- x 1)))])))
    (lambda (i) ;i e' l'indice della sequenza di tyalor di e^x
      (cond
        [(= i 0) 1]
        [else (/ (power x i) (fact i))]))))

(define (myexp x)
  (sum (mk-exp-taylor x) 100))

;integrate: (numero -> numero) + numero + numero -> numero
;calcola l'integrale definito di f sull'intervallo fornito in
;input, utilizzando il metodo di keplero (dei trapezi)
(define (integrate f a b)
  (local ((define x0 a)
          (define x1 (/ (+ a b) 2))
          (define x2 b)
          (define y0 (f x0))
          (define y1 (f x1))
          (define y2 (f x2))
          (define area1 (/ (* (+ y0 y1) (- x1 x0)) 2))
          (define area2 (/ (* (+ y1 y2) (- x2 x1)) 2)))
    (+ area1 area2)))

;esercizio: utilizzando la funzione integrate, definire una
;funzione integrate2: (numero -> numero) + numero + numero + 
;numero -> numero
;il primo argomento e' la funzione da integrare, il secondo ed
;il terzo rappresentano l'intervallo sul quale integrare, il
;terzo parametro indica il numero di sottointervalli nel quale
;l'intervallo deve essere diviso

;derivate: (numero -> numero) -> (numero -> numero)
;la funzione restituita e' la derivata della funzione passata
;in input
(define (derivate f)
  (local ((define epsilon 0.001))
    (lambda (x)
      (/ (- (f (+ x epsilon)) (f (- x epsilon)))
         (* 2 epsilon)))))

;bisect: (numero -> numero) + numero + numero + numero ->
;numero
;dati in input una funzione (continua, monotona e crescente),
;due punti a b t.c. (f a) < 0 e (f b) > 0 ed una tolleranza
;delta, restituisce un numero x t.c. (abs (f x)) <= delta
(define (bisect f a b delta)
  (local ((define x0 a)
          (define x1 (/ (+ a b) 2))
          (define x2 b)
          (define y0 (f x0))
          (define y1 (f x1))
          (define y2 (f x2)))
    (cond
      [(<= (abs y1) delta) x1]
      [(> y1 0) (bisect f x0 x1 delta)]
      [else (bisect f x1 x2 delta)])))

;esercizio: ridefinire bisect in modo che sia corretto anche
;per funzioni monotone decrescenti