(* I. Structures de contrôle *)

let abs(x) = 
  if x > 0 then x else -x
;;

let diviseurs(n) = 
  let num = ref(0) in
  for i = 1 to n do
    if n mod i = 0 then incr num
  done ;
  !num
;;

let premier(n) =
  let d = ref(2) in
  while n mod !d <> 0 && !d * !d <= n do
    incr d
  done;
  n mod !d <> 0
;;

(* II. Tableaux *)

let poly(n,t) = 
  init_vect t (fun i -> i*i + n*i)
;;

let somme_polynomes(a,b) =

  let longueur_a = vect_length(a) in
  let longueur_b = vect_length(b) in

  let c = make_vect (max longueur_a longueur_b) 0 in
  
  for i = 0 to longueur_a - 1 do 
    c.(i) <- a.(i)
  done;

  for i = 0 to longueur_b - 1 do
    c.(i) <- c.(i) + b.(i)
  done;

  c
;;

let maximum(t) =
  let m = ref(min_int) in
  for i = 0 to vect_length(t) - 1 do
    m := max !m t.(i)
  done;
  !m
;;

let iter(x,f)(t) =
  let a = ref(x) in
  for i = 0 to vect_length(t) - 1 do
    a := f !a t.(i)
  done;
  !a
;;

let maximum = iter(min_int,max);;
let minimum = iter(max_int,min);;
let somme   = iter(0, prefix +);;
let produit = iter(1, prefix *);;

(* III. Listes *)

let rec list_length = function
  | []   -> 0
  | _::q -> 1 + list_length q
;;

let rec diviseurs(n,d) = 
  if n < d then 
    [] 
  else if d > 0 && n mod d = 0 then 
    d :: diviseurs(n,d+1)
  else
    diviseurs (n,d+1)
;;

let rec iter(f)(i) = function
  | [] -> i
  | t :: q -> iter f (f i t) q
;;

let list_length l = iter (fun i _ -> i + 1) 0 l;;
let maximum = iter max min_int;;
let minimum = iter min max_int;;
let exists p = iter (fun i t -> i || p t);;
let for_all p = iter (fun i t -> i && p t);;

let rec map(f) = function
  | [] -> []
  | t :: q -> f t :: map f q
;;

let rec filter(p) = function
  | [] -> []
  | t :: q -> 
      if p t then t :: filter p q 
      else filter p q
;;

let map f lst = 
  iter (fun q t -> t::q) [] (iter (fun q t -> f t::q) [] lst)
;;

let filter p lst = 
  iter (fun q t -> t::q) [] 
    (iter (fun q t -> if p t then t::q else q) [] lst)
;;