(*  Exercice 2 *)


let abs_int x =
	if x >=0 then x else -x ;;

abs_int (-5);;


let abs_float x =
	if x >=0. then x else -.x ;;

let signe_int x =
	if x > 0 then 1 else
		if x = 0 then 0 else (-1);;
	
	
let signe_float x =
	if x > 0. then 1 else
		if x = 0. then 0 else (-1);;
		
signe_int (-5);;



(*  Exercice 3  *)
let collatz n =
	if n mod 2 = 0 then n/2 else 3*n+1;;


let syracuse n = 
	let u = ref n in
	let indice = ref 0 in
	while !u != 1 do
			u := collatz (!u) ;
			incr indice ;	
	done ;
	!indice ;;



syracuse 155;;

let le_max_collatz n=
		let m = ref 0 in
		let valeur_max = ref 1 in
		for i = 1 to n do
			if syracuse(i) > !m then
				begin
					m := syracuse(i) ;
					valeur_max := i ;
				end
		done ;
		(!valeur_max, !m);;

le_max_collatz 1000;;				
syracuse 871;;	

(*  Exercice  4 *)

let minimum a b c =
	if a < b then
		if a < c then a
		else c
	else
		if b < c then b
			else c;;



(* Exercice 5 *)
let nb_chiffre n =
	let compteur = ref 0 in
	let n_2 = ref n in
	while !n_2 != 0 do
			n_2 := !n_2 / 10 ;
			incr compteur ;			
	done ;
	!compteur ;;

nb_chiffre 1564;;	
	
	
let nb_de_zero n =
	let compteur = ref 0 in
	let n_2 = ref n in
	while !n_2 != 0 do
			if !n_2 mod 10 = 0 then
				incr compteur ;			
			n_2 := !n_2 / 10 ;
	done ;
	!compteur ;;	
	
nb_de_zero 10502101;;	


let symetrie n =
	let resultat= ref 0 in
	let n_2 = ref n in
	while !n_2 != 0 do
			resultat := !resultat * 10 +  !n_2 mod 10 ;
			n_2 := !n_2 / 10 ;
	done ;
	!resultat ;;

symetrie 123456001;;



(*  Exercice 6 *)

type complexe = { part_reelle : float ; part_imaginaire : float } ;;


let zero = { part_reelle = 0. ; part_imaginaire = 0. };;

let un = { part_reelle = 1. ; part_imaginaire = 0. };;

let i = { part_reelle = 0. ; part_imaginaire = 1. };;

let z_1 = { part_reelle = 3. ; part_imaginaire = 2. };;


let z_2 = { part_reelle = 5. ; part_imaginaire = -.1. };;	


let somme z_1 z_2 =
	let z_3 = { part_reelle = z_1.part_reelle +. z_2.part_reelle  ; 
	part_imaginaire = z_1.part_imaginaire +. z_2.part_imaginaire } in
	z_3 ;;


somme z_1 z_2;;

let produit z_1 z_2 =
	 { part_reelle = z_1.part_reelle *. z_2.part_reelle 
	 				-. z_1.part_imaginaire *. z_2.part_imaginaire ; 
	part_imaginaire = z_1.part_reelle *. z_2.part_imaginaire 
					+. z_2.part_reelle  *. z_1.part_imaginaire } ;;

produit z_2 z_1;;

let conjugue z =
	{ part_reelle = z.part_reelle ; part_imaginaire = -. z.part_imaginaire };;


let inverse z =
	{ part_reelle = z.part_reelle /. 
	( z.part_reelle *. z.part_reelle +. z.part_imaginaire *. z.part_imaginaire)
	; part_imaginaire = -. z.part_imaginaire /. 
	( z.part_reelle *. z.part_reelle +. z.part_imaginaire *. z.part_imaginaire )
 };;


let quotient z_1 z_2 =
	let inv_2 = inverse z_2 in
	produit z_1 inv_2;;

quotient z_1 z_2;;

inverse z_1;;


let norme z =
	let prod = produit z (conjugue z) in
	sqrt ( prod.part_reelle);;

norme z_1;;