content: -- Ce fichier est le TP numéro 2 du cours de Programmation Fonctionnelle et Logique
  
  -- Exercice 1
  cube :: Int -> Int
  cube x = x * x * x
  
  -- Exercice 2
  pair :: Int -> Bool
  pair x
    | x `mod` 2 == 0 = True
    | otherwise = False
  
  -- Exercice 3
  volpar :: (Float, Float, Float) -> Float
  volpar (x,y,z) = x * y * z
  
  volpar2 :: Float->Float->Float->Float
  volpar2 x y z = x * y * z
  
  -- Exercice 4
  nombreDeSolutions :: (Float, Float, Float) -> Int
  nombreDeSolutions (a, b, c)
    | f > 0 = 2
    | f == 0 = 1
    | f < 0 = 0
    where f  = b ^ 2 - 4 * a * c
  
  -- Exercice 5
  aireTriangle :: Float->Float->Float->Float
  aireTriangle x y z = sqrt (p * (p-x) * (p-y) * (p-z))
    where p = (x + y + z)/2
  
  -- Exercice 6
  -- Fonction qui détermine si un nombre peut être exprimé comme la somme de cube de autres nombres positifs
  sommeDeCube :: Int -> [(Int, Int)]
  sommeDeCube x = [(a, b) | a <- [1..x], b <- [1..x], (a^3 + b^3) == x]
  
  -- Exercice 7
  -- Déterminer si un triangle est équilatéral ou isocèle ou sclène à partir de ses trois dimensions
  typeTriangle :: Int -> Int -> Int -> String
  typeTriangle x y z
    | x == y && y == z = "Equilatéral"
    | x == y || x == z || y == z = "Isocèle"
    | otherwise = "Scalène"
  
  -- Exercice 8
  -- pair (cube (cube 3))
  -- pair x = x `mod`2 == 0
  -- (cube (cube 3)) `mod` 2 == 0
  -- ((cube 3) * (cube 3) * (cube 3))  `mod` 2 == 0
  -- Extérieure => (3 * 3 * 3) * (3 * 3 * 3) * (3 * 3 * 3) `mod` 2 == 0
  -- Extérieure Paresseuse => (3 * 3 * 3) * (cube 3) * (cube 3) `mod` 2 == 0
  -- (27) * (cube 3) * (cube 3)
  -- (27) * (27) * (27) `mod ` 2 == 0
  -- 19683 `mod` 2 == 0
  -- 1 == 0
  -- False
  
  -- Exercice 10
  volpar3 :: Float -> (Float -> (Float->Float))
  volpar3 x = (\y -> (\z-> x * y * z))
  
  -- Exercice 12
  curry2 :: ((a,b) -> c) -> (a->(b->c))
  curry2 f = (\x -> (\y -> f (x,y)))
  
  -- Exercice 16
  compo :: (b->c)->(a->b)->a->c
  compo g f = \x -> g (f x)
  
  -- Exercice 17 
  appl3 :: (a->a)->a->a
  appl3 f = f . f . f
  
  
  
  -- Préparation TPs
  applyJusque :: (Int->Int->Int)->Int->Int
  applyJusque op borne
   | borne == 0 = op 0 0
   | otherwise = (op borne (applyJusque op (borne-1)))
  
  applyJusque2 :: (Int->Int->Int)->Int->Int
  applyJusque2 op 0 = op 0 0
  applyJusque2 op borne = op borne (applyJusque2 op (borne-1))