Programmation fonctionnelle

12/04/2017
1
Programmation fonctionnelle
Cours 12 : Correction du CC2
Révisions
Licence 1
Année 2016 –2017
Par N. VINCENT
# let rec present l nom = match l with [] ->
| (no , va) :: t -> if no = nom then
else present tnom ;;
Licence 1 -programmation fonctionnelle 2
Exercice 1-1
Ecrire une fonction booléenne present qui aura deux arguments, une
liste de mesures nommée let une chaîne de caractères nommée nom
représentant le nom d’un expérimentateur. Cette fonction indique si
l’expérimentateur a effectué une mesure contenue dans la liste l.
[("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)]
# let rec present l nom = match l with [] -> false
| (no , va) :: t -> if no = nom then true
else present tnom ;;
val present : ('a* 'b) list -> 'a-> bool = <fun>
# present [("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)] "lea" ;;
-: bool = true
# present [("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)] "martin" ;;
-: bool = false
# let rec fcompte l nom = match l with [] -> 0
|(no , va) :: t -> if no = nom then 1 + fcompte tnom
else fcompte tnom ;;
val fcompte : ('a* 'b) list -> 'a-> int = <fun>
# fcompte li "lea" ;;
-: int = 3
Licence 1 -programmation fonctionnelle 3
Exercice 1-2
Ecrire une fonction fcompte qui aura deux arguments, une liste de
mesures nommée let une chaîne de caractères nommée nom
représentant le nom d’un expérimentateur. Cette fonction calcule le
nombre de mesures effectuées par l’expérimentateur dont le nom est
le second argument.
[("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)]
# let fcompte l nom = let rec faux acc ll name =
match ll with [] -> acc
|(no , va) :: t -> if no = name then faux (1 + acc) tname
else faux acc tname
in faux 0 l nom ;;
val fcompte : ('a * 'b) list -> 'a -> int = <fun>
# fcompte li "lea" ;;
-: int = 3
# let fcompte2 l nom1 nom2 = (fcompte l nom1 , fcompte l nom2)
Licence 1 -programmation fonctionnelle 4
Exercice 1-3
Ecrire une fonction fcompte2 qui à partir d’une liste de mesures fournie
en argument et de deux autres arguments, des chaînes de caractère,
calcule un couple contenant respectivement le nombre de mesures de
chaque expérimentateur.
[("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)]
# fcompte2 li "luc" "lea" ;;
-: int * int = (1, 3)
# let fcompte2 l nom1 nom2 = let rec faux acc1 acc2 ll name1 name2 =
match ll with [] -> acc1 , acc2
|(name1 , va) :: t -> faux (1 + acc1) acc2 tname1 name2
| (name2 , va) :: t -> faux acc1 (1 + acc2) tname1 name2
| h :: t -> faux acc1 acc2 tname1 name2
in faux 0 0 l nom1 nom2 ;;
Warning 11: this match case is unused.
Warning 11: this match case is unused.
val fcompte2 : ('a * 'b) list -> 'a -> 'a -> int * int =
<fun>
# fcompte2 li "luc" "lea" ;;
-: int * int = (7, 0)
Licence 1 -programmation fonctionnelle 5
Exercice 1-3
Ecrire une fonction fcompte2 qui à partir d’une liste de mesures fournie
en argument et de deux autres arguments, des chaînes de caractère,
calcule un couple contenant respectivement le nombre de mesures de
chaque expérimentateur.
[("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)]
# let fcompte2 l nom1 nom2 = let rec faux acc1 acc2 ll name1 name2 =
match ll with [] -> acc1 , acc2
|(no , va) :: t -> if no = name1 then faux (1 + acc1) acc2 tname1 name2
else if no = name2 then faux acc1 (1 + acc2) tname1 name2
else faux acc1 acc2 tname1 name2
in faux 0 0 l nom1 nom2 ;;
val fcompte2 : ('a * 'b) list -> 'a -> 'a -> int * int = <fun>
# fcompte2 li "luc" "lea" ;;
-: int * int = (1, 3)
# let rec mesure l nom = match l with [] -> []
| (nom , va) :: t -> va :: mesure tnom
| _:: t -> mesure tnom ;;
Licence 1 -programmation fonctionnelle 6
Exercice 1-4
Ecrire une fonction mesure qui aura pour arguments une liste de
mesures nommée let une chaîne de caractères nommée nom qui
représente le nom d’un expérimentateur. Cette fonction doit créer la
liste des mesures réalisées par l’expérimentateur nom .
[("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)]
# let mesure l nom = let rec faux acc ll name =
match ll with [] -> acc
|(no , va) :: t -> if no = nom then faux (acc@ [va]) tname
else faux acc tname
in faux [] l nom ;;
# mesure li "lea" ;;
-: int list = [10; 12; 14; 8; 22; 13; 18]
# let rec mesure l nom = match l with [] -> []
| (no , va) :: t -> if no = nom then va :: mesure tnom
else mesure tnom ;; # mesure li "lea" ;;
-: int list = [12; 8; 18]

12/04/2017
2
# let fmoy l nom = let rec som acc ll = match ll with [] -> acc
| h:: t -> som (acc+h) t
in float_of_int (som 0 (mesure l nom)) /. float_of_int (fcompte l nom) ;;
Licence 1 -programmation fonctionnelle 7
Exercice 1-5
Ecrire une fonction fmoy qui à partir d’une liste de mesures lcalcule la
moyenne des mesures réalisées par un expérimentateur dont le nom
est indiqué en argument nom.
[("luc",10);("lea",12);("agathe",14);("lea",8);("louis",22);("louis",13);
("lea",18)]
# let fmoy l nom = let rec faux acc l name =
match l with [] -> float_of_int (acc) /. float_of_int (List.length
(mesure l nom))
|(no , va) :: t -> if no = name then faux (acc +va) tname
else faux acc tname
in faux 0 l nom ;;
# let fmoy l nom = let rec faux acc ll name =
match ll with [] -> float_of_int (acc) /. float_of_int (List.length
(mesure l nom))
|(no , va) :: t -> if no = name then faux (acc +va) tname
else faux acc tname
in faux 0 l nom ;;
# let fmax l nom1 nom2 = match (present l nom1) && (present l nom2)
with false -> failwith "un des expérimentateurs sans mesure"
| _ -> let rec maxi acc ll = match ll with [] -> acc
| h:: t -> maxi (max acc h) t
in (maxi (List.hd(mesure l nom1)) (mesure l nom1) , maxi (List.hd(mesure l
nom2)) (mesure l nom2)) ;;
Licence 1 -programmation fonctionnelle 8
Exercice 1-6
Ecrire une fonction fmax qui à partir d’une liste de mesures let de deux
arguments nom1 et nom2, calcule un couple d’entiers contenant
respectivement les valeurs maximum mesurées par chacun des
expérimentateurs. On vérifiera que la liste comporte au moins une
mesure réalisée par chacun des expérimentateurs, sinon une exception
indiquera ce cas.
val fmax : ('a* 'b) list -> 'a-> 'a-> 'b* 'b= <fun>
# fmax li "louis" "lea" ;;
-: int * int = (22, 18)
# let resum l = let rec faux acc ll = match ll with [] -> acc
| (no,va):: t -> if present acc no then faux acc t
else faux (acc @ [(no, (fcompte l no))]) t
in faux [] l ;;
Licence 1 -programmation fonctionnelle 9
Exercice 1-7
Ecrire une fonction resum qui à partir d’une liste de mesures nommées l
construit une liste dont les éléments sont des couples dont le premier
élément est le nom d’un expérimentateur et le second est le nombre
de mesures faites par cet expérimentateur et présentes dans la liste l.
# resum li ;;
-: (string * int) list =
[("luc", 1); ("lea", 3); ("agathe", 1); ("louis", 2)]
Licence 1 -programmation fonctionnelle 10
Exercice 2
Ecrire une fonction fqui calcule la somme des éléments de rang impair dans
une liste d’entiers, la liste est donnée dans l’argument appelé l.
# let rec f l = match l with [] -> 0
| [h] -> h
| h1::h2:: t -> h1 + f t;;
val f : int list -> int = <fun>
# f[3 ; 7; -1 ; 8; 5; 7] ;;
-: int = 7
# f[3 ; 7; -1 ; 8; 5] ;;
-: int = 7
Licence 1 -programmation fonctionnelle 11
Exercice 3
On considère la fonction suivante :
let rec f l = match l with
| [] -> []
| h::t -> if h mod 2 = 0 then (f t) @ [h] else h::(f t) ;;
1°/ Ecrire l’interprétation de cette fonction f.
val f : int list -> int list = <fun>
2°/ Quel est le résultat de l’application de f sur l’argument :
[1 ; 10 ; 4 ; 1 ; 5 ; 3] ?
1:: f [10 ; 4 ; 1 ; 5 ; 3]
[1 ; 1; 5 ; 3 ; 4 ; 10]
1 :: (f [ 4 ; 1 ; 5 ; 3]) @ [10]
1:: (f [1 ; 5 ; 3]) @ [4] @ [10]
1::1:: (f [5 ; 3]) @ [4] @ [10]
1::1::5::3 (f [ ]) @ [4] @ [10]
1::1::5:: (f [3]) @ [4] @ [10]
Licence 1 -programmation fonctionnelle 12
Exercice 3
On considère la fonction suivante :
let rec f l = match l with
| [] -> []
| h::t -> if h mod 2 = 0 then (f t) @ [h] else h::(f t) ;;
Donner une version terminale de cette fonction f.
On pourra vérifier son résultat sur l’argument [1 ; 10 ; 4 ; 1 ; 5; 3].
let f1 liste = let rec faux ll acc = match ll with [] -> acc
| h::t -> if h mod 2 = 0 then (faux t (h::acc)) else (faux t (acc@[h]))
in faux liste [] ;;
# f1 [1 ; 10 ; 4 ; 1 ; 5; 3] ;;
-: int list = [4; 10; 1; 1; 5; 3]
let f2 liste = let rec faux ll acc1 acc2 = match ll with [] -> acc1 @ acc2
| h::t -> if h mod 2 = 0 then faux t acc1 (h::acc2) else faux t (acc1@[h]) acc2
in faux liste [] [] ;;
# f2 [1 ; 10 ; 4 ; 1 ; 5; 3] ;;
-: int list = [1; 1; 5; 3; 4; 10]

12/04/2017
3
Licence 1 -programmation fonctionnelle 13
Exercice 3
On considère la fonction suivante :
let rec f l = match l with
| [] -> []
| h::t -> if h mod 2 = 0 then (f t) @ [h] else h::(f t) ;;
Donner une version terminale de cette fonction f.
let f1 liste = let rec faux ll acc1 acc2 = match ll with [] -> acc1 @ acc2
| h::t -> if h mod 2 = 0 then faux t acc1 (h::acc2) else faux t (acc1@[h]) acc2
in faux liste [] [] ;;
# f1 [1 ; 10 ; 4 ; 1 ; 5; 3] ;;
-: int list = [1; 1; 5; 3; 4; 10]
let f3 liste = let rec mir ll acc = match ll with [] -> acc
| h::t -> mir t (h::acc)
in
let rec faux ll acc = match ll with [] -> acc
| h::t -> if h mod 2 = 0 then (faux t (acc@[h])) else (faux t (h::acc))
in faux (mir liste []) [] ;;
# f3 [1 ; 10 ; 4 ; 1 ; 5; 3] ;;
-: int list = [1; 1; 5; 3; 4; 10]
Licence 1 -programmation fonctionnelle 14
Géométrie
Les vecteurs peuvent être modélisés par
un enregistrement
# type vecteur = { x : float ; y : float } ;;
type vecteur = { x : float; y : float; }
Produit scalaire
# let prod u v = (u.x)*.(v.x) +. (u.y)*.(v.y) ;;
val prod : vecteur -> vecteur -> float = <fun>
# let u1 = {x = 1. ; y=2. } ;;
val u1 : vecteur = {x = 1.; y = 2.}
# let u2 = {x=(-2.) ; y = 1. } ;;
val u2 : vecteur = {x = -2.; y = 1.}
# prod u1 u2 ;;
-: float = 0.
Licence 1 -programmation fonctionnelle 15
Géométrie
Appartenance à une droite : ax+by+c=0
# type vecteur = { x : float ; y : float } ;;
type vecteur = { x : float; y : float; }
Droite définie par un élément de type
vecteur et une constante
# let adroit p c m = ((prod p m)+.c)=0. ;;
# let n = { x = 1. ; y = 2.} and c = 0. ;;
val n : vecteur = {x = 1.; y = 2.}
val c : float = 0.
# let droit1 m = adroit n c m ;;
# droit1 { x = 0. ; y = 0.} ;;
-: bool = true
# droit1 { x = -1. ; y = 0.} ;;
-: bool = false
# let adroit p c m = ((prod p m)+.c)=0. ;;
val adroit : vecteur -> float -> vecteur -> bool = <fun>
# let droit1 m = adroit n c m ;;
val plan1 : vecteur -> bool = <fun>
Licence 1 -programmation fonctionnelle 16
Nombres complexes
# let prod c1 c2 = {re = ((c1.re)*.(c2.re))-.((c1.im)*.(c2.im)) ;
im = ((c1.re)*.(c2.im))+.((c1.im)*.(c2.re)) } ;;
val prod : complexe -> complexe -> complexe = <fun>
# let add c1 c2 = {re = (c1.re +. c2.re) ; im = (c1.im +. c2.im) } ;;
val add : complexe -> complexe -> complexe = <fun>
# type complexe = {re : float ; im : float} ;;
type complexe = { re : float; im : float; }
addition
produit
Licence 1 -programmation fonctionnelle 17
conversion
# let vect2comp u = {re = u.x ; im = u.y } ;;
val vect2comp : vecteur -> complexe = <fun>
# type complexe = {re : float ; im : float} ;;
type complexe = { re : float; im : float; }
Complexe associé à un vecteur
# type vecteur = { x : float ; y : float } ;;
type vecteur = { x : float; y : float; }
Licence 1 -programmation fonctionnelle 18
Représentation d'un polynôme
anxn+ … + a0
# let affmono (a , n) = if n = 0 then print_int a
else begin print_string "+" ; print_int a ;
print_string "x^" ; print_int n end ;;
val affmono : int * int -> unit = <fun>
# affmono (3 , 5) ;;
+3x^5-: unit = ()
Ensemble de monômes
Liste de paires d'entiers
affichage
a , n
# let p1 = [(1 , 0) ; (3, 1) ; ((-2) , 5)] ;;
val p1 : (int * int) list = [(1, 0); (3, 1); (-2, 5)]

12/04/2017
4
Licence 1 -programmation fonctionnelle 19
Affichage d'un polynôme
# let affpoly p = List.map affmono p ;;
val affpoly : (int * int) list -> unit list = <fun>
# let p1 = [(1 , 0) ; (3, 1) ; ((-2) , 5)] ;;
val p1 : (int * int) list = [(1, 0); (3, 1); (-2, 5)]
# affpoly p1 ;;
1+3x^1+-2x^5-: unit list = [(); (); ()]
Licence 1 -programmation fonctionnelle 20
Calcul de la valeur en un point
# let rec puis x n = if n = 0 then 1 else x*puis x (n-1) ;;
val puis : int -> int -> int = <fun>
anxn+ … + a0
# let expo x n = let rec f acc x n = if n = 0 then acc
else f (x*acc) x (n-1)
in
f 1 x n ;;
val expo : int -> int -> int = <fun>
# expo 8 2 ;;
-: int = 64
Calcul des puissances
Version terminale
Licence 1 -programmation fonctionnelle 21
Calcul de la valeur en un point
# let rec valeur p m = let c1 x = match x with | (x1,x2) -> x1
in let c2 x = match x with | (x1,x2) -> x2
in match p with
| [] -> 0
| h::t -> (c1 h)* (expo m (c2 h)) + valeur t m ;;
val valeur : (int * int) list -> int -> int = <fun>
# p1 ;;
-: (int * int) list = [(1, 0); (3, 1); (-2, 5)]
# valeur p1 1 ;;
-: int = 2
anxn+ … + a0
# let rec valeur p m = match p with
| [] -> 0
| (v , e) ::t -> (v)* (expo m (e)) + valeur tm ;;
val valeur : (int * int) list -> int -> int = <fun>
# p1 ;;
-: (int * int) list = [(1, 0); (3, 1); (-2, 5)]
# valeur p1 1 ;;
-: int = 2
Licence 1 -programmation fonctionnelle 22
Calcul de la valeur en un point
# let value p m = let c1 x = match x with | (x1,x2) -> x1
in let c2 x = match x with | (x1,x2) -> x2
in let rec f acc p m = match p with
| [] -> acc
| h::t -> f (acc+(c1 h)* (expo m (c2 h))) t m
in f 0 p m ;;
val valeur : (int * int) list -> int -> int = <fun>
# p1 ;;
-: (int * int) list = [(1, 0); (3, 1); (-2, 5)]
# value p1 1 ;;
-: int = 2
anxn+ … + a0version terminale
Licence 1 -programmation fonctionnelle 23
Addition de deux polynômes
Première version
# let rec add p1 p2 = match (p1,p2) with
| (a,[]) -> a
| ([],a) -> a
| ((a1,n1)::t1 , (a2,n2)::t2) -> if n1 < n2 then (a1,n1)::add t1 p2 else
if n1=n2 then (a1+a2,n1)::add t1 t2
else (a2,n2)::add p1 t2 ;;
val add : (int * 'a) list -> (int * 'a) list -> (int * 'a) list = <fun>
# p1 ;;
-: (int * int) list = [(1, 0); (3, 1); (-2, 5)]
let p2 = [(1, 0); (2, 1); (3, 6)] ;;
val p2 : (int * int) list = [(1, 0); (2, 1); (3, 6)]
# addition p1 p2 ;;
-: (int * int) list = [(2, 0); (5, 1); (-2, 5); (3, 6)]
Licence 1 -programmation fonctionnelle 24
Addition de deux polynômes
Version terminale
# let addition p1 p2 = let rec addi acc p1 p2 = match (p1,p2) with
| (a,[]) -> acc@a
| ([],a) -> acc@a
| ((a1,n1)::t1 , (a2,n2)::t2) -> if n1 < n2 then addi (acc@[(a1,n1)]) t1 p2
else
if n1=n2 then addi (acc@[(a1+a2,n1)]) t1 t2
else addi (acc@[(a2,n2)]) p1 t2
in
addi [] p1 p2 ;;
val addition : (int * 'a) list -> (int * 'a) list -> (int * 'a) list = <fun>
# addition p1 p2 ;;
-: (int * int) list = [(2, 0); (5, 1); (-2, 5); (3, 6)]