Programmation fonctionnelle

Transcription

1 Programmation fonctionnelle Cours 11 : les enregistrements Licence 1 Année Par N. VINCENT Exercice 1-1 # let rec f l x= match l with [ ] -> [ ] [h] -> [ h + x] h1 :: h2 :: t -> (h1 + x) ::(f t x);; 1 / Quel est son effet pour les arguments [ 3 ; 2 ; 8 ; 51 ; 1 ; 21 ; 1 ] et 3? f [ 3 ; 2 ; 8 ; 51 ; 1 ; 21 ; 1 ] 3 = (3+3)::(f [8 ; 51 ; 1 ; 21 ; 1 ] 3) f [8 ; 51 ; 1 ; 21 ; 1 ] 3 = (8+3)::(f [1 ; 21 ; 1 ] 3) f [1 ; 21 ; 1 ] 3 = (1+3):: (f [1 ] 3) f [1 ] 3 = [1 +3] f [1 ] 3 = [4] f [1 ; 21 ; 1 ] 3 = (4):: [4 ] f [8 ; 51 ; 1 ; 21 ; 1 ] 3 = (11):: [4 ; 4 ] f [ 3 ; 2 ; 8 ; 51 ; 1 ; 21 ; 1 ] 3 = (6):: [11 ; 4 ; 4 ] = [6 ; 11 ; 4 ; 4 ] Licence 1 - programmation fonctionnelle 2 Exercice 1-2 # let rec f l x= match l with [ ] -> [ ] [h] -> [ h + x] h1 :: h2 :: t -> (h1 + x) ::(f t x);; 2 / Écrire une version terminale ft de cette fonction. # let ft l x = let rec ftaux acc ll xx = match ll with [ ] -> acc [h] -> acc@[ h + xx] h1 :: h2 :: t -> ftaux (acc@[ h1 + x]) t xx in ftaux [ ] l x;; ;; val ft : int list -> int -> int list = <fun> Exercice / Écrire une fonction positif qui remplace par 0 les éléments négatifs d une liste On donnera deux versions de la fonction dont une devra être sous forme terminale. Le résultat de la fonction pour [1 ; -5 ; 10 ; 4 ; -1 ; -5 ; 3] est égal à [1 ; 0 ; 10 ; 4 ; 0 ; 0 ; 3] h :: t -> (if h > 0 then h else 0)::(positif t);; h :: t -> if h > 0 then h::positif t else 0::(positif t);; # let positif l = let pos x = if x > 0 then x else 0 in List.map pos l ;; Licence 1 - programmation fonctionnelle 3 Licence 1 - programmation fonctionnelle 4 Exercice / Écrire une fonction positif qui remplace par 0 les éléments négatifs d une liste On donnera deux versions de la fonction dont une devra être sous forme terminale. Le résultat de la fonction pour [1 ; -5 ; 10 ; 4 ; -1 ; -5 ; 3] est égal à [1 ; 0 ; 10 ; 4 ; 0 ; 0 ; 3] h :: t -> (if h > 0 then h else 0)::(positif t);; # let positif l = let rec faux acc ll = match ll with [ ] -> acc h :: t -> faux [if h > 0 then h else 0 ]) t in faux [ ] l ;; Licence 1 - programmation fonctionnelle 5 Exercice / Écrire une fonction somme dont l argument est une liste d entiers et dont le résultat est un couple dont le premier terme contient la somme des termes positifs et le second la somme des termes négatifs. Le résultat de la fonction pour [1 ; -5 ; 10 ; 4 ; -1 ; -5 ; 3] est égal à (18, -11) # let somme l = let rec sommeplus ll = match ll with [ ] -> 0 h :: t -> if h > 0 then h+(sommeplus t) else sommeplus t in let rec sommemoins ll = match ll with [ ] -> 0 h :: t -> if h < 0 then h+(sommemoins t) else sommemoins t in (sommeplus l, sommemoins l) ;; # let somme l = let rec somaux accp accn ll = match ll with [ ] -> (accp, accn) h :: t -> if h > 0 then somaux (accp+h) accn t else somaux accp (accn+h) t in somaux 0 0 l ;; Licence 1 - programmation fonctionnelle 6 1

2 Exercice / Écrire une fonction somme dont l argument est une liste d entiers et dont le résultat est un couple dont le premier terme contient la somme des termes positifs et le second la somme des termes négatifs. Le résultat de la fonction pour [1 ; -5 ; 10 ; 4 ; -1 ; -5 ; 3] est égal à (18, -11) # let rec somme l = match l with [ ] -> (0, 0) h :: t -> if h > 0 then (h, 0) + somme t else (0, h) + somme t # let rec somme l = let add (x1,y1) (x2,y2) = (x1 + x2, y1 + y2) in match l with [ ] -> (0, 0) h :: t -> if h > 0 then add (h, 0) (somme t) else add (0, h) (somme t) ;; Exercice / Écrire une fonction moyenne qui indique la moyenne des termes d une liste Le résultat de la fonction pour [1 ; -5 ; 10 ; 4 ; -1 ; -5 ; 3] est égal à 1.0 # let moyenne l = let (a,b) = somme l in (float_of_int (a+b )) /. float_of_int (List.length l) ;; # let moyenne l = let rec somme ll = match ll with [ ] -> 0 h :: t -> h + somme t in (float_of_int (somme l )) /. float_of_int (List.length l) ;; # let moyenne l = let rec moy acc ll = match ll with [ ] -> (float_of_int (acc)) /. float_of_int (List.length ll) l) h :: t -> moy (acc+h) t # moyenne [1 ; -5 ; 10 ; 4 ; -1 ; -5 ; 3] ;; in moy 0 l ;; - : float = infinity Licence 1 - programmation fonctionnelle 7 Licence 1 - programmation fonctionnelle 8 Exercice 3-1 Une liste ne doit pas être vide pour constituer une ligne. Une liste de points définit une ligne polygonale. Un polygone est une ligne polygonale fermée. Une liste ne comportant qu un point est un polygone. Par exemple [ (1,1) ; (1,5) ; (4,5) ; (4,2) ] représente une ligne, tandis que [ (1,1) ; (1,5) ; (4,5) ; (4,2) ; (1,1)] représente un polygone. 1 / Écrire une fonction dernier dont l argument est une liste et dont le résultat est le dernier terme de la liste. # let rec dernier l = match l with [] -> failwith "la liste est vide" [h] -> h dernier t ;; val dernier : 'a list -> 'a = <fun> # dernier [ (1,1) ; (1,5) ; (4,5) ; (4,2) ] ;; - : int * int = (4, 2) # dernier [ ] ;; Exception: Failure "la liste est vide". Licence 1 - programmation fonctionnelle 9 Exercice / Écrire une fonction dist ayant deux points en arguments dont le résultat est la distance euclidienne réelle entre les deux points. # let dist (x1,y1) (x2,y2) = sqrt (float_of_int ((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2))) ;; val dist : int * int -> int * int -> float = <fun> # dist (1,1) (1,5) ;; - : float = 4. # let dist (x1,y1) (x2,y2) = sqrt (((float_of_int (x1-x2))** 2.) +. ((float_of_int (y1-y2))**2.)) ;; val dist : int * int -> int * int -> float = <fun> # dist (1,1) (1,5) ;; - : float = 4. Licence 1 - programmation fonctionnelle 10 Exercice / Écrire une fonction longueur dont l argument est une liste de points et dont le résultat est la longueur réelle de la ligne polygonale. La fonction proposée doit être terminale. Exercice / Écrire une fonction booléenne gauche_droite dont l argument est une liste de points et qui indique si tous les points sont à droite au sens large de leur prédécesseur. # let rec longueur l = match l with [ m ] -> 0. m1::m2::t -> (dist m1 m2) +. longueur (m2::t) ;; val longueur : (int * int) list -> float = <fun> # let longueur l = assert (l <> [ ]) ; let rec long acc ll = match ll with [ m ] -> acc m1::m2::t -> long (acc +. (dist m1 m2)) (m2::t) in long 0. l ;; val longueur : (int * int) list -> float = <fun> Licence 1 - programmation fonctionnelle 11 # let rec gauche_droite l = match l with [ m ] -> true (x1,y1)::(x2,y2)::t -> if x1>x2 then false else gauche_droite ((x2,y2)::t) ;; val gauche_droite : ('a * 'b) list -> bool = <fun> Licence 1 - programmation fonctionnelle 12 2

3 Exercice / Écrire une fonction booléenne polygone dont l argument est une liste de points et qui indique si la ligne polygonale est un polygone. # let polygone l = match l with [ m ] -> true h = dernier t ;; val polygone : 'a list -> bool = <fun> # polygone [ (1,1) ; (1,5) ; (4,5) ; (4,2) ] ;; - : bool = false # polygone [ (1,1) ; (1,5) ; (4,5) ; (4,2) ; (1,1)] ;; - : bool = true Licence 1 - programmation fonctionnelle 13 Exercice / Écrire une fonction lig2polyg dont l argument est une liste de points et dont le résultat est le polygone obtenu en ajoutant à la droite de la liste, le premier point de la ligne, si celle-ci n est pas déjà un polygone. # let lig2polyg l = if polygone l then l else l@ [ List.hd l] ;; val lig2polyg : 'a list -> 'a list = <fun> # lig2polyg [ ] ;; Exception: Failure "la liste est vide". # lig2polyg [ (1,1) ; (1,5) ; (4,5) ; (4,2) ] ;; - : (int * int) list = [(1, 1); (1, 5); (4, 5); (4, 2); (1, 1)] # lig2polyg [ (1,1) ; (1,5) ; (4,5) ; (4,2) ; (1,1)] ;; - : (int * int) list = [(1, 1); (1, 5); (4, 5); (4, 2); (1, 1)] Licence 1 - programmation fonctionnelle 14 Accès aux valeurs d'un champ Enregistrements # type t_info ={ info1 : float ; info2 : int ; info3 : string} ;; type t_info = { info1 : float; info2 : int; info3 : string; } Définition d'une fiche de type t_info # let e1 = {info1 = 3. ; info2 = 2 ; info3 = "bonjour "} ;; val e1 : t_info = {info1 = 3.; info2 = 2; info3 = "bonjour "} # let e2 = {info1 = 5. ; info3 = "bonjour "; info2 = (-2)} ;; val e2 : t_info = {info1 = 5.; info2 = -2; info3 = "bonjour "} # e1.info1 ;; - : float = 3. - : int = 2 # e1.info3 ;; - : string = "bonjour " Licence 1 - programmation fonctionnelle 15 Est possible sur les enregistrements On peut utiliser la généralisation par _ aussi bien sur un champ que sur l'ensemble du reste des enregistrements {nom = _ ; ident = _ ; licence = true ; ne = 1996 ; result = _ } match m with {nom = _ ; ident = _ ; licence = true ; ne = 1996 ; result =_ } -> print_string m.nom ; print_string _ -> print_string Licence 1 - programmation fonctionnelle 16 Fonction qui affiche les noms des membres une liste # let rec extract l = match l with [] -> print_newline () -> print_string h.nom ; print_string" " ; extract t _ -> print_string" " ; extract t ;; val extract : t_membre list -> unit = <fun> # let l = [m1 ; m2 ; m3] ;; val l : t_membre list = [{nom = "dupont"; ident = "eee"; licence = true; ne = 1996; result = []}; {nom = "dupond"; ident = "eae"; licence = true; ne = 1996; result = []}; # extract l ;; dupont dupond Licence 1 - programmation fonctionnelle 17 Fonction qui retourne les noms des membres une liste # let rec extract l = match l with [] -> [] -> h.nom :: extract t _ -> extract t ;; val extract : t_membre list -> string list = <fun> # let l = [{nom = "dupont"; ident = "eee"; licence = true; ne = 1996; result = [true ; false ; true]}; {nom = "durant"; ident = "eae"; licence = true; ne = 1996; result = []}; # extract l ;; - : string list = ["dupont"; "durant"] Licence 1 - programmation fonctionnelle 18 3

4 Fonction qui retourne les noms des membres une liste, version terminale # let extract1 l = let rec faux acc ll = match ll with [] -> acc -> faux (h.nom ::acc) t _ -> faux acc t in faux [] l ;; val extract1 : t_membre list -> string list = <fun> # let l = [{nom = "dupont"; ident = "eee"; licence = true; ne = 1996; result = [true ; false ; true]}; {nom = "durant"; ident = "eae"; licence = true; ne = 1996; result = []}; # extract1 l ;; - : string list = ["durant"; "dupont"] Licence 1 - programmation fonctionnelle 19 Modifier un champ Ajouter un résultat à un membre # let ajour m r = {nom = m.nom ; ident = m.ident ; ne = m.ne ; licence = m.licence ; result = r::m.result } ;; val ajour : t_membre -> bool -> t_membre = <fun> # let m4 = ajour m1 true ;; val m4 : t_membre = {nom = "dupont"; ident = "eee"; licence = true; ne = 1990; result = [true]} # let m5 = ajour m4 false ;; val m5 : t_membre = {nom = "dupont"; ident = "eee"; licence = true; ne = 1990; result = [false; true]} Licence 1 - programmation fonctionnelle 20 Dans une liste ajouter un résultat à un # let rec modif l a b = match l with [] -> [] if h = a then b::modif t a b else h::modif t a b ;; # let ll = [1 ; 2 ; 3 ; 2 ; 5 ; 2 ] ;; val ll : int list = [1; 2; 3; 2; 5; 2] # let ll = modif ll 2 0 ;; val ll : int list = [1; 0; 3; 0; 5; 0] # ll ;; D'abord un cas plus général : remplacer par b les occurrences a dans une liste l - : int list = [1; 0; 3; 0; 5; 0] Licence 1 - programmation fonctionnelle 21 Remplacer par b les occurrences a dans une liste l En version terminale # let rec modif l a b = match l with [] -> l if h = a then b::modif t a b else h::modif t a b ;; # let modif l a b = let rec faux acc ll aa bb = match ll with [] -> acc if h = aa then faux (acc@[b]) t aa bb else faux (acc@[h]) t aa bb in faux [] l a b ;; # let liste = [1 ; 2 ; 3 ; 2 ; 5 ; 2 ] ;; val liste : int list = [1; 2; 3; 2; 5; 2] # modif liste 2 0 ;; - : int list = [1; 0; 3; 0; 5; 0] Licence 1 - programmation fonctionnelle 22 # let rec modif l a b = match l with [] -> l if h = a then b::modif t a b else h::modif nom t a b :;; string ; Dans une liste ajouter un résultat à un # let rec modif l a r = match l with [] -> l if h.ident = a then let b = {nom=h.nom ; ident= a ; ne = h.ne ; result = r::h.result ; licence = h.licence } in b::modif t a r else h::modif t a r ;; val modif : t_membre list -> string -> bool -> t_membre list = <fun> Let l =[{nom= "dupont"; ident = "eee"; licence = true; ne = 1990; result = []}; {nom = "dupond"; ident = "eae"; licence = true; ne = 1990; result = []}; {nom = "dupond"; ident = "ebe"; licence = true; ne = 1995; result = []}] ;; # modif l "eee" true ;; - : t_membre list = [{nom = "dupont"; ident = "eee"; licence = true; ne = 1990; result = [true]}; {nom = "dupond"; ident = "eae"; licence = true; ne = 1990; result = []}; {nom = "dupond"; ident = "ebe"; licence = true; ne = 1995; result = []}] Licence 1 - programmation fonctionnelle 23 Dans une liste ajouter un résultat à un # let remplace l a r = let rec modif acc ll aa rr = match ll with [] -> acc if h.ident = aa then let b = {nom=h.nom ; ident= aa ; ne = h.ne ; result = r::h.result ; licence = h.licence } in modif (acc@[b]) t aa rr else modif (acc@[h]) t aa rr in modif [] l a r ;; val remplace: t_membre list -> string -> bool -> t_membre list = <fun> Licence 1 - programmation fonctionnelle 24 4

5 Enregistrements # type t_info ={ info1 : float ; info2 : int ; info3 : string} ;; type t_info = { info1 : float; info2 : int; info3 : string; } accès - : int = 2 Les champs ne sont pas modifiables # let e1 = f e1 e2 ;; val e1 : t_info = {info1 = 8.; info2 = 0; info3 = "bonjour bonjour "} - : int = 0 Licence 1 - programmation fonctionnelle 25 Enregistrement à champ mutable Un champ modifiable est dit mutable # type t_info ={ info1 : float ; mutable info2 : int } ;; type t_info = { info1 : float; mutable info2 : int; } # x.info2 <- 0 ;; # let x = {info2 = 5 ; info1 = 4.5 } ;; val x : t_info = {info1 = 4.5; info2 = 5} # let modif xx = xx.info2 <- read_int() ;; val modif : t_info -> unit = <fun> # modif x ;; # x ;; 2 - : t_info = {info1 = 4.5; info2 = 0} # x ;; - : t_info = {info1 = 4.5; info2 = 2} Licence 1 - programmation fonctionnelle 26 5