Programmation fonctionnelle

Transcription

1 Exercice 1 a Programmation fonctionnelle a1/ # let a = 5 ;; a2/ # let f x = let a = x * x in (3*a+2) ;; a3/ # f 3 ;; a4/ # f a ;; Cours 7 : la récursivité (2) Licence 1 Année Par N. VINCENT # let a = 5 ;; val a : int = 5 # let f x = let a = x * x in (3*a+2) ;; # f 3 ;; - : int = 29 # f a ;; - : int = 77 Licence 1 - programmation fonctionnelle 2 Exercice 1-b b1/ # let h x y = match x,y with 0, y -> 2 * y x, 0 -> 3 * x _ -> x * y ;; b2/ # h 0 6 ;; b3/ réécrire la fonction h avec un seul argument et indiquer l interprétation correspondante. val h : int -> int -> int = <fun> # h 0 6 ;; - : int = 12 # let h (x,y) = match x,y with 0, y -> 2 * y x, 0 -> 3 * x _ -> x * y ;; val h : int * int -> int = <fun> Licence 1 - programmation fonctionnelle 3 Exercice 1-c c1/ # let g a b x = b (x,2*x) b (x, a x) ;; c2/ # g abs ;; c3/ proposer un exemple cohérent pour les 3 arguments et indiquer un appel correspondant. # let g a b x = b (x,2*x) b (x, a x) ;; val g : (int -> int) -> (int * int -> bool) -> int -> bool = <fun> # g abs ;; - : (int * int -> bool) -> int -> bool = <fun> # let aux (x,y) = x = y ;; # g abs aux 4 ;; val aux : 'a * 'a -> bool = <fun> Licence 1 - programmation fonctionnelle 4 Exercice 2 1 / 1 / Écrire une fonction booléenne petit qui compare deux éléments de même type donnés en argument. La fonction se base sur l opérateur < entre le premier et le second argument. Quel est le résultat de l appel : petit 56 25? Quel est le résultat de l appel : petit (30,4) (7,85)? # let petit x y = x <y ;; val petit : 'a -> 'a -> bool = <fun> # petit ;; Exercice 2 2 / 2 / Écrire une fonction range dont l argument est un couple d éléments de même type et dont le résultat est le couple des éléments rangés en sorte que le premier élément du couple est le plus petit. (on utilisera la fonction petit) Exemple : le résultat de l appel range ((6,5),(3,4)) est ((3,4),(6,5)) # let range (x,y) = if petit x y then (x,y) else (y,x) ;; val range : 'a * 'a -> 'a * 'a = <fun> # petit (30,4) (7,85) ;; Licence 1 - programmation fonctionnelle 5 Licence 1 - programmation fonctionnelle 6 1

2 Exercice 2 3 / 3 / Une date est modélisée par un triplet d entiers. Écrire une fonction booléenne avant indiquant si une date précède une autre. On écrira deux versions. a/ L une des définitions commencera par : let avant (j1,m1,a1) (j2,m2,a2)= b/ L autre commencera par : let avant d1 d2 = Exemple : le résultat de l appel avant (18,2,2019) (12,3,2019) est true avant est une fonction de comparaison qui diffère de la fonction petit. # let avant (j1,m1,a1) (j2,m2,a2) = if a1 <> a2 then a1 < a2 else if m1 <> m2 then m1 < m2 else j1 <= j2 ;; # let avant d1 d2 = match d1,d2 with (j1,m1,a1),(j2,m2,a2) -> if a1 <> a2 then a1 < a2 else if m1 <> m2 then m1 < m2 else j1 <= j2 ;; Licence 1 - programmation fonctionnelle 7 Exercice 2 3 / 3 / Une date est modélisée par un triplet d entiers. Écrire une fonction booléenne avant indiquant si une date précède une autre. On écrira deux versions. a/ L une des définitions commencera par : let avant (j1,m1,a1) (j2,m2,a2)= b/ L autre commencera par : let avant d1 d2 = Exemple : le résultat de l appel avant (18,2,2019) (12,3,2019) est true avant est une fonction de comparaison qui diffère de la fonction petit. # let avant (j1,m1,a1) (j2,m2,a2) = (a1,m1,j1) < (a2,m2,j2) ;; # let avant d1 d2 = match d1,d2 with (j1,m1,a1),(j2,m2,a2) -> (a1,m1,j1) < (a2,m2,j2) ;; Licence 1 - programmation fonctionnelle 8 Exercice 2 4 / Exercice 2 5 / 4 / Écrire une fonction tri avec deux arguments, une fonction de comparaison et un couple d éléments de même type. Le résultat de la fonction est le couple des éléments rangés en sorte que le premier élément du couple est inférieur au second au sens de la fonction en argument. La définition de tri commencera par let tri f (x,y). On indiquera l interprétation de la fonction proposée. Quel est l appel pour ordonner un couple de deux dates : (12,3,2019) et (18,2,2019)? # let tri f (x,y) = if f x y then (x,y) else (y,x) ;; val tri : ('a -> 'a -> bool) -> 'a * 'a -> 'a * 'a = <fun> # tri avant ((12,3,2019),(18,2,2019)) ;; - : (int * int * int) * (int * int * int) = ((18, 2, 2019), (12, 3, 2019)) Licence 1 - programmation fonctionnelle 9 5 / Écrire une fonction annees qui permet de calculer le nombre d années entières entre deux dates modélisées par le triplet décrit précédemment. La fonction comporte deux arguments (chacune des deux dates). # let annees d1 d2 = let ((j1,m1,a1),(j2,m2,a2))=tri avant (d1,d2) in if avant (j1,m1,a1) (j2,m2,a1) then a2-a1 else a2-a1-1 ;; val annees : 'a * 'b * int -> 'a * 'b * int -> int = <fun> Licence 1 - programmation fonctionnelle CC1 Chaîne, variable et expression # let X = 3 ;; Error: Unbound constructor X Les indices n ont pas de sens 2

3 Match # let f a = match a with (x,y,z) -> z ;; # f(3,2,5) ;; val f : 'a * 'b * 'c -> 'c = <fun> - : int = 5 # let f x y = match x with (3, y) -> 3 * y (5, 5) -> 55 _ -> 2 * y ;; val f : int * int -> int -> int = <fun> # f(3,25) # f(3,25) ;; ;; # f(3,25) 25 ;; - : int -> int = <fun> - : int = 75 # f(2,25) 25 ;; - : int = 50 # f(3,5) 25 ;; - : int = 15 Match # let f x = match x with (a,2*a) -> 5-> 5 _ -> 6 ;; _ -> 6 ;; Error: Syntax error: pattern expected. let # let f x f = x = match (x1,x2) with with x -> x -> 2 * 2 x *;; x ;; Error: Unbound value x1 # let f f1 x x = = match x x with (x1,x2)-> -> x1 x1 ;; ;; val f1 : 'a * 'b -> 'a = <fun> # let f f2 x x = = let let (x1,x2) = = x x in in x1 x1 ;; ;; val f2 : 'a * 'b -> 'a = <fun> # let h x,y = y ;; Error: Syntax error # f (3,6) ;; # let x=(x1,x2,x3) x=(x1,x2) ;; ;; Error: Unbound value x1 # f1 (2,25) ;; - : int = 2 # f2 (3,5) ;; - : int = 3 Comparaison # (2, 3) < (7, 1) ;; # 3 < 5 < (9 <11) ;; # 3 < 5 < 9 ;; ;; Error: This expression has type int but an expression was expected of type bool # true < true ;; # let f x y = if (x < y) then x < y else y < x ;; val f : 'a -> 'a -> bool = <fun> # false < true ;; # f 5 1 ;; Match # let f x = match x with x > 0 -> 1 x <0 -> -1 x=0 -> 0 ;; Error: Syntax error # let f x = match x with true -> 1 false false -> ->-1-1 _ -> _ -> 0 ;; 0 ;; Warning 11: this match case is unused. val f : bool -> int = <fun> # let f x y = if (1+x)<y then true else false ;; val f : int -> int -> bool = <fun> # let f x y = (1+x)<y ;; val f : int -> int -> bool = <fun> # let f x = match x<0 with true -> 0 false -> x ;; # let f x = if (x < 0) = true then 0 else x ;; # let f x = if x < 0 then 0 else x ;; If then else # let f a = if a > 0 then a-1 ;; # let f a = if a > 0 then a-1 ;; Error: This expression has type int but an expression was expected of type unit # let f a = if a > 0 then print_string "positif";; ;; val f : int -> unit = <fun> # let f a = if a > 0 then a-1 else print_string "négatif" ;; Error: This expression has type unit but an expression was expected of type int 3

4 # let positif a = a > 0 ;; ;; val positif : int -> bool = <fun> # let f positif l = List.for_all positif l ;; val f : ('a -> bool) -> 'a list -> bool = <fun> # let negatif a = a < 0 ;; val negatif : int -> bool = <fun> # let liste = [5;4; 8; 6] ;; val liste : int list = [5; 4; 8; 6] # f positif liste ;; # f negatif liste ;; # let f positif l = List.for_all positif l ;; val f : ('a -> bool) -> 'a list -> bool = <fun> # let list = [5; -1; 4; 8; 6] ;; val list : int list = [5; -1; 4; 8; 6] # f positif list ;; Error: Unbound value positif # let plus a = a > 0 ;; val plus : int -> bool = <fun> # f plus list ;; # let moins a = a < 0 ;; val moins : int -> bool = <fun> # f moins list ;; Fonction récursive Schéma de base #let rec f x = Si condition sur x Alors résultat facile à calculer Sinon lien entre le résultat sur les données plus simples et le résultat sur x Les difficultés : - définir le cas simple (condition sur x résultat) - trouver le lien avec les cas plus simples ramenant au cas simple Licence 1 - programmation fonctionnelle 21 Récursion et accumulation Factorielle : n! = (n-1).n let rec fact n = if n = 0 then 1 else n * fact(n-1) ;; val fact : int -> int = <fun> # fact 3 ;; fact <-- 3 fact(3) fact <-- 2 fact <-- 1 3xfact(2) fact <-- 0 3x2xfact(1) fact --> 1 fact --> 1 3x2x1xfact(0) fact --> 2 3x2x1x1 fact --> 6 Pourrait être calculée au fur et à mesure n! = (n-1). n Licence 1 - programmation fonctionnelle 22 Récursion et accumulation Récursion et ordre des calculs calcul au fur et à mesure n! = (n-1). n Pour calculer 4! 4 4x3 4x3x2 4x3x2x1 Il faut créer une variable intermédiaire dans laquelle on stocke les calculs progressivement. C est un accumulateur Nous l appellerons acc Licence 1 - programmation fonctionnelle 23 Comment créer une variable qui change de valeur au fur et à mesure des calculs? Utiliser une fonction factorielle qui a 2 arguments - n la valeur dont on calcule la factorielle - acc la variable intermédiaire # let rec facto acc n Pour 3! facto 1 3 facto 3 2 facto 6 1 facto 6 0 Cas simple n=0 et n->(n-1) Résultat : contenu de acc Cas plus simple acc -> acc x n n -> n 1 Lien facto (acc x n) (n 1) Licence 1 - programmation fonctionnelle 24 4

5 Récursion et ordre des calculs # let rec facto acc n = if n = 0 then acc else facto (acc * n) (n-1) ;; val facto : int -> int -> int = <fun> # facto 1 4 ;; Appel facto 1 3 facto 3 2 facto 6 1 facto 6 0 # facto 1 3 ;; facto <-- 1 facto* <-- 3 facto <-- 3 facto* <-- 2 facto* <-- 1 facto* <-- 0 Licence 1 - programmation fonctionnelle 25 L utilisateur n a pas à connaître l algorithme utilisé acc doit être caché Variable d'accumulation cachée n! = (n-1).n let factoriel n = facto 1 n ;; val factoriel : int -> int = <fun> # factoriel 4 ;; # let factoriel n = let rec facto acc nn = if nn = 0 then acc else facto (acc * nn) (nn-1) in facto 1 n ;; val factoriel : int -> int = <fun> # factoriel 4 ;; # factoriel 3 ;; facto <-- 1 facto* <-- 3 facto <-- 3 facto* <-- 2 facto* <-- 1 facto* <-- 0 Licence 1 - programmation fonctionnelle 26 Version terminale / non terminale # let rec facto acc n = if n = 0 then acc else facto (acc * n) (n-1) ;; val facto : int -> int -> int = <fun> let rec fact n = if n = 0 then 1 else n * fact(n-1) ;; val fact : int -> int = <fun> Terminal Non Terminal f(x) = si condition alors valeur sinon f(...) f(x) = si condition alors valeur sinon g(f(...)) Licence 1 - programmation fonctionnelle 27 Longueur d une liste # let rec long l = if l = [] then 0 else 1 + long (List.tl l) ;; version non terminale ajouter 1 à chaque fois qu une tête est trouvée Cas simple l = [] et l = h::t l -> t Résultat : contenu de acc Cas plus simple acc -> acc + 1 l -> t Lien longueur (acc + 1) t # let rec longueur acc l = if l = [] then acc else longueur (acc + 1) (List.tl l) ;; version terminale Licence 1 - programmation fonctionnelle 28 Longueur d une liste version terminale Les points importants # let long l = let rec longaux acc ll = match ll with [] -> acc h::t -> longaux (acc + 1) t in longaux 0 l ;; val long : 'a list -> int = <fun> Méthode récursive non terminale Méthode récursive terminale Licence 1 - programmation fonctionnelle 29 Licence 1 - programmation fonctionnelle 30 5