Programmation fonctionnelle

Programmation fonctionnelle
Notes de cours
Cours 2
18 Septembre 2013
Sylvain Conchon
[email protected]
1/19 1
Programme 5 : Trac´ e de courbe
Notions introduites :
In-uplets, tableaux
Iordre d’´
evaluation
Ifonctions de premi`
ere classe, ordre sup´ erieur
Ifonctions anonymes
Ifiltrage
4
20
15
2
2
30
10
10
15
2/19 2
Les n-uplets
Expressions de type produit
#(1,’a’);;
-:int*char = (1, ’a’)
# (1 + 2, ’a’, true && false) ;;
- : int * char * bool = (3, ’a’, false)
# ("hello", (1, 3.4)) ;;
- : string * (int * float) = ("hello", (1, 3.4))
# fst (1, ’a’) ;;
-:int=1
# snd ((1, ’a’), (2+3, true, "a")) ;;
- : int * bool * string = (5, true, "a")
Ile type produit *repr´
esente les n-uplets
Iles n-uplets peuvent ˆ
etre arbitrairement imbriqu´ es
Ifst et snd permettent d’acc´
eder respectivement ` a la premi` ere
et ` a la deuxi` eme composante d’une valeur de type τ1*τ2
3/19 3
Les n-uplets
Attention ` a ne pas confondre les types des expressions suivantes :
# (1, 2, 3) ;;
- : int * int * int = (1, 2, 3)
# ((1, 2), 3) ;;
- : (int * int) * int = ((1, 2), 3)
# (1, (2, 3)) ;;
- : int * (int * int) = (1, (2, 3))
Iint * int * int d´
esigne un triplet d’entiers
I(int * int) * int est une paire dont la premi `
ere
composante est une paire d’entiers et la deuxi` eme un entier
Iint * (int * int) est une paire dont la premi `
ere
composante est un entier et la deuxi` eme une paire d’entiers
4/19 4

Les n-uplets
Attention ´ egalement ` a ne pas confondre les types des fonctions
suivantes :
#letfxyz=x+y+z;;
val f : int -> int -> int -> int = <fun>
#letf(x,y,z)=x+y+z;;
val f : int * int * int -> int = <fun>
Iint -> int -> int -> int est le type d’une fonction avec
trois arguments de type int
I(int * int * int) -> int d´
esigne le type d’une fonction
`
aun argument (un triplet) de type int * int * int
5/19 5
Les tableaux
#lett=[| 5;1;3|] ;;
val t : int array = [| 5; 1; 3 |]
# t.(0) <- 10 ;;
- : unit = ()
# t.(0) ;;
- : int = 10
#Array.length t ;;
-:int=3
Iarray est le type “g´
en´ erique” des tableaux
It.(i) est l’acc`
es au i` eme ´ el´ ement d’un tableau t
It.(i) <- v affecte la valeur vdans i`
eme case de t
L’indexation des cases d’un tableau contenant
n´ el´ ements se fait de 0` an−1
6/19 6
Les tableaux
#lett=Array.make 4 ’a’ ;;
val t : char array = [| ’a’; ’a’; ’a’; ’a’ |]
#lett=Array.init 5 (fun i -> 2 * i) ;;
val t : int array = [|0; 2; 4; 6; 8|]
IArray.make n v cr´
ee un tableau de ncases, toutes
initialis´ ees avec la mˆ eme valeur v(attention au partage) ;
IArray.init n f cr´
ee un tableau de taille ninitialis´ e par la
fonction f: pour chaque case d’indice i,f i renvoie la valeur
`
a stocker en i.
7/19 7
Les tableaux multi-dimensionnels
# let t = [| [|1; 0|]; [|0; 1|] |] ;;
valt:int array array = [| [|1; 0|]; [|0; 1|] |]
# t.(0).(1) ;;
-:int=0
# t.(1) ;;
- : int array = [|0; 1|]
# let t = Array.make matrix 2 2 0. ;;
val t : float array array = [|[|0.; 0.|]; [|0.; 0.|]|]
Iles tableaux multi-dimensionnels sont simplement
repr´ esent´ es par des tableaux contenant d’autres tableaux
Iles matrices sont donc de type αarray array, o `
uα
repr´ esente n’importe quel type
Il’op´
eration .(i) est associative ` a gauche, c’est-` a-dire qu’il
faut lire t.(i).(j).(k) comme t.(i) .(j) .(k)
8/19 8

Les fonctions anonymes
#fun x-> x * x ;;
- : int -> int = <fun>
# (fun x -> x * x) 4 ;;
- : int = 16
#funxy->x*y;;
- : int -> int -> int = <fun>
Ile mot-cl´
efun permet de cr´ eer des valeurs fonctionnelles
Iles fonctions anonymes s’appliquent comme les fonctions
nomm´ ees
Ila d´
eclation letfxy=x*yest donc ´ equivalente ` a
letf=funxy->x*y
9/19 9
L’ordre sup´ erieur
Les fonctions sont des valeurs comme les autres
Elles peuvent ˆ etre
Istock´
ees dans une structure de donn ´ ee
Ipass´
ees en argument ` a une autre fonction
Iretourn´
ees comme r´ esultat d’une fonction
Les fonctions prenant des fonctions en arguments ou rendant des
fonctions en r´ esultat sont dites d’ordre sup´ erieur
10/19 10
Fonctions stock´ ees dans des structures de donn ´ ees
#((fun x -> x + 1), 4.2 ) ;;
- : (int -> int) * float = (<fun>, 4)
#lett=[|(fun x -> x * 2);(funx->x+1)|] ;;
val t : (int -> int) array = [| <fun>; <fun> |]
# t.(0) 5 ;;
- : int = 10
#letf=ref(fun x -> x + 2) ;;
val f : (int -> int) ref
# !f 5 ;;
-:int=7
#f:=(fun x -> x / 4) ;;
- : unit = ()
Iles fonctions peuvent ˆ
etre stock´ ees comme des valeurs
quelconques
11/19 11
Fonctions comme arguments
Icertaines fonctions prennent naturellement des fonctions en
arguments
Ipar exemple, les notations math´
ematiques telles que la
sommation Σn
i=1f(i)se traduisent imm´
ediatement si l’on peut
utiliser des arguments fonctionnels
# let rec somme (f, n) =
if n<=0 then 0
else (f n) + somme (f, n - 1) ;;
val somme : (int -> int) * int -> int = <fun>
# somme ( (fun x -> x * x), 10) ;;
- : int = 385
12/19 12

Exemple : la m´ ethode dichotomique (1/2)
Si fest une fonction continue et monotone, on peut trouver un
z´ ero de fsur un intervalle [a, b]par la m´ ethode dichotomique
quand f(a)et f(b)sont de signes oppos´ es :
Isi est la pr´
ecision souhait´ ee et que |b−a|<  alors on
renvoie a
Isinon, couper l’intervalle [a, b]en deux et recommencer sur
l’intervalle contenant 0
13/19 13
Exemple : la m´ ethode dichotomique (2/2)
# let rec dichotomie f (a, b) epsilon =
if abs float (b -. a) < epsilon then a
else
let c = (a +. b) /. 2.0 in
let bornes =
if (f a) *. (f c) > 0. then (c, b) else (a, c)
in
dichotomie f bornes epsilon
val dichotomie :
(float -> float) -> (float * float) -> float -> float = <fun>
Ion peut utiliser cette m´
ethode pour trouver un encadrement
de πen le calculant comme z´ ero de la fonction cos(x/2)
# dichotomie (fun x->cos (x/.2.0)) (3.1, 3.2) 1e-10 ;;
- : float = 3.14159265356138384
14/19 14
Fonctions comme r´ esultats
ILes fonctions `
a plusieurs arguments sont en fait des fonctions
d’ordre sup´ erieur qui rendent des fonctions comme r´ esultats
# let plus x y = x + y ;;
val plus : int -> int -> int
IIl faut lire le type de cette fonction de la mani `
ere suivante
int -> (int -> int)
IDe mani`
ere ´ equivalente, on peut ´ ecrire la fonction plus de la
fac¸on suivante afin de souligner son r´ esultat fonctionnel
# let plus x = (fun y -> x+y) ;;
val plus : int -> int -> int
15/19 15
Applications partielles
# let plus2 = plus 2 ;;
val plus2 : int -> int = <fun>
# plus2 10 ;;
- : int = 12
# plus2 100 ;;
- : int = 102
ILes fonctions d’ordre sup´
erieur rendant des fonctions en
r´ esultats peuvent ˆ etre appliqu´ ees partiellement
IOn peut faire des calculs avant de renvoyer un r´
esultat
#letfx=
Printf.printf "x = %d" x;
(fun y -> Printf.printf "y = %d" y);;
# let f1 = f 1 ;;
x = 1 val f1 : int -> unit = <fun>
# let () = f1 2 ;;
y=2-:unit=()
16/19 16

Fermetures
# let compteur i =
let etat = ref i in
fun () -> etat := !etat + 1; !etat ;;
val compteur : int -> unit -> int
# let f = compteur 0 ;;
valf:unit -> int = <fun>
# f () ;;
-:int=1
# f () ;;
-:int=2
# let g = compteur 10 ;;
valg:unit -> int = <fun>
# g() ;;
- : int = 11
IUne fermeture est une fonction avec un ´
etat interne
IDans cet exemple, les fonctions fet gont chacune leur ´
etat
17/19 17
Exemple de fonctions en arguments et en r´ esultat (1/2)
On peut calculer de fac¸on approximative la d´ eriv ´ ee f0d’une
fonction favec un petit intervalle dx de la mani` ere suivante :
# let derive (f, dx) =
fun x -> ( f(x +. dx) -. f(x) ) /. dx ;;
val derive :
(float -> float) * float -> float -> float = <fun>
# derive ( (fun x -> x *. x), 1e-10) 1. ;;
- : float = 2.000000165480742
18/19 18
Exemple : fonctions en arguments et en r´ esultat (2/2)
IOn peut r´
e´ ecrire la fonction derive de la mani` ere suivante
# let derive dx f =
fun x -> ( f(x +. dx) -. f(x) ) /. dx ;;
val derive :
float -> (float -> float) -> float -> float
IOn fixe le param`
etre dx par application partielle
# let derivation = derive 1e-10 ;;
val derivation : (float -> float) -> float -> float
IOn peut alors d´
efinir par exemple la d ´ eriv ´ ee de la fonction
sinus simplement de la mani` ere suivante :
# let sin’ = derivation sin ;;
val sin’ : float -> float
# sin’ 1. ;;
- : float = 0.540302247387103307
# cos 1. ;;
- : float = 0.540302305868139765
19/19 19