Nous continuons l’apprentissage de la programmation imp´erative par l’´etude des tableaux. `A titre d’illustration, nous ´ecrivons un jeu de fonctions qui impl´ementent les op´erations de base sur les polynˆomes. Avant de nous lancer dans la programmation, nous rappelons bri`evement ce que sont les polynˆomes.
Les polynˆomes `a une ind´etermin´ee
Des classes ´el´ementaires, on retient souvent qu’un polynˆome est une somme de puissances de x. Par exemple, p = x2+2x+3 est un polynˆome. La variable x est appel´ee
l’ind´etermin´ee du polynˆome. Un polynˆome est une somme de termes ´el´ementaires qu’on nomme monˆomes (par exemple x2 et 2x). ´Etant donn´ee une variable x, on appelle monˆome de coefficient ai et de degr´e i l’expression aixi. Le degr´e d’un polynˆome est
celui de son monˆome de plus haut degr´e. On rappelle que x1 = x et x0 = 1. Le monˆome
de degr´e 0 est donc r´eduit `a une constante (c’est 3 pour p) et celui de degr´e 1 au produit d’un nombre par l’ind´etermin´ee (c’est 2x pour p). D’autre part, nous utiliserons la propri´et´e : pour tout n et m entiers positifs, xn× xm = xn+m.
Nous mod´elisons les polynˆomes `a l’aide de tableaux d’entiers : le tableau des coef- ficients de leurs monˆomes. Les degr´es seront donc implicites, simplement d´etermin´es par l’indice du coefficient dans le tableau qui repr´esente le polynˆome. Par exemple, le polynˆome p = x2+ 2x + 3 sera repr´esent´e par le tableau contenant les nombres 3, 2, 1
dans cet ordre, puisque 3 est le coefficient de degr´e 0 de p, 2 est le coefficient de degr´e 1 et 1 le coefficient de degr´e 2. Nous ´etudions donc maintenant bri`evement les tableaux de Caml.
Tableaux
Les tableaux, aussi appel´es « vecteurs », sont des suites finies et modifiables de valeurs d’un mˆeme type. Leur type est not´e ′
a vect (o`u ′
a signifie « n’importe quel type »). Puisque les ´el´ements des tableaux sont tous de la mˆeme nature (du mˆeme type), on qualifie les tableaux de suites homog`enes de valeurs. Les valeurs d’un tableau sont enregistr´ees dans des cellules de m´emoire cons´ecutives. Les positions des ´el´ements dans un tableau d´ebutent `a la position 0.
Construction de tableaux
Un tableau se d´efinit de deux fa¸cons : soit en dressant directement la liste de ses ´el´ements, soit en cr´eant le tableau et en remplissant ses cases ult´erieurement. Si un tableau est d´efini par la liste de ses ´el´ements, cette liste est entour´ees des symboles [| et |], tandis que les ´el´ements sont s´epar´es par des « ; ». Notre polynˆome p = x2+2x+3
se d´efinit donc par la phrase :
# let p = [| 3; 2; 1 |];; p : int vect = [|3; 2; 1|]
Graphiquement, on repr´esente naturellement les tableaux par une succession de cases. Par exemple, p sera repr´esent´e ainsi :
Manipulation de polynˆomes 41
p 3 2 1
0 1 2
| {z }
indices
Pour construire des tableaux dont on remplira les cases plus tard, on dispose de la fonction pr´ed´efinie make_vect. Avec cette fonction, on cr´ee un tableau en donnant sa taille et un ´el´ement qui sera mis au d´epart dans toutes les cases du tableau : la valeur d’initialisation du tableau. D´efinissons par exemple un tableau de taille 4 contenant des 2 et un tableau de taille 3 contenant la chaˆıne "Bonjour" :
# let q = make_vect 4 2;; q : int vect = [|2; 2; 2; 2|] # let r = make_vect 3 "Bonjour";;
r : string vect = [|"Bonjour"; "Bonjour"; "Bonjour"|]
La taille d’un tableau s’obtient en appelant la primitive vect_length.
# vect_length q;; - : int = 4
Une fois le tableau cr´e´e, on peut consulter et modifier le contenu de ses cases. Si t est un tableau et n un entier, t.(n) d´esigne l’´el´ement d’indice n du tableau t.
t
t.(0) t.(n) t.(vect_length(t)−1)
# let a0 = p.(0);; a0 : int = 3
On affecte la valeur v `a la case n du tableau t par la construction t.(n) <- v. Cela correspond graphiquement `a :
t
t.(0) t.(n − 1) t.(n + 1) t.(vect_length(t)−1)
v
La valeur retourn´ee par cette construction est (), la valeur « rien ».
# q.(0) <- 1;; - : unit = () # q;;
- : int vect = [|1; 2; 2; 2|]
# r.(1) <- "tout"; r.(2) <- "le monde!";; - : unit = ()
# r;;
- : string vect = [|"Bonjour"; "tout"; "le monde!"|]
Nous savons maintenant d´efinir des tableaux, en lire et modifier les ´el´ements. Il nous faut encore apprendre `a les parcourir. C’est tr`es facile en utilisant les boucles que nous avons d´ecrites `a la section pr´ec´edente. Puisqu’il s’agit de parcourir un tableau,
on connaˆıt `a l’avance le nombre de r´ep´etitions : on utilise donc une boucle « pour ». Le parcours complet d’un tableau t s’effectue par une boucle commen¸cant en 0 et finissant en vect_length t - 1. En effet, puisque les indices d’´el´ements de tableaux commencent toujours `a 0, le dernier ´el´ement d’un tableau a pour indice la longueur du tableau moins un. Par exemple :
# for i = 0 to vect_length r - 1 do print_string r.(i)
done;;
Bonjourtoutle monde!- : unit = ()
Pour rendre la sortie plus jolie, il suffit d’ajouter un blanc apr`es chaque ´el´ement :
# for i = 0 to vect_length r - 1 do print_string r.(i);
print_string " " done;;
Bonjour tout le monde! - : unit = ()
Syntaxe des tableaux
Pour m´emoire, voici la syntaxe BNF correspondant `a ces deux constructions et `a la d´efinition des tableaux sous la forme de liste d’´el´ements.
La syntaxe des d´efinitions de tableaux est la suivante : Tableaux ::= [| expression( ; expression)∗
|]
Nous utilisons ici un nouveau symbole pour la description des constructions syntax- iques qui acceptent les r´ep´etitions : l’´etoile «∗
». La formule quelque-chose∗
signifie la r´ep´etition de quelque-chose un nombre quelconque de fois, y compris z´ero fois si n´ecessaire (ce qui correspond alors `a ignorer compl`etement quelque-chose). Nous in- diquons ainsi que le premier ´el´ement du tableau est ´eventuellement suivi d’autres ´el´ements, en nombre quelconque, s´epar´es par des points-virgules.
La syntaxe de l’affectation et de l’acc`es aux ´el´ements de tableaux est la suivante : Acc`es dans un tableau ::= vect .( indice )
Modification d’un ´el´ement de tableau ::= vect .( indice ) <- expression Attention `a la signification des parenth`eses dans cette description. Elles font ici partie de la syntaxe d´ecrite (il faut les ´ecrire dans les programmes), alors que dans la notation ( ; expression)∗
, les parenth`eses nous servaient `a regrouper les constructions syntax- iques « ; » et « expression ». (La diff´erence de nature des parenth`eses se traduit par un changement de police de caract`eres.)