(* Exercice 1 *)
(* 1. 2. 3. 4. 5. 6. *)
(* À tester vous-même *)

(* Exercice 2 *)
(*  7. *) fun x y -> float_of_int x +. y
(*  8. *) fun x y -> x + int_of_float y, true
(*  9. *) fun f g x -> if f x then x else g x
(* 10. *) fun f x -> succ (f x)

(* Exercice 3 *)
(* 11 *)
(* mystery 3 => [0; 1; 2] *)
(* 12 *)
(* O(2^n) *)
(* cf fibonacci *)

(* 13 *)
let mystery_lin n =
  let rec aux n =
    if n = 0 then 2, 3 else
      let u, v = aux (n - 1) in
      v, u + v + 2
  in fst (aux n)

(* Exercice 4 *)
let seq_constant c  = fun (i : int) -> c

(* 14 *)
let seq_i = fun (i : int) -> i

(* 15 *)
let seq_even = fun (i : int) -> 2 * i

(* 16 *)
let seq_sum (seq1 : int -> int) (seq2 : int -> int) = fun i -> seq1 i + seq2 i

(* 17 *)
let seq_odd = seq_sum seq_even (seq_constant 1)

(* 18 *)
let seq_to_list seq n p =
  let rec aux p l =
    if n > p then l
    else aux (pred p) (seq p :: l)
  in aux p []

(* 19 *)
let trapeze_area a b fa fb =
  (b -. a) *. (fa +. fb) /. 2.

(* 20 *)
let area_trapeze_method f a b n = 
  let step = (b -. a) /. (float_of_int n) in
  let rec aux a area =
    if a >= b then area
    else let a' = min (a +. step) b in
         aux a' (area +. trapeze_area a a' (f a) (f a'))
  in aux a 0.

(* 21 *)
let integrale f n =
  fun a b ->  area_trapeze_method f a b n

(* 22 *)
let primitive f a n = fun x -> integrale f n a x