(* definition de types enumeres *)

type couleur = Rouge | Noir ;;
type enseigne = Pique | Coeur | Carreau | Trefle ;;


(* cette fonction prend en parametre une enseigne et renvoie sa couleur *)
(* couleurEnseigne : enseigne -> couleur *)

let couleurEnseigne (e : enseigne) : couleur =
  if e=Pique || e=Trefle then
    Noir
  else
    Rouge
;;

  (couleurEnseigne Pique) ;;

(* meme fonction en utilisant du filtrage *)
(* Ici on oublie volontairement la valleur Carreau *)

let couleurEnseigne (e : enseigne) : couleur =
  match e with
    Pique -> Noir
  | Trefle -> Noir
  | _ -> Rouge
              ;;

let valeurrEnseigne (e : enseigne) : int =
  match e with
    Pique -> 4
  | Trefle -> 3
  | _ -> 2
              ;;

couleurEnseigne Pique ;;

(* attention aux arrondis sur les valeurs de type float ! *)

 match 4.3 -. 1.2 with
     3.1 -> true
    |_ -> false
  ;;

4.3 -. 1.2 ;;

(* definition du type "complexe" comme un produit de float 
   et d'une fonction d'addition entre complexes *)

type complexe = float * float ;;

let addComplexe (c1 : complexe) (c2 : complexe) : complexe =
  let (r1, im1)=c1 and (r2, im2)=c2 in 
                     (r1 +. r2, im1 +. im2)
;;

  (addComplexe (3., 4.5) (1.2, 3.1)) ;;

(*Type sommme*)

type pt = float * float;;

type figure = 
        | Rectangle of pt*pt
        | Cercle of pt*float
        | Triangle of pt*pt*pt;;

let distance (p1:pt) (p2:pt) : float = let (x1,y1)=p1 and (x2,y2)=p2 in 
sqrt(((x1-.x2)*.(x1-.x2))+.((y1-.y2)*.(y1-.y2)));;


let perimetre (f : figure) : float =
match f with
| Rectangle (p1, p2) -> let (x1,y1)=p1 and (x2,y2)=p2 in
         2.0*.(sqrt ((x1-.x2)*.(x1-.x2))+.sqrt((y1-.y2)*.(y1-.y2)))
| Cercle (_, r) -> 3.14*.2.0*.r
| Triangle (p1, p2, p3) -> (distance p1 p2) +. (distance p2 p3) +. (distance p3 p1) 
                ;;
                           

let valeur_carte (c1:carte) : int = 
    match c1 with 
          |Habille (h,c) -> (match h with 
                                  Roi -> 13
                                  |Dame ->12
                                  |Valet -> 11)
          |Petite(p,c) -> if (p=1) then 14 else p;;