(* ######################################################################## *)
(* #                                                                      # *)
(* #          Premiers programmes - Decoupage fonctionnel                 # *)
(* #                                                                      # *)
(* ######################################################################## *)
(* exercice 1 *)
(* ---------- *)
(*1) *)
let a = 2 * 3 + 1;;
(* a : int = 7 *)
let a2 = a * a;;
(* a2 : int = 14 *)
a2 = 10;;
(* - : bool = false*)

(* 2) *)
let a = 5;;
(* a : int = 5 *)
let a = 12 in 2 * a + 1;;
(* - : int = 25 *)
let a2 = 2*a;;
(* a2 : int = 10 *)
let a = 10;;
(* a : int = 10 *)
a2 = a ;;
(* - bool = true *)

(* exercice 2 *)
(* ---------- *)

(* Donner le resultat des expressions Caml qui suivent :                    *)

(function x -> function y -> 3 * (x + y)) 2 5 ;;
(function x -> 3 * (x + (function y -> y) 2)) 5;;
3 * (function x -> x * x) 3 ;;
(function x -> function y -> 2 + (x * y)) (7+11) (5+2) ;;
(function x -> function y -> function z -> x * y + x * z) 2 3 4 ;;
(function x -> function y -> function z -> function u -> z) 1023 917 79 402 ;;

(* - : int = 21                                                            *)
(* - : int = 21                                                            *)
(* - : int = 27                                                            *)
(* - : int = 128                                                           *)
(* - : int = 14                                                            *)


(* exercice 3 *)
(* ---------- *)

(* Evaluer les expressions suivantes.                                       *)
(* Preciser un type possible pour chacune des fonctions                     *)

(function x -> function y -> x+1) (2*5) (1.13*.2.78);;
(function x -> not(not x)) false ;;
(function x -> function y -> (not((x*x)=y)or(x<2))) 2 4 ;;
(function x -> function y -> (not((x*x)=y)&(x<=2))) 2 4 ;;

(* - : int = 11                                                            *)
(* - : bool = false                                                        *)
(* - : bool = false                                                        *)
(* - : bool = false                                                        *)

(* a) entier X indifferent --> entier      : 11                             *)
(* b)              booleen --> booleen     : false                          *)
(* c) entier X entier      --> booleen     : false                          *)
(* d) entier X entier      --> booleen     : false                          *)


(* exercice 4 *)
(* ---------- *)

(* definir une fonction renverser                                           *)
(* [10,99]  --> [1,99]-{10,20,30,40,50,60,70,80,90}                         *)
(*       n |--> nombre constitue des chiffres de n dans l'ordre inverse     *)
(* exemple : renverser 13 = 31                                              *)
(* idee : renverser(n) = unite(n) * 10 + dizaine(n)                         *)
(* precision : cet algo supprime les "0" inutiles : renverser(20) = 2       *)
(* unite :   [10,99]  --> [0,9]                                             *)
(*                 n |--> chiffre des unites de n                           *)
(* dizaine : [10,99]  --> [1,9]                                             *)
(*                 n |--> chiffre des dizaines de n                         *)
(* unite(n) = n modulo 10                                                   *)
(* unite(n) = n / 10                                                        *)

let dizaine n = n/10 ;;
let unite n = n mod 10 ;;
let renverser n = 10 * unite n + dizaine n ;;

(* ou bien *)

let renverser n = let dizaine n = n/10
                in let unite n = n mod 10 
                in 10 * unite n + dizaine n ;;

(* exercice 5 *)
(* ---------- *)

(* Ecrire une fonction somme chiffre qui calcule la somme de tous les
*)
(* chiffres d\ufffdun nombre entre 0 et 999. A l\ufffdaide de cette fonction \ufffdcrire
*)
(* une fonction div3 qui permet de d\ufffdterminer si un nombre est divisible
*)
(* par 3 (La somme des chiffre d\ufffdun nombre divisible par trois est
*)
(* divisible par trois). Proposer une fonction div3 plus simple v\ufffdrifiant
*)
(* si un nombre est divisible par 3 fonctionnant quelle que soit la valeur
*)
(* de n.
*)

let somme n = n / 100 + (n mod 100) / 10 + n mod 10 ;;

let div3 n = (somme (somme n) = 3) or (somme (somme n) = 6) or (somme (somme n) = 9);;
(* puisque n entre 0 et 999 :
*)
(* au maximum somme n = 27 donc au maximum  somme (somme n) = 9
*)

let div3 n = (n mod 3 = 0);;


(* exercice 6 *)
(* ---------- *)

(* Ecrire une fonction qui teste si deux intervalles                        *)
(* [x1,x2] et [x3,x4] sont disjoints                                        *)
(* reel x reel x reel x reel  --> booleen                                   *)
(*             (x1,x2,x3,x4) |--> [x1,x2] et [x3,x4] sont disjoints         *)
(* si on veut s'assurer que [x1,x2] et [x3,x4] sont bien des intervalles,   *)
(* on peut definir une fonction                                             *)
(* intervalle? : reel x reel  --> booleen                                   *)
(*                     (x,y) |--> [x,y] est  non reduit a 1 point           *)
(*                                                                          *)

let intervalle x y = x < y ;;

(* ou bien *)
let (intervalle : int -> int -> bool) = function x -> function y -> x < y ;;
let intervalle_disjoints x1 x2 x3 x4 =
    intervalle  x1 x2 & intervalle  x3 x4 & ((x2 < x3) or (x4 < x1));;


(* exercice 7 *)
(* ---------- *)


(* Concevoir les diff\ufffdrentes op\ufffdrations de bases de l'arithm\ufffdtique *)
(* s'appliquant sur les entiers  *)
(* naturels ; addition, soustraction, multiplication. D\ufffdfinir les  *)
(* pr\ufffdconditions n\ufffdcessaires (rappel :  *)
(* les nombres naturels sont forcement positifs). Ces pr\ufffdconditions seront *)
(*  aussi impl\ufffdment\ufffdes  *)
(* en utilisant la notation \textit{op\ufffdration\_pre} et prenant les m\ufffdmes  *)
(* param\ufffdtres que  *)
(* l'op\ufffdration. Avant de pouvoir faire un appel \ufffd \textit{op\ufffdration}, *)
(* l'utilisateur devra  *)
(* v\ufffdrifier que \textit{op\ufffdration\_pre} soit v\ufffdrifi\ufffd. *)



let addition x y = x + y ;;
let soustraction x y = x - y ;;
let multiplication x y = x * y ;;

let addition_pre x y = x >= 0 & y >= 0 ;;
let soustraction_pre x y = x >=0 & x >= y ;;
let multiplication_pre x y = x >= 0 & y >= 0 ;;

(* Quelle est la proc\ufffddure \ufffd suivre pour calculer $5 + 8 * 7 - 6$ *)
(* avec ces op\ufffdrations ? de m\ufffdme pour $6 - ( 2 + 3)$  et $2 - 5 * 8$. *)

multiplication_pre 8 7 ;;
soustraction_pre (multiplication 8 7) 6) ;;
addition_pre 5 (soustraction (multiplication 8 7) 6) ;;
addition 5 (soustraction (multiplication 8 7) 6) ;;

addition_pre 2 3 ;;
soustraction_pre 6 (addition 2 3) ;;
soustraction 6 (addition 2 3) ;;

multiplication_pre 5 8 ;;
soustraction_pre 2 (multiplication 5 8) ;;


(* exercice 8 *)
(* ---------- *)

(* Concevoir et coder en Caml des fonctions qui calculent les aires de :    *)
(* carre, rectangle, cercle, triangle et cylindre                           *)

let aire_carre a = a *. a ;;
let aire_rectangle l1 l2= l1 *. l2 ;;
let pi = 3.14159 ;;
let aire_cercle r = pi *. r *. r ;;
let aire_triangle b h = b *. h /. 2. ;;
let aire_cylindre r h = 2. *. pi *. r *. h ;;


(* Concevoir et coder en Caml une fonction qui calcule l'aire d'un hexagone *)
(* regulier sachant que l'aire d'un triangle equilateral est :              *)
(* a*a*racine(3)/4                                                          *)

let aire_triangle_equi a = let racine_de_3 = 1.732 in a*.a*.racine_de_3/.4. ;;
let aire_hexa a = 6. *. aire_triangle_equi a ;;


(* Concevoir et coder en Caml des fonctions qui calculent les volumes de :  *)
(* cube, parallelepipede, sphere et prisme hexagonal                        *)

let volume_cube a = a *. a *. a ;;
let volume_parallelepipede l p h = l *. p *. h ;;
let volume_sphere r = 4. /. 3. *. pi *. r *. r *. r ;;
let volume_prisme_hexa h a = h *. aire_hexa a ;;


(* Concevoir et coder en Caml une fonction qui                             *)
(*  calcule le volume d'un ecrou a 8 pans                                  *)
(* de cotes x, de hauteur h et evide d'un cylindre de rayon r              *)

(* Decoupage fonctionnel                                                    *)
(*                                                 ______                   *)
(*                vol_ecrou                       /      \                  *)
(*                    |                          /        \                 *)
(*                    |                         /          \                *)
(*                    |                        |     __     |               *)
(*            h * surf_ecrou                   |    |  |    |               *)
(*                 |      |                    |     --     |               *)
(*                 |      |                     \          /                *)
(*                 |      |                      \        /                 *)
(*      surf_octogone  - surf_cercle              \      /                  *)
(*            |                                    ------                   *)
(*            |                                                             *)
(*            |                                                             *)
(*  8 * surf_triangle                                                       *)

let vol_ecrou x h r =
  let surf_triangles = 8. *. aire_triangle x (x/.(2. *. tan(pi/.8.)))
  in h *. (surf_triangles -. aire_cercle r);;