Cet ouvrage fait partie de la bibliothèque YouScribe
Obtenez un accès à la bibliothèque pour le lire en ligne
En savoir plus

Apprendre à programmer avec OCaml

De
443 pages


Un langage de programmation moderne



La connaissance de l'algorithmique (dont le but est de choisir l'algorithme le plus élégant et le plus efficace en toute cir-constance) est ce qui distingue en premier lieu le programmeur avancé de celui qui débute. Cet ouvrage d'algorithmique fondamentale choisit le langage de programmation moderne OCaml, pris comme modèle par Microsoft pour concevoir F#, afin d'initier le lecteur à cet outil puissant alliant expressivité, performance et sûreté. OCaml est également l'un des fers de lance de l'institut de recherche public Inria depuis une vingtaine d'années.



Un livre incontournable pour débuter avec OCaml



C'est pourquoi cet ouvrage propose une véritable initiation à ce langage, à la fois aux débutants en programmation et aux programmeurs plus expérimentés qui ne le connaissent pas. À travers plus de 100 petits programmes et près de 200 exercices associés, le lecteur découvrira également les concepts fondamentaux de la programmation et du langage OCaml.



À qui s'adresse ce livre ?



Ce livre peut également servir de manuel d'initiation à la programmation OCaml pour les élèves des classes préparatoires aux grandes écoles qui ont choisi de se spécialiser en informatique - voies MPSI, MP ou MPx -, et les étudiants en informatique à l'université. En plus des passionnés d'algorithmique, il intéressera tous les développeurs avancés souhaitant se tourner vers un langage de programmation fonctionnel, tel que Scala, F#, Scheme, Lisp, etc.




  • Programmation avec OCaml


    • Environnement de travail


    • Débuter avec OCaml en programmant


    • Approfondir les concepts d'OCaml




  • Structures de données


    • Tableaux


    • Ensembles et dictionnaires


    • Files


    • Graphes


    • Classes disjointes


    • Le zipper




  • Techniques algorithmiques et applications


    • Arithmétique


    • Programmation dynamique et mémorisation


    • Algorithmes de tri


    • Algorithmes de graphes




Voir plus Voir moins

Vous aimerez aussi

Sylvain Conchon et Jean-Christophe Filliâtre
Apprendre
à programmer
avec OCaml
Algorithmes
et structures de donnéesSylvain Conchon est professeur d’informatique à l’université Paris-Sud où il enseigne la programmation
et l’algorithmique avec OCaml. Jean-Christophe Filliâtre est chercheur au CNRS. Il donne par ailleurs des
cours d’algorithmique à l’École polytechnique et de compilation avec OCaml à l’ENC (Ulm). Tous deux sont
programmeurs OCaml depuis plus de vingt ans et ont développé de nombreux logiciels avec ce langage.
Ils sont très actifs au sein de la communauté francophone des langages applicatifs et ont organisé, entre
autres, les « Journées francophones des langages applicatifs ».
Un langage de programmation moderne
La connaissance de l’algorithmique (dont le but est de choisir l’algorithme le plus élégant et le plus effcace en toute
circonstance) est ce qui distingue en premier lieu le programmeur avancé de celui qui débute. Cet ouvrage d’algorithmique
fondamentale choisit le langage de programmation moderne OCaml, pris comme modèle par Microsoft pour concevoir
F#, afn d’initier le lecteur à cet outil puissant alliant expressivité, performance et sûreté. OCaml est également l’un des
fers de lance de l’institut de recherche public Inria depuis une vingtaine d’années.
Un livre incontournable pour débuter avec OCaml
C’est pourquoi cet ouvrage propose une véritable initiation à ce langage, à la fois aux débutants en programmation et
aux programmeurs plus expérimentés qui ne le connaissent pas. À travers plus de 100 petits programmes et près de
200 exercices associés, le lecteur découvrira également les concepts fondamentaux de la programmation et du langage
OCaml.
À qui s’adresse ce livre ?
Ce livre peut également servir de manuel d’initiation à la programmation OCaml pour les élèves des classes préparatoires
aux grandes écoles qui ont choisi de se spécialiser en informatique – voies MPSI, MP ou MPx –, et les étudiants en
informatique à l’université. En plus des passionnés d’algorithmique, il intéressera tous les développeurs avancés souhaitant se
tourner vers un langage de programmation fonctionnel, tel que Scala, F#, Scheme, Lisp, etc.
Au sommaire
Programmation avec Ocaml. Environnements de travail. Compilateur et interprète • Premier programme avec
OCaml • Environnements de programmation • Installation de bibliothèques OCaml. Débuter avec OCaml en
programmant. Années bissextiles • Méthode de Monte-Carlo • Dessin d’une cardioïde • Ensemble de
Mandelbrot • Crible d’Ératosthène • Tracé de courbe • Copie d’un fchier • Renverser les lignes d’un texte • Conversion
d’entiers en base quelconque • Un casse-briques sans briques • Tortue Logo • Jouer une partition de musique
• Arbres quaternaires • Résoudre le problème des N reines. Approfondir les concepts d’OCaml. Algorithme
de typage • Modèle d’exécution • Analyser le temps d’exécution d’un programme. Structures de données.
Tableaux. Tableaux redimensionnables • Tableaux de bits • Cordes • Tableaux persistants. Ensembles et
dictionnaires. Arbres binaires de recherche • AVL • Tables de hachage • Arbres de préfxes • Arbres de Patricia. Files.
Files impératives • Files persistantes • Files de priorité impératives • Files de priorité persistantes. Graphes.
Matrice d’adjacence • Listes d’adjacence • Dictionnaire d’adjacence • Comparatif. Classes disjointes. Principe •
Réalisation. Le zipper. Zipper pour les listes • Zipper pour les arbres • Curseurs. Techniques algorithmiques et
applications. Arithmétique. Algorithme d’Euclide • Exponentiation rapide • Calcul modulo • Calcul matriciel.
Programmation dynamique et mémoïsation. Principe • Mémoïsation systématique • Différences entre
mémoïsation et programmation dynamique • Hash-consing. Algorithmes de tri. Tri par insertion • Tri rapide • Tri
fusion • Tri par tas • Complexité optimale • Évaluation expérimentale. Algorithmes sur les graphes. Parcours
en largeur • Parcours en profondeur • Plus court chemin • Arbre couvrant de poids minimal.
Tous les programmes de ce livre sont disponibles sur le site compagnon :
http://programmer-avec-ocaml.lri.fr/Apprendre
à programmer
avec OCaml Chez le même éditeur
Dans la même collection
Dans la collection Blanche
Dans la collection Design weB
autres ouvrages
Retrouvez aussi nos livres numériques sur
http://izibook.eyrolles.comSylvain Conchon et Jean-Chistophe Filliâtre
Apprendre
à programmer
avec OCaml
Algorithmes
et structures de donnéesÉDITIONS EYROLLES
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com
En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage,
sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre Français d’exploitation du droit de copie,
20, rue des Grands Augustins, 75006 Paris.
© Groupe Eyrolles, 2014, ISBN : 978-2-212-13678-4À nos épouses et nos fil lesSommair e
A v ant-pr opos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XI
P       
Pr ogr ammation a v ec OCaml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
C     
En vir onnements de tr a v ail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1 Compilateur et inter pr ète . . . . . . . . . . . . . . . . . . . . . 3
1.2 P r emier pr ogr amme a v ec O Caml . . . . . . . . . . . . . . . . . 4
1.3 En vir onnements de pr ogr ammat ion . . . . . . . . . . . . . . . 5
1.4 Instal lat ion de bibliothèques O Caml . . . . . . . . . . . . . . . 6
C     
Débuter a v ec OCaml en pr ogr ammant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1 Années bisse xt iles . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Métho de de Monte-Car lo . . . . . . . . . . . . . . . . . . . . 15
2.3 Dessin d ’une c ar dioïde . . . . . . . . . . . . . . . . . . . . . . 25
2.4 Ensemble de Mandelbr ot . . . . . . . . . . . . . . . . . . . . . 29
2.5 Cr ible d ’Ér atosthène . . . . . . . . . . . . . . . . . . . . . . . 36
2.6 T r a cé de cour b e . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.7 Copie d ’un fic hier . . . . . . . . . . . . . . . . . . . . . . . . . 53
2.8 Ren v erser les lignes d ’un te xte . . . . . . . . . . . . . . . . . . . 60
2.9 Con v ersion d ’ ent iers en base quelconque . . . . . . . . . . . . . 67
2.10 Un c asse-br iques sans br iques . . . . . . . . . . . . . . . . . . . 76Appr endr e à pr ogr ammer avec OCaml
VIII
2.11 T or t ue L og o . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
2.12 Jouer une par t it ion de m usique . . . . . . . . . . . . . . . . . . 95
2.13 Ar br es quater nair es . . . . . . . . . . . . . . . . . . . . . . . . 105
2.14 Résoudr e le pr oblème des N r eines . . . . . . . . . . . . . . . . 110
2.15 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
C     
Appr ofondir les concepts d’OCaml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
3.1 Alg or ithme de t y pag e . . . . . . . . . . . . . . . . . . . . . . . 135
3.2 Mo dèle d ’ e x écut ion . . . . . . . . . . . . . . . . . . . . . . . . 139
3.3 Anal y ser le temps d ’ e x écut ion
d ’un pr ogr amme . . . . . . . . . . . . . . . . . . . . . . . . . . 146
3.4 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
D      
Structur es de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
C     
T ableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
4.1 T ableaux r edimensionnables . . . . . . . . . . . . . . . . . . . 153
4.2 T de bits . . . . . . . . . . . . . . . . . . . . . . . . . . 159
4.3 Cor des . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
4.4 T ableaux p ersistants . . . . . . . . . . . . . . . . . . . . . . . . 184
4.5 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C     
Ensembles et dictionnair es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
5.1 Ar br es binair es de r ec her c he . . . . . . . . . . . . . . . . . . . 196
5.2 A VL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
5.3 T ables de ha c hag e . . . . . . . . . . . . . . . . . . . . . . . . . 214
5.4 Ar br es de pr éfix es . . . . . . . . . . . . . . . . . . . . . . . . . 224
5.5 Ar br es de P at r icia . . . . . . . . . . . . . . . . . . . . . . . . . 233
5.6 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245Sommair e
IX
C     
Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
6.1 F iles imp ér at iv es . . . . . . . . . . . . . . . . . . . . . . . . . 251
6.2 F iles p ersistantes . . . . . . . . . . . . . . . . . . . . . . . . . 256
6.3 F iles de pr ior ité imp ér at iv es . . . . . . . . . . . . . . . . . . . . 259
6.4 F iles de pr ior ité p ersistantes . . . . . . . . . . . . . . . . . . . 268
6.5 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
C     
Gr aphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
7.1 Mat r ice d ’a dja cence . . . . . . . . . . . . . . . . . . . . . . . . 279
7.2 Listes d ’a dja cence . . . . . . . . . . . . . . . . . . . . . . . . . 283
7.3 Dict ionnair e d ’a dja cence . . . . . . . . . . . . . . . . . . . . . 285
7.4 Compar at if . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
7.5 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
C     
Classes disjointes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
8.1 P r incip e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
8.2 Réalisat ion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
8.3 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
C     
Le zipper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
9.1 Z ipp er p our les listes . . . . . . . . . . . . . . . . . . . . . . . 305
9.2 Z ipp er p our les ar br es . . . . . . . . . . . . . . . . . . . . . . . 309
9.3 Curseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
9.4 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
T        
T echniques algorithmiques et applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
C     
Arithmétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
10.1 Alg or ithme d ’Euc lide . . . . . . . . . . . . . . . . . . . . . . . 325
10.2 E xp onent iat ion r apide . . . . . . . . . . . . . . . . . . . . . . 327
10.3 Calcul mo dulo . . . . . . . . . . . . . . . . . . . . . . . . . . . 328Appr endr e à pr ogr ammer avec OCaml
X
10.4 Calcul mat r iciel . . . . . . . . . . . . . . . . . . . . . . . . . . 331
10.5 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
C     
Pr ogr ammation d ynamique et mémoïsation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
11.1 P r incip e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
11.2 Mémoïsat ion sy stémat ique . . . . . . . . . . . . . . . . . . . . 344
11.3 Diff ér ences ent r e mémoïsat ion et pr ogr ammat ion dy namique . . 347
11.4 Hash-consing . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
11.5 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
C     
Algorithmes de tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
12.1 T r i par inser t ion . . . . . . . . . . . . . . . . . . . . . . . . . . 358
12.2 T r i r apide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
12.3 T r i fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
12.4 T r i par tas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
12.5 Comple xité opt imale . . . . . . . . . . . . . . . . . . . . . . . 380
12.6 Évaluat ion e xp ér imentale . . . . . . . . . . . . . . . . . . . . . 381
12.7 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
C     
Algorithmes sur les gr aphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
13.1 P ar cours en larg eur . . . . . . . . . . . . . . . . . . . . . . . . 394
13.2 P ar cours en pr of ondeur . . . . . . . . . . . . . . . . . . . . . . 396
13.3 P lus cour t c hemin . . . . . . . . . . . . . . . . . . . . . . . . . 399
13.4 Ar br e couv r ant de p oids minimal . . . . . . . . . . . . . . . . . 408
13.5 E x er cices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Bibliogr aphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425A v ant-pr opos
L’appr entissag e de la pr ogr ammatio n est difficile . Bien pr ogr ammer nécessite des
co nnaissances alg or ithmiques, de l’imaginatio n, de l’anticipatio n, la maîtr ise d ’un
langag e de pr ogr ammatio n, et sur tout beaucoup d ’ expér ience c ar les difficultés se
c a c hent souv ent dans les détails. Cet ouv r ag e sy nthétise nos expér iences à la f ois
de pr ogr ammeurs et d ’ enseignants en pr ogr ammatio n.
N ’ oublie z pas que le st y le de pr ogr ammatio n est essentiel. Dans un langag e do nné ,
le même alg or ithme peut êtr e écr it de m ultiples fa ço ns, et cer taines peuv ent êtr e
à la f ois élégantes et effic a ces. C ’ est cela que le pr ogr ammeur doit r ec her c her à
tout pr ix. C ’ est la r aiso n pour la quel le nous av o ns c hoisi d ’utiliser un langag e de
pr ogr ammatio n par ticulier plutôt que du pseudo-code . N otr e c hoix s’ est ainsi por té
sur le langag e O Caml.
Cet ouv r ag e est découpé en tr ois par ties. L a pr emièr e est une initiatio n au
langag e O Caml destinée aux débutants. I l peut s’agir autant de débutants en pr
ogr ammatio n, que de pr ogr ammeurs plus expér imentés qui ne co nnaissent pas
O Caml. À tr av ers des petits pr ogr ammes, le lecteur découv r e les co ncepts f o
ndamentaux de la pr ogr ammatio n et du langag e O Caml. L es deuxième et tr
oisième par ties so nt dédiées à la pr ésentatio n de co ncepts alg or ithmiques f o
ndamentaux pour per mettr e au lecteur d ’ écr ir e ses pr opr es pr ogr ammes, de manièr e
effic a ce et str uctur ée . L es co ncepts alg or ithmiques so nt pr ésentés dir ectement dans
la sy ntax e du langag e O Caml et tous les pr ogr ammes de cet ouv r ag e peuv ent êtr e
immédiatement r éutilisés.Appr endr e à pr ogr ammer avec OCaml
XII
À qui s’adr esse ce livr e
Ce liv r e s’a dr esse aux enseignants, étudiants et pr ogr ammeurs qui souhaitent
découv r ir ou utiliser effic a cement le langag e O Caml. P our les enseignants et les
étudiants, cet ouv r ag e peut ser vir de base à un cours de pr ogr ammatio n f o nctio nnel le
ou à un cours d ’alg or ithmique . En par ticulier , o n y tr ouv er a beaucoup de code et
de no mbr eux ex er cices. P our les pr ogr ammeurs O Caml, ce liv r e peut de v enir un
ouv r ag e de r éf ér ence dans lequel ils pourr o nt pioc her une str uctur e de do nnées ou
un alg or ithme spécifique .
Site compagnon associé au livr e
T ous les pr ogr ammes de ce liv r e o nt été co mpilés et testés av ec la v ersio n 4.01.0
d ’O Caml. I ls so nt dispo nibles à l’a dr esse suivante :
http://programmer- avec- ocaml.lri.fr/
Remer ciements
N ous r emer cio ns par ticulièr ement F r ançois P ottier pour av oir par ticipé aux
discussio ns r elativ es à la cr éatio n de cet ouv r ag e . N ous so mmes également tr ès r
eco nnaissant en v ers nos col lègues Ar thur Charguér aud et F r édér ic V oisin pour leur
r electur e soignée et co nstr uctiv e . N ous r emer cio ns également toutes les perso nnes
qui o nt co ntr ibué par leurs r electur es et leurs r emar ques : o mas Br aibant,
Martin Cloc har d, David Dec ler c k, L éo n Go ndelman, L ouis Mandel, S imã o Melo de
S ousa, Mattias Roux. Enfin, nous teno ns à saluer toute l’équipe des éditio ns
Eyr ol les pour so n aide pr écieuse dans la co nstr uctio n de ce liv r e .Pr emièr e partie
Pr ogr ammation a v ec
OCaml1
En vir onnements de
tr a v ail
L e langag e O Caml est dispo nible pour de no mbr eux sy stèmes d ’ exploitatio n
(Linux, Ma c OS , W indo ws, etc.), à l’a dr esse suivante :
http://caml.inria.fr/ocaml/release.fr.html
I l est également dispo nible à tr av ers les pr incipaux sy stèmes de pa quets ( apt-get,
port , yum , brew , etc.).
Une autr e fa ço n d ’ instal ler O Caml co nsiste à téléc harg er le g estio nnair e de pa quets
OP AM dispo nible à l’a dr esse suivante :
http://opam.ocaml.org
1.1 Compilateur et interpr ète
L e langag e O Caml pr opose deux co mpilateurs, ocamlc et ocamlopt, pour g énér er
r espectiv ement du code por table , indépendant des ar c hitectur es matér iel les, ou
du code natif (X86, ARM, etc.) plus effic a ce . On pourr a utiliser indiff ér emment
ces deux outils pour co mpiler les pr ogr ammes do nnés dans cet ouv r ag e . I l existePr emièr e partie : pr ogr ammation avec OCaml
4
également une v ersio n inter a ctiv e du langag e O Caml, le pr ogr amme ocaml, qui se
pr ésente sous la f or me d ’un inter pr éteur ( t op le v e l en anglais) ex écutant une bouc le
d ’ inter a ctio n lectur e-é valuatio n-affic hag e .
1.2 Pr emier pr ogr amme a v ec OCaml
N ous il lustr o ns l’utilisatio n de ces outils sur le pr emier pr ogr amme , inco
ntournable , qui co nsiste à affic her le messag e Hello world! à l’écr an. I l peut s’ écr ir e
ainsi :
let () = print string "Hello world!\n"
T el qu ’ il est do nné , ce pr ogr amme est co mplet (le c hapitr e suivant explique la
co nstr uctio n d ’un tel pr ogr amme). S’ il est co ntenu dans un fic hier hello.ml, o n
peut le co mpiler à par tir d ’un ter minal ¹ av ec le co mpilateur ocamlc de la manièr e
suivante :
> ocamlc hello.ml
On ex écute ensuite le binair e obtenu, à sav oir a.out, av ec le r ésultat esco mpté :
> ./a.out
Hello world!
S i o n le souhaite , o n peut do nner un autr e no m au binair e av ec l’optio n -o du
co mpilateur :
> ocamlc -o hello hello.ml
> ./hello
Hello world!
P our utiliser l’inter pr éteur , il suffit de taper la co mmande ocaml dans un ter
minal. L e pr ogr amme affic he alors une in vite ( pr ompt en anglais), matér ialisée par le
c ar a ctèr e # , in vitant l’utilisateur à entr er une expr essio n.
> ocaml
OCaml version 4.00.1
#
P our êtr e é valuée , l’expr essio n doit se ter miner par deux point-virgules ;; suivis
d ’un r etour-c har iot. A pr ès av oir v ér ifié que l’expr essio n est sy ntaxiquement
cor1. On suppose ici que le c he v r o n > désigne l’in vite du ter minal depuis lequel o n lance les co
mmandes.1 – Envir onnements de tr avail
5
r ecte et bien t y pée , le t op le v e l l’é value et affic he so n r ésultat. Ainsi, il suffit de
taper :
> ocaml
OCaml version 4.00.1
# let () = print_string "Hello world!\n";;
Hello world!
#
pour v oir s’affic her le messag e Hello world! à l’écr an.
En plus de so n r ésultat, le t op le v e l affic he également le t y pe inf ér é par O Caml pour
l’expr essio n saisie . P ar ex emple , si o n entr e l’expr essio n mathématique 1+4×2,
o n obtient la r épo nse suivante de l’inter pr éteur :
# 1 + 4 * 2;;
- : int = 9
#
qui indique que cette expr essio n est de t y pe int (le t y pe des entiers) et que so n
r ésultat est 9. P ar la suite , nous r epr ésenter o ns la bouc le d ’ inter a ctio n en color iant
av ec un f o nd gr is l’expr essio n entr ée par l’utilisateur et la r épo nse de l’inter pr éteur .
Ainsi, l’é valuatio n de l’expr essio n pr écédente ser a r epr ésentée de la manièr e
suivante :
# 1 + 4 * 2 ;;
- : int = 9
P our sor tir du t op le v e l, il faut taper la co mmande #quit de la manièr e suivante :
# #quit;;
>
P lus simplement, o n peut aussi taper sim ultanément sur les touc hes ctrl et D .
1.3 En vir onnements de pr ogr ammation
Co mme pour beaucoup d ’autr es langag es de pr ogr ammatio n, une fa ço n c lassique
de tr avail ler av ec O Caml co nsiste à utiliser so n éditeur pr éf ér é (Ema cs, g edit,
A quama cs, etc.) et, é v entuel lement, à le co nfigur er pour obtenir la color atio n sy
ntaxique spécifique à O Caml, le positio nnement sur err eur , etc.Pr emièr e partie : pr ogr ammation avec OCaml
6
P our auto matiser le pr ocessus de co mpilatio n, le plus simple est d ’utiliser l’outil
ocamlbuild f our ni av ec la distr ibutio n O Caml. Une autr e solutio n, av ec l’outil
GNU make, nécessite l’écr itur e d ’un fic hier de co nfigur atio n ( makefile) spécifique
à O Caml.
Une alter nativ e à ces solutio ns co nsiste à utiliser un en vir o nnement de dé v
eloppement intégr é (I DE). P ar ex emple , il existe un gr eff o n Ec lipse pour O Caml,
Oc aI DE, dispo nible à l’a dr esse suivante :
http://www.algo- prog.info/ocaide/
1.4 Installation de bibliothèques OCaml
I l existe de no mbr euses pour O Caml dé v eloppées par sa co mm
unauté d ’utilisateurs. L a fa ço n la plus simple de les instal ler est d ’utiliser le sy stème
de pa quets OP AM, qu ’ o n ait utilisé ou pas OP AM pour instal ler O Caml.
En vir onnements en ligne
I l existe également des solutio ns en ligne pour utiliser O Caml sans l’instal ler sur sa
ma c hine . Un ex emple est l’inter pr éteur en ligne T r yO Caml, dispo nible à l’a dr esse
suivante :
http://try.ocamlpro.com/2
Débuter a v ec OCaml
en pr ogr ammant
P ar ce qu ’ il n’y a r ien de mieux que de pr ogr ammer pour appr endr e un langag e de
pr ogr ammatio n, nous v ous pr oposo ns quator z e (petits) codes pour débuter av ec
O Caml. L eur but pr emier est d ’ intr oduir e les co nstr uctio ns et notio ns élémentair es
du langag e .
2.1 Années bissextiles
Notions intr oduites
• f or me g énér ale d ’un pr ogr amme
• co nstr uctio n let
• appel de f o nctio n
• t y pes de base (int, bool , string )
• bibliothèques (Printf, Sys, etc.), sy stème de modules, dir ectiv e open
• a ccès aux arguments d ’un pr ogr amme (Sys.argv)
• a ccès aux éléments d ’un tableau (notatio n t.(i))Pr emièr e partie : pr ogr ammation avec OCaml
8
Pr ogr amme 1 [leap year.ml] — Année bissextile
let year = read int ()
let leap =
(year mod 4 = 0 && year mod 100 <> 0) || year mod 400 = 0
let msg = if leap then "is" else "is not"
let () = Printf.printf "%d %s a leap year\n" year msg
N otr e pr emier pr ogr amme , leap year.ml, déter mine si une année est ou no n
bissextile . On peut le co mpiler en utilisant ocamlc .
> ocamlc -o leap_year leap_year.ml
Une f ois lancé , le pr ogr amme attend que l’o n saisisse une année sur l’entr ée
standar d, puis indique s’ il s’agit d ’une année bissextile .
> ./leap_year
2013
2013 is not a leap year
Expliquo ns maintenant la str uctur e de ce pr ogr amme . L a pr emièr e ligne du pr
ogr amme lit un entier sur l’entr ée standar d :
let year = read int ()
À el le seule , cette ligne co ntient plusieurs notio ns du langag e O Caml. El le corr
espo nd tout d ’abor d à une déclar ation de v ar iab le de la f or me :
let year = ...
Cela a pour eff et d ’ initialiser une (nouv el le) var iable year av ec le r ésultat de
l’é valuatio n de l’expr essio n à dr oite du sy mbole =. N oto ns que le t y pe de la var iable
year n’a pas besoin d ’ êtr e déc lar é : il est auto matiquement déduit par le co
mpilateur ou l’inter pr éteur . L’expr essio n à dr oite du sy mbole = est un a pp e l de f onction.
I l s’agit ici de l’appel à la f o nctio n pr édéfinie read int.
... = read int ()
Ici, () indique que la f o nctio n read int ne r eçoit pas d ’argument signific atif ; el le
ne fait que r en v o y er un entier , lu sur l’entr ée standar d.
L a deuxième ligne intr oduit une var iable booléenne leap qui est v r aie si et
seulement si l’année year est bissextile , c ’ est-à-dir e si el le est divisible par 4 mais pas
par 100, ou si el le est divisible par 400.2 – Débuter avec OCaml en pr ogr ammant
9
let leap =
(year mod 4 = 0 && year mod 100 <> 0) || year mod 400 = 0
L’opér ateur infix e mod do nne le r este de la divisio n entièr e . L es opér ateurs && et ||
r epr ésentent r espectiv ement le E T et le O U booléens. De même que pour year , le
t y pe de la var iable leap est d éduit auto matiquement. L a ligne suivante intr oduit
une tr oisième var iable msg co ntenant une c haîne de c ar a ctèr es :
let msg = if leap then "is" else "is not"
L a var iable msg co ntiendr a do nc la c haîne "is" (les c haînes de c ar a ctèr es so nt
délimitées par des guil lemets " ) si leap est v r aie e t la c haîne "is not" sino n. On
r emar que que la co nstr uctio n if-then - else est utilisée ici pour co nstr uir e une
expr essio n, à sav oir une c haîne de c ar a ctèr es.
Enfin, la der nièr e ligne affic he un messag e qui indique si l’année passée en par
amètr e est ou no n bissextile .
let () = Printf.printf "%d %s a leap year\n" year msg
L’affic hag e est r éalisé par un appel à la f o nctio n de bibliothèque Printf.printf
av ec tr ois arguments : une c haîne de f or matag e "%d %s a leap year\n" et deux
valeurs year et msg qui se substituer o nt r espectiv ement à %d et %s dans le messag e
impr imé . Co mme o n le v oit, l’appel de f o nctio n se note par une simple
juxtapositio n de la f o nctio n et de ses arguments. Co ntr air ement à d ’autr es langag es, o n
n’utilise pas de par enthèses autour des arguments.
... = Printf.printf "%d %s a leap year\n" year msg
N ous r en v o y o ns le lecteur au manuel d ’O Caml pour plus d ’ inf or matio n sur la
bibliothèque , et notamment sur la f o nctio n printf du module Printf. L e manuel
peut êtr e co nsulté en ligne à l’a dr esse http://caml.inria.fr/pub/docs/. N oto ns
enfin que l’appel à la f o nctio n printf est co ntenu dans une déc lar atio n av ec la
f or me par ticulièr e :
let () = ...
El le est quelque peu énigmatique pour le mo ment, mais ser a expliquée lorsque
nous abor der o ns la tec hnique de filtr ag e dans les sectio ns 2.6 T r a cé de courb e et
2.12 Joue r une p ar tition de musique. Diso ns pour le mo ment que , d ’une manièr e
g énér ale , un pr ogr amme O Caml est une suite de déc lar atio ns, qui so nt é valuéesPr emièr e partie : pr ogr ammation avec OCaml
10
de haut en bas, c ’ est-à-dir e dans l’or dr e dans leq uel el les appar aissent dans le
fic hier sour ce . Co ntr air ement à des langag es co mme C ou Java, il n’y a pas de point
d ’ entr ée de t y pe main. Cette déc lar atio n par ticulièr e let () = ... est utilisée pour
co nser v er cette f or me de pr ogr amme , y co mpr is pour les mor ceaux de pr ogr amme
qui ne r en v oient pas de valeur . O Caml v ér ifie même dans ce c as que l’expr essio n
n’a eff ectiv ement pas de valeur .
Compléments d’information
La ligne de commande
P lutôt que de lir e l’année sur l’entr ée standar d du pr ogr amme , o n peut c hoisir de
la passer sur la ligne de co mmande . Dans ce c as, le pr ogr amme est in v oqué de la
manièr e suivante :
> ./leap_year 2013
2013 is not a leap year
P our cela, o n r empla ce la ligne let year = read int () par la ligne :
let year = int of string Sys.argv.(1)
I l s’agit de l’appel à la f o nctio n pr édéfinie int of string av ec Sys.argv.(1)
co mme argument. L a valeur Sys.argv.(1) corr espo nd à l’année passée en par
amètr e sur la ligne de co mmande . D’une manièr e similair e à d ’autr es langag es de
pr ogr ammatio n ( Java ou C par ex emple), o n r écupèr e les valeurs passées au pr
ogr amme sous la f or me d ’un tableau de c haînes de c ar a ctèr es, désigné par Sys.argv
en O Caml. P our êtr e plus pr écis, ce tableau se no mme argv et il est a ccessible
depuis la bibliothèque Sys qui off r e des f o nctio nnalités d ’ inter fa ce av ec le sy stème
d ’ exploitatio n. L a notatio n Sys.argv utilise le s yst ème de mo dules d ’O Caml qui
découpe les bibliothèques en unités, appelées modules, qui r egr oupent eux-mêmes
diff ér entes valeurs. S ans r entr er tr op dans les détails de ce sy stème de modules
(nous do nner o ns plus de pr écisio n dans la sectio n 2.11 T or t ue log o en par ticulier), il
suffit pour le mo ment de sav oir que l’o n utilise une valeur d ’un module en pr éfixant
le no m de cette valeur av ec le no m du module suivi d ’un point. Ainsi, Sys.argv
doit se lir e co mme « le tableau argv qui appar tient au module Sys ».
On utilise la notatio n t.(i) pour a ccéder au i-ème élément d ’un tableau t. N ous
r e viendr o ns plus en détail sur la notio n de tableaux à la sectio n 2.5 Cr ib le d ’Ér at
osthène . L e pr emier élément de Sys.argv, c ’ est-à-dir e Sys.argv.(0) c ar les tableaux
so nt index és à par tir de 0, est le no m du pr ogr amme (ici leap year ). L e seco nd élé-2 – Débuter avec OCaml en pr ogr ammant
11
ment, à sav oir Sys.argv.(1), est le pr emier par amètr e passé au pr ogr amme ( 2013
dans notr e ex emple). Co mme il s’agit d ’une c haîne de c ar a ctèr es, o n la co n v er tit
en un entier av ec un appel à la f o nctio n int of string. Cette der nièr e appar tient
à la bibliothèque Pervasives, une bibliothèque par ticulièr e pour la quel le il n’est
pas nécessair e d ’ écr ir e Pervasives.f .
T ypage
N ous co mpléto ns nos explic atio ns en do nnant quelques détails supplémentair es
sur les t y pes de do nnées intr oduits dans ce pr emier pr ogr amme . Bien que les t y pes
des var iables soient c alculés auto matiquement, il est possible de les fair e affic her
par le co mpilateur , gr â ce à so n optio n -i :
> ocamlc -i leap_year.ml
val year : int
val leap : bool
val msg : string
On v oit ainsi que les var iables year , leap et msg so nt r espectiv ement de t y pes int,
bool et string. I l s’agit ici de tr ois t y pes pr édéfinis d ’O Caml. Détail lo ns ces tr ois
t y pes, ainsi que les t y pes similair es, en nous ser vant du t op le v e l.
T ypes int, int32 et int64
Co mmenço ns par le t y pe int corr espo ndant aux entiers natif s de la ma c hine . Une
co nstante entièr e peut êtr e écr ite en décimal, e n binair e (pr éfix e 0b ), en octal (pr
éfix e 0o ) ou encor e en hexa décimal (pr éfix e 0x). Ainsi, la co nstante décimale 91
s’ écr it 0b1011011 en binair e , 0o133 en octal et 0x5B en hexa décimal.
L es opér atio ns usuel les sur le t y pe int so nt l’a dditio n ( + ), la soustr a ctio n ( -), la
m ultiplic atio n ( * ), la divisio n euc lidienne (/) et so n r este ( mod).
# 2 * (7 / 2) + 7 mod 2;;
- : int = 7
P our gagner en c lar té , les c hiff r es peuv ent êtr e sépar és par des c ar a ctèr es soulignés
( ).
# 0x2f ff ff ff + 268 435 456;;
- : int = 1073741823Pr emièr e partie : pr ogr ammation avec OCaml
12
L a pr écisio n du t y pe int dépend de l’ar c hitectur e de la ma c hine . L es valeurs
minimale et maximale du t y pe int so nt do nnées par les deux co nstantes min int et
max int.
# min int;;
- : int = -1073741824
S ur une ma c hine 32 bits, les valeurs de t y pe int so nt codées sur 31 bits signés ¹,
30 30d ’ où les valeurs−2 et 2 − 1 de min int et max int. S ur une ma c hine 64 bits,
le t y pe int est codé sur 63 bits signés. L a r epr ésentatio n ma c hine des entiers,
en co mplément à deux, peut êtr e explicitement manipulée à l’aide d ’ opér atio ns de
déc alag e ( lsl, lsr et asr) et d ’ opér atio ns bit-à-bit ( land , lor , lxor et lnot). P ar
ex emple , o n peut tester le cinquième bit de la r epr ésentatio n de l’entier 42 av ec :
# 42 land (1 lsl 5);;
- : int = 32
P our manipuler explicitement des entiers 32 ou 64 bits signés, O Caml f our nit
deux t y pes spécifiques int32 et int64. L es co nstantes entièr es de t y pe int32 (r esp .
int64) s’ écr iv ent av ec le suffix e l (r esp . L).
# 123l;;
- : int32 = 123l
# 10 000 000 000 000L;;
- : int64 = 10000000000000L
L es opér atio ns ar ithmétiques sur ces deux t y pes so nt f our nies dans les
bibliothèques Int32 et Int64 d ’O Caml.
T ype bool
L e t y pe bool r epr ésente les valeurs booléennes, à sav oir v r ai ( true) et faux ( false).
L es opér atio ns sur le t y pe bool so nt la co njo nctio n ( && ), la disjo nctio n ( ||) et la
négatio n ( not).
# not true && false || true ;;
- : bool = true
1. Un bit est utilisé par le sy stème de g estio n auto matique de la mémoir e d ’O Caml ; v oir la
sectio n 3.2 Mo dè le d ’ e x écution du c hapitr e 3.2 – Débuter avec OCaml en pr ogr ammant
13
L a négatio n a la pr ior ité la plus f or te , de vant la co njo nctio n puis la disjo nctio n. L a
p hr ase pr écédente se lit do nc co mme :
# ((not true ) && false) || true;;
- : bool = true
L’or dr e d ’ é valuatio n des opér atio ns && et || est fix é de gauc he à dr oite . De plus,
le seco nd argument n’est é valué que si nécessair e , c ’ est-à-dir e uniquement si le
pr emier est v r ai (r esp . faux) pour l’opér atio n && (r esp . ||). Ce so nt les
seules opér atio ns pour lesquel les l’or dr e d ’ é valuatio n soit spécifié . De même , ce
so nt les seules opér atio ns pour lesquel les l’é n soit par esseuse .
L es opér atio ns de co mpar aiso n = , <>, <, > , <= ou >= r en v oient un booléen.
# 1 < 2 && 3 = 4;;
- : bool = false
L es expr essio ns booléennes so nt essentiel lement utilisées dans la co nstr uctio n
co nditio nnel le if e1 then e2 else e3 qui é value , soit l’expr essio n e2, soit
l’expr essio n e3, selo n que l’expr essio n e1 est v r aie ou fausse .
# if 1 < 2 then 3 else 4;;
- : int = 3
Co mme o n le v oit sur cet ex emple , la co nstr uctio n if then else est une expr essio n
co mme une autr e . En par ticulier , pou r que cette expr essio n soit bien t y pée , les deux
br anc hes e2 et e3 doiv ent av oir le même t y pe ; c ’ est alors le t y pe de l’expr essio n
toute entièr e .
T ypes char et string
L es c ar a ctèr es so nt r epr ésentés par le t y pe char. Un c ar a ctèr e se note entr e
apostr op hes, co mme 'a'. L es c ar a ctèr es no n impr imables so nt saisis av ec une notatio n
de la f or me '\c' oùc peut êtr e un c ar a ctèr e (n, r, t, \) ou un code ASCI I (entr e
0 et 255) écr it sur tr ois c hiff r es décimaux ( \ddd) ou deux c hiff r es hexa décimaux
(\xdd).Pr emièr e partie : pr ogr ammation avec OCaml
14
# 'a';;
- : char = 'a'
# '\n';;
- : char = '\n'
# '\\';;
- : char = '\\'
# '\126';;
- : char = '˜'
# '\x7E';;
- : char = '˜'
On peut passer d ’un c ar a ctèr e à so n code ASCI I et in v ersement à l’aide des f o
nctio ns Char.code et Char.chr de la bibliothèque Char .
L es c haînes de c ar a ctèr es so nt r epr ésentées par le t y pe string. Une c haîne se
note entr e guil lemets, co mme "abc". L es c ar a ctèr es no n impr imables d ’une c haîne
peuv ent êtr e saisis av ec la même sy ntax e que pour le t y pe char.
# "a";;
- : string = "a"
# "hello world\n";;
- : string = "hello world\n"
# "";;
- : string = ""
# "abc\126def";;
- : string = "abc˜def"
Co mme o n le v oit sur cet ex emple , la c haîne "a" n’a pas le même t y pe que le
c ar a ctèr e 'a'. De manièr e g énér ale , il n’y a pas de co n v ersio n entr e ces deux t y pes.
On a ccède au i-ième c ar a ctèr e de la c haîne s av ec la notatio n s .[i ], le pr emier
c ar a ctèr e a yant l’indice 0.
# "abc".[1];;
- : char = 'b'
L a lo ngueur d ’une c haîne est do nnée par la f o nctio n String.length de la
bibliothèque String . Enfin, deux c haînes peuv ent êtr e co nc aténées av ec l’opér ateur ˆ.
# String.length ("abc" ˆ "def");;
- : int = 62 – Débuter avec OCaml en pr ogr ammant
15
N ous r en v o y o ns le lecteur au manuel d ’O Caml pour d e plus amples inf or matio ns
sur les bibliothèques pr ésentées dans ce c hapitr e .
Entr ées-sorties
L es f o nctio ns d ’ entr ées-sor ties les plus simples so nt cel les qui per mettent d
’affic her les valeurs des t y pes de base , co mme print string déjà utilisée plus haut
pour hello world. On tr ouv e également print char, print int et print float,
ainsi que print newline pour affic her un r etour-c har iot et print endline pour
affic her une c haîne suivie d ’un r etour-c har iot. Ces six f o nctio ns d ’affic hag e écr iv ent
sur la sor tie standar d ; pour écr ir e sur la sor tie d ’ err eur , il existe six autr es f o
nctio ns prerr char , prerr string, etc. De même , o n dispose de f o nctio ns pour
lir e sur l’entr ée standar d, à sav oir read int, read float et read line et il existe
une var iante de la f o nctio n printf pour écr ir e sur la sor tie d ’ err eur , à sav oir
Printf.eprintf. On tr ouv er a plus de détails sur les entr ées-sor ties dans la
sectio n 2.7 Copie d ’un fic hie r.
2.2 Méthode de Monte-Carlo
Notions intr oduites
• eff ets de bor d, séquences d ’ instr uctio ns, r éf ér ences (mot-c lé ref)
• var iables loc ales (co nstr uctio n let- in)
• bouc les for
• no mbr es flottants (t y pe float)
• bibliothèque de no mbr es aléatoir es Random
N otr e deuxième pr ogr amme (v oir pag e 17), approx pi.ml, c alcule expér
imentalement la valeur deπ en utilisant la méthode de Mo nte-Car lo. El le co nsiste à tir er
des points au hasar d dans un c arr é de côté 1, do nt l’air e vaut do nc 1, et à co mpter
le no mbr e de ces points qui to mbent dans le quar t de cer c le de r a y o n 1 inscr it dans
ce c arr é , do nt l’air e vautπ/4 . L a figur e 2.1 il lustr e cette idée .
On co mpile approx pi.ml en utilisant par ex emple ocamlopt (pour plus d ’ effic
acité), de la manièr e suivante :
> ocamlopt -o approx_pi approx_pi.mlPr emièr e partie : pr ogr ammation avec OCaml
16
Figur e 2.1
Calcul de π par la méthode de Monte-Carlo
On l’ex écute en lui do nnant le no mbr e de points à tir er . S i ce no mbr e est asse z éle v é ,
la pr opor tio n de points co ntenus dans le quar t de cer c le appr oc he le r appor t de
l’air e du quar t de cer c le sur l’air e du c arr é , c ’ est-à-dir eπ/4 . On obtient les r ésultats
suivants :
> ./approx_pi
500
3.136000
> ./approx_pi
5000
3.113600
> ./approx_pi
50000
3.149920
> ./approx_pi
500000
3.142184
Cette méthode ne per met cependant pas d ’ espér er plus de quelques décimales.
Ainsi, av ec 10 mil lio ns de points, o n n’obtient g énér alement que 3 décimales
corr ectes.
Co mme pour notr e pr emier pr ogr amme , la pr emièr e ligne de approx pi.ml r
écupèr e le no mbr e n de points à tir er en lisant un entier sur l’entr ée standar d :
let n = read int ()2 – Débuter avec OCaml en pr ogr ammant
17
Pr ogr amme 2 [approx pi.ml] — Appr oximation deπ
let n = read int ()
let () =
let p = ref 0 in
for k = 1 to n do
let x = Random.float 1. in
let y = 1. in
if x *. x +. y *. y <= 1. then
p := !p + 1
done;
let pi = 4. *. float !p /. float n in
Printf.printf "%f\n" pi
L e r este du pr ogr amme utilise une bouc le pour tir er n points au hasar d. À c ha que
tour de bouc le , o n incr émente le co ntenu d ’une var iable (initialisée à 0) si le point
tir é to mbe dans le quar t de cer c le de r a y o n 1. À la fin, o n affic he la valeur appr oc hée
deπ , qui est égale à quatr e f ois le r appor t du no mbr e de points to mbés dans le quar t
de cer c le au no mbr e de points total.
Cette fa ço n de c alculer par modific atio n du co ntenu d ’une var iable s’appel le le
c alcul par e ff et de b or d . P lus g énér alement, ce ter me est utilisé pour par ler d ’une
expr essio n qui ne r end pas de valeur apr ès av oir été é valuée . Co mme nous l’av o ns
dit dans la sectio n pr écédente , o n utilise une déc lar atio n de la f or me let () = ...
pour é valuer de tel les expr essio ns.
L a suite du pr ogr amme est do nc co ntenue dans l’expr essio n qui suit le sy mbole =
et co mmence par initialiser une var iable p à l’aide d ’une déc lar atio n de la f or me :
let p = ... in
...
Cette déc lar atio n intr oduit une v ar iab le lo c ale do nt l’utilisatio n, ou la p or t ée , est
r estr einte à l’expr essio n qui suit le mot -c lé in. Ce g enr e de déc lar atio n est utile
lorsqu ’ o n v eut r estr eindr e la visibilité d ’une var iable , soit pour s’assur er qu ’ el le n’est
pas utilisée à n’impor te quel endr oit du pr ogr amme , soit par ce que l’o n souhaite
occulter tempor air ement la visibilité d ’une var iable de même no m.Pr emièr e partie : pr ogr ammation avec OCaml
18
L a var iable p est initialisée av ec une r é f é r ence , c ’ est-à-dir e une c ase mémoir e do nt
le co ntenu peut êtr e modifié , qui co ntient initialement la valeur 0. Cette r éf ér ence
va êtr e utilisée pour co mpter le no mbr e de points appar tenant au quar t de cer c le .
let p = ref 0 in
...
L a cr éatio n de p se fait en appelant la f o nctio n pr édéfinie ref (définie dans la
bibliothèque Pervasives) av ec l’entier 0 co mme argument. L’applic atio n de cette f o
nctio n a pour eff et d ’al louer une nouv el le c ase mémoir e et d ’ initialiser so n co ntenu
av ec 0. L e t y pe des r éf ér ences por te le même no m que la f o nctio n utilisée pour les
cr éer . Ainsi, le t y pe de p inf ér é par O Caml est int ref , c ’ est-à-dir e le t y pe d ’« une
r éf ér ence co ntenant une valeur de t y pe int ».
L a ligne suivante intr oduit une b oucle for qui é value n f ois l’expr essio n située entr e
les mots-c lés do et done en faisant var ier le co ntenu d ’une var iable k de 1 à n :
for k = 1 to n do
...
done
L a var iable k est l’indice de la bouc le et l’expr essio n entr e do et done est le cor ps de
la bouc le. L’indice k est initialisé av ec la valeur 1 puis le cor ps est é valué : c ’ est le
pr emier tour de bouc le . P uis k est incr émenté et le cor ps est de nouv eau é valué :
c ’ est le deuxième tour de bouc le . Et ainsi de suite . L a bouc le se ter mine apr ès
l’é valuatio n du cor ps de la bouc le pour k valant n.
L’expr essio n du cor ps de bouc le co mmence par tir er au hasar d un point de
coordo nnées (x, y) dans le c arr é de côté de lo ngueur 1.
let x = Random.float 1. in
let y = 1. in
P our cela, deux var iables loc ales x et y so nt initialisées par deux appels à la f o nctio n
Random.float av ec le no mbr e à virgule flottante (ou simplement appelé no mbr e
flott ant ) 1 co mme argument. Cha cun de ces appels r en v oie un no mbr e flottant
entr e 0 inc lus et 1 ex c lu. Co mme nous le v err o ns plus loin, O Caml fait une
distinctio n f or te entr e ces no mbr es flottants, de t y pe float , et les no mbr es entiers de
t y pe int. En par ticulier , il faut ajouter un point apr ès le c hiff r e 1 pour r epr ésenter
le no mbr e flottant 1 .2 – Débuter avec OCaml en pr ogr ammant
19
L e test qui suit incr émente le co ntenu de la r éf ér ence p si le point( x, y) appar tient
2 2au quar t de cer c le , c ’ est-à-dir e si x + y ≤ 1.
if x *. x +. y *. y <= 1. then
p := !p + 1
Co mme o n le v oit dans l’expr essio n x *. x +. y *. y, l es opér ateurs ar
ithmétiques sur les flottants so nt également distingués s ynt axiquement des opér ateurs
sur les entiers : il faut ajouter un point . apr ès c ha que sy mbole + , -, etc. Ainsi, +.
est l’opér ateur d ’a dditio n sur les flottants, *. la m ultiplic atio n, etc. En r e vanc he ,
o n utilise le même opér ateur <= pour co mpar er des flottants et des entiers (v oir
c hapitr e 3 pour plus de détails sur ces opér ateurs de co mpar aiso n).
L’incr émentatio n de la r éf ér ence p est r éalisée par l’expr essio n p := !p + 1.
L’opér ateur d ’aff ectatio n := per met de modifier le co ntenu d ’une r éf ér ence . P our
a ccéder au co ntenu d ’une r éf ér ence , o n utilise l’opér ateur unair e de dé r é f é r
encement ! en positio n de pr éfix e . Ainsi, si p est une r éf ér ence de t y pe int ref, la
valeur !p est de t y pe int. L a bouc le se ter mine apr ès l’ex écutio n du cor ps pour
k valant n . On enc haîne alors l’é valuatio n de la bouc le av ec l’expr essio n qui suit
l’opér ateur ;
for k = 1 to n do
...
done ;
Cet enc haînement est appelé une séquence d ’ expr essio ns. P our qu ’une séquence soit
a cceptée par O C aml, il faut que l’expr essio n située avant le point-virgule ne r ende
pas de valeur , c ’ est-à-dir e qu ’ el le ne fasse que des eff ets de bor d.
L a déc lar atio n qui suit la bouc le for définit une var iable loc ale pi co ntenant
l’appr o ximatio n deπ .
let pi = 4. *. float !p /. float n in
Afin de c alculer une divisio n sur no mbr es flottants, o n co n v er tit les valeurs
entièr es !p et n en flottants à l’aide de la f o nctio n float (définie dans la bib liothèque
Pervasives). Enfin, o n affic he l’appr o ximatio n de π ainsi c alculée à l’aide de la
f o nctio n Printf.printf : "%f\n" piPr emièr e partie : pr ogr ammation avec OCaml
20
De même que nous avio ns utilisé %d dans une c haîne de f or matag e pour affic her
un entier , o n utilise ici %f pour affic her un flottant.
Compléments d’information
N ous co mpléto ns nos explic atio ns en do nnant quelques détails supplémentair es
sur les notio ns intr oduites dans ce deuxième pr ogr amme .
T ype float
L es no mbr es r éels (ou à virgules) so nt r epr ésentés en ma c hine à l’aide d ’un codag e
par ticulier qu ’ o n appel le nombr es à virgule flott ant e, ou plus simplement no mbr es
flott ants. En O Caml, le codag e des no mbr es flottants est le standar d I E E E 754 à
double pr écisio n (64 bits) ; il n’y a pas de flottants simple pr écisio n en O Caml.
Co mme nous l’av o ns dit pr écédemment, le t y pe d es no mbr es flottants est float.
Une co nstante de t y pe float est écr ite soit av ec un point décimal, co mme 3.14 ,
soit en notatio n scientifique , co mme 6.02214e23. Dans la notatio n décimale , la
pr ésence du point est obligatoir e , pour fair e une distinctio n av ec le t y pe int. Dans
la notatio n scientifique , en r e vanc he , le point n’est pas obligatoir e .
# 3 ;;
- : int = 3
# 3. ;;
- : float = 3.
# 1e6 ;;
- : float = 1000000.
L es opér atio ns sur le t y pe float so nt distinctes de cel les sur le t y pe int . El les so nt
suivies d ’un point qui r appel le celui des flottants ( +., -., *. et /. ). À la diff ér ence
d ’autr es langag es, les opér atio ns ar ithmétiques por tent des no ms diff ér ents, selo n
qu ’ il s’agit d ’ entiers ou des flottants, et il n’y a pas no n plus de co n v ersio n implicite
entr e les t y pes int et float.
# 2 +. 3.14;;
Error: This expression has type int but an expression was
expected of type float
I l faut utiliser les f o nctio ns de co n v ersio n float et truncate pour passer r
espectiv ement des entiers aux flottants et in v ersement.2 – Débuter avec OCaml en pr ogr ammant
21
# 3.14 /. float 2;;
- : float = 1.57
# truncate 3.141592;;
- : int = 3
De no mbr euses opér atio ns so nt dispo nibles sur le t y pe float dans la bibliothèque
Pervasives, co mme l’expo nentiatio n **, la r a cine c arr ée sqrt , les f o nctio ns tr
ig o no métr iques, logar ithmiques, etc. Ainsi, o n peut c alculer la valeur d e π , no n
pr édéfinie en O Caml, av ec l’expr essio n suivante :
# 4. *. atan 1.;;
- : float = 3.14159265358979312
Co ntr air ement au t y pe int, le t y pe float co ntient par ail leurs tr ois valeurs
particulièr es neg infinity, infinity et nan, qui r epr ésentent les r ésultats de c alculs
sans signific atio n.
# -1. /. 0.;;
- : float = neg infinity
# 1. /. 0.;;
- : float = infinity
# 0. /. 0.;;
- : float = nan
À la diff ér ence d ’autr es langag es, O Caml ne f our nit qu ’un seul t y pe de flottants
qui désigne des no mbr es en double pr écisio n (64 bits) co nf or mes à la nor me I E E E
754. L es flottants so nt co mpr is entr e une valeur minimale min float et une valeur
maximale max float.
# min float;;
- : float = 2.22507385850720138e-308
# max float;;
- : float = 1.79769313486231571e+308
Constructions let et let-in
L es co nstr uctio ns let et let- in définissent r espectiv ement des var iables globales et
loc ales. Deux points impor tants mér itent d ’ êtr e soulignés co ncer nant les var iables :
• Une var iable est nécessair ement initialisée .
• L e t y pe d ’une var iable est inf ér é auto matiquement.Pr emièr e partie : pr ogr ammation avec OCaml
22
L e pr emier point r ésulte simplement du fait que les var iables peuv ent uniquement
êtr e définies à l’aide des co nstr uctio ns let et let- in, do nt la sy ntax e exig e une
expr essio n d ’ initialisatio n. L e deuxième point est une des spécificités du langag e
O Caml.
On peut utiliser le t op le v e l pour co nnaîtr e le t y pe inf ér é pour une var iable . Ainsi,
lorsque l’o n tape la déc lar atio n :
# let x = 1+2;;
L’inter pr éteur affic he la r épo nse :
val x : int = 3
El le indique que l’o n a intr oduit une var iable globale x initialisée av ec l’entier 3.
L e t y pe de x est celui inf ér é pour l’expr essio n 1+2, c ’ est-à-dir e int.
I l est également impor tant de bien maîtr iser la r è gle de p or t ée des var iables déc lar ées
par une co nstr uctio n let ou let-in. L a por tée d ’une var iable globale x co mmence
juste apr ès la déc lar atio n let x = ... qui l’a définie et s’ étend jusqu ’à la fin du pr
ogr amme . L a por tée d ’une var iable loc ale intr oduite av ec la co nstr uctio n let-in est
limitée à l’expr essio n qui suit le mot-c lé in. Ainsi, les tr ois déc lar atio ns suivantes
pr o v oquent des err eurs de por tée :
# let x = x + 1;;
Error: Unbound value x
# (let v = 1 + 2 in v * v) + v ;;
Error: Unbound value v
# let z = 1 + z in z * 2;;
Error: Unbound value z
L es tr ois déc lar atio ns pr écédentes il lustr ent une r ègle impor tante sur l’utilisatio n
des var iables : pour êtr e utilisée , une var iable doit av oir été déc lar ée au pr éalable .
Ainsi, le pr ogr amme suivant est corr ect :
let x = 10
let y = x+2
En r e vanc he , celui-ci ne l’est pas :
let y = x+2
let x = 102 – Débuter avec OCaml en pr ogr ammant
23
I l est impor tant de r emar quer que dans l’expr essio n let x = e1 in e2; e3, la
por tée de la var iable x s’ étend à toute l’expr essio n e2; e3 . En eff et, la pr ior ité de
l’opér ateur ; est plus f or te que cel le de la co nstr uctio n let. Dit autr ement, cette
expr essio n doit se lir e co mme let x = e1 in (e2; e3). L e pr ogr amme 2 utilise
cette r ègle de por tée dans la déc lar atio n de la var iable loc ale p.
let () =
let p = ... in
for k = 1 to n do
...
p := !p + 1
done;
let pi = 4. *. float !p /. float n in
...
Ainsi, la var iable p est visible dans la bouc le for ainsi que dans le cor ps de la
déc lar atio n de la var iable pi .
On peut utiliser le même no m pour plusieurs var iables, y co mpr is pour des t y pes
diff ér ents. L’utilisatio n d ’une var iable x fait toujours r éf ér ence à la déc lar atio n la
plus pr oc he . P r eno ns par ex emple le pr ogr amme suivant :
let x = 10
let y = x + 2
let x = 20
let () = Printf.printf "x=%d y=%d\n" x y
L a déc lar atio n let x = 20 définit une nouv e lle var iable x, qui c a c he la por tée de
l’ancienne . L e messag e affic hé quand o n e x écute le pr ogr amme est do nc x=20 y=12.
Boucle for
Co mme nous l’av o ns vu d ans notr e ex emple , les bouc les for so nt utilisées pour
é valuer un cer tain no mbr e de f ois une expr essio n do nnée . El les o nt la f or me
suivante :Pr emièr e partie : pr ogr ammation avec OCaml
24
for i = e to e do1 2
e
done
L’indice de la bouc le , la var iable i , est intr oduite par la co nstr uctio n for . S a valeur
n’est pas modifiable par l’utilisateur . S a por tée est limitée au cor ps de la bouc le
(l’expr essio n e) et el le n’est do nc pas utilisable dans les expr essio ns e et e . L es1 2
expr essio nse ete so nt é valuées une seule f ois, avant l’ex écutio n de la bouc le . On1 2
peut l’obser v er expér imentalement av ec le pr ogr amme suivant :
let () =
for i = (Printf.printf "*"; 0) to (Printf.printf "."; 5) do
Printf.printf "%d" i
done
L or qu ’ o n l’ex écute , ce pr ogr amme affic he la suite de c ar a ctèr es *.012345. En
eff et, l’é valuatio n de la bouc le for co mmence par l’initialisatio n de l’indice i av ec
l’expr essio n (Printf.printf "*"; 0). L’é valuatio n de cette séquence co nduit tout
d ’abor d à affic her le sy mbole *, puis à r en v o y er l’entier 0 . L e deuxième c ar a ctèr e
affic hé étant le point ., cela signifie que l’expr essio n (Printf.printf "."; 5) pour
la valeur de l’indice final est ensuite é valuée . L e r este du messag e n’étant co nstitué
que des c hiff r es affic hés par l’expr essio n Printf.printf "%d" i du cor ps de bouc le ,
o n en déduit que les expr essio ns e et e ne so nt plus é valuées. I l est également1 2
impor tant de noter que si la valeur dee est str ictement plus gr ande que cel le de1
e , le cor ps de la bouc le n’est ja mais ex écuté .2
P our êtr e co mplet, mentio nno ns qu ’ il existe une var iante de la co nstr uctio n for
pour co mpter à r ebours. P ar ex emple , le pr ogr amme suivant affic he les c hiff r es 9
8 7 6 5 4 3 2 1 0 dans cet or dr e .
let () =
for i = 9 downto 0 do
Printf.printf "%d " i
done
N oto ns enfin qu ’ il n’existe pas de var iante pour co mpter den enn. P our cela, o n
peut utiliser une bouc le while, qui ser a décr ite plus loin.2 – Débuter avec OCaml en pr ogr ammant
25
2.3 Dessin d’une car dioïde
Notions intr oduites
• bibliothèque de code objet (extensio n .cma)
• Graphics
• f o nctio n ignore
N otr e tr oisième pr ogr amme , cardioide.ml, dessine une c ar dioïde , c ’ est-à-dir e une
cour be qui r epr ésente la tr ajectoir e d ’un point fix e sur un cer c le tour nant (sans
glisser) autour d ’un autr e cer c le (de même diamètr e), co mme décr it dans la figur e 2.2.
Figur e 2.2
Dessin d’une cardioïde
D’un point de vue mathématique , cette c ar dioïde est une cour be alg ébr ique plane
qui peut êtr e définie par les équatio ns par amétr iques suivantes :

 x(θ) =a(1−sin(θ))cos(θ)
 y(θ) =a(1−sin(θ))sin(θ)
oùa r epr ésente le r a y o n des deux cer c les.
P our tr a cer cette c ar dioïde , o n utilise la bibliothèque Graphics d ’O Caml qui
permet d ’ ouv r ir une f enêtr e gr ap hique 2D et d ’y dessiner à l’aide de f o nctio ns gr
ap hiques élémentair es. Co mme nous al lo ns utiliser de no mbr euses f o nctio ns de
cette bibliothèque , notr e pr ogr amme co mmence par une dir ectiv e d ’ ouv er tur e de
module :
open Graphics
N ous pourr o ns ainsi utiliser les valeurs et f o nctio ns de cette bibliothèque sans les
pr éfix er sy stématiquement par le no m de module Graphics.Pr emièr e partie : pr ogr ammation avec OCaml
26
Pr ogr amme 3 [cardioide.ml] — Dessin d’une car dioïde
open Graphics
let () = open graph " 300x200"
let () =
moveto 200 150;
for i = 0 to 200 do
let th = atan 1. *. float i /. 25. in
let r = 50. *. (1. -. sin th) in
lineto (150 + truncate (r *. cos th))
(150 + (r *. sin th))
done;
ignore (read key ())
L a ligne suivante ouv r e une f enêtr e gr ap hique av ec la f o nctio n open graph. Cette
f o nctio n pr end en argument une c haîne de c ar a ctèr es indiquant les dimensio ns de
la f enêtr e .
let () = open graph " 300x200"
Cette instr uctio n ouv r e une f enêtr e de tail le300×200, c ’ est-à-dir e av ec 300 pix els
de larg e et 200 pix els de haut (l’espa ce au début de la c haîne est nécessair e). On
dessine alors dans cette f enêtr e av ec des coor do nnées entièr es, l’or igine étant située
en bas à gauc he de la f enêtr e , les abscisses pr enant des valeurs de 0 à 299 et les
or do nnées des valeurs de 0 à 199 (v oir figur e 2.3).
L a suite du pr ogr amme affic he la c ar dioïde . Co mme c ’ est une par tie de code qui
ne r end pas de valeur , o n l’englobe dans une déc lar atio n de la f or me :
let () = ...
P our tr a cer la c ar dioïde , o n utilise des f o nctio ns qui f o nt r éf ér ence à une notio n de
p oint cour ant . Ce point peut êtr e positio nné av ec moveto. Un appel à lineto x y
tr a ce alors un segment de dr oite du point cour ant v ers celui de coor do nnées (x,y),
qui de vient alors le nouv eau point cour ant.2 – Débuter avec OCaml en pr ogr ammant
27
ax e desy
199
y •
0 ax e desx.
299x0
Figur e 2.3
Système de coordonnées de la bibliothèque Graphics
On co mmence par dépla cer le point cour ant en (200,150), à l’aide d ’un appel à la
f o nctio n moveto , pour dessiner la c ar dioïde à par tir de ce point-là :
moveto 200 150;
À l’aide d ’une bouc le for , o n fait var ier l’angleθ entr e 0 et 2π . P our cela, o n fait
var ier un indice entier i de 0 à 200 et o n utilise le f ait que arctan(1) =π/4 pour
c alculerθ co mme étant égal à arctan(1)× / 25.
for i = 0 to 200 do
let th = atan 1. *. float i /. 25. in
...
done
En O Caml, l’ar c tang ente d ’un angle , expr imé en r a dians, est c alculé av ec la f o
nctio n atan de la bibliothèque Pervasives.
L a ligne suivante définit une var iable loc ale inter médiair e r pour c alculer la
sousexpr essio na(1−sin(θ)), où le r a y o n de la c ar dioïdea est fix é à 50 pix els :
let r = 50. *. (1. -. sin th) in
L’utilisatio n de cette var iable inter médiair e per met de fa ctor iser une par tie du c
alcul des coor do nnées du point (x(θ),y(θ)).Pr emièr e partie : pr ogr ammation avec OCaml
28
Enfin, à l’aide de la f o nctio n lineto , o n tr a ce un segment entr e le point cour ant
et le point de coor do nnées (x(θ),y(θ)) . L es coor do nnées gr ap hiques étant des
valeurs entièr es, o n utilise la f o nctio n truncate pour r en v o y er la par tie entièr e des
expr essio ns c alculées pour les coor do nnées.
lineto (150 + truncate (r *. cos th))
(150 + (r *. sin th))
A pr ès la bouc le for, la der nièr e ligne du code attend qu ’une touc he soit pr essée ,
afin d ’ é viter que la f enêtr e gr ap hique ne soit immédiatement r ef er mée une f ois le
dessin ter miné .
ignore (read key())
Co mme o n souhaite seulement attendr e qu ’une touc he soit pr essée , o n ignor e le c
ar a ctèr e r en v o y é par la f o nctio n read key en utilisant la f o nctio n pr édéfinie ignore.
Compilation
Co ntr air ement aux modules co mme Sys, Arg ou Printf vus pr écédemment, qui
appar tiennent à la bib liothèque st andar d d ’O Caml, il faut indiquer e xp licit ement au
co mpilateur O Caml que l’o n souhaite utiliser la bibliothèque Graphics pour co
mpiler le pr ogr amme cardioide.ml . Cela se fait simplement en ajoutant le fic hier
graphics.cma sur la ligne de co mmande , de la manièr e suivante :
> ocamlc -o cardioide graphics.cma cardioide.ml
Dans le c as où l’o n souhaite co mpiler av ec le co mpilateur de code natif , il faut
r empla cer le suffix e .cma par .cmxa. Co mme nous le v err o ns dans la sectio n 2.10
Un c asse-br iques sans br iques , l’or dr e des fic hiers sur la ligne de co mmande du co
mpilateur est impor tant : ici, il faut obligatoir ement que graphics.cma soit passé
avant le fic hier cardioide.ml sur la ligne de co mmande , c ar ce der nier utilise la
bibliothèque Graphics.
P our utiliser la bibliothèque Graphics av ec le t op le v e l ocaml, il suffit de taper dans
le ter minal la co mmande suivante :
> ocaml graphics.cma
OCaml version 4.00.1
#
Enfin, o n peut dir ectement utiliser la bibliothèque Graphics av ec T r yO Caml.2 – Débuter avec OCaml en pr ogr ammant
29
La bibliothèque Gr aphics
En plus des f o nctio ns moveto et lineto utilisées dans notr e pr ogr amme
cardioide.ml , la bibliothèque Graphics off r e des f o nctio ns tel les que plot pour
affic her un point, set color pour modifier la couleur d ’affic hag e , draw circle pour
dessiner un cer c le , set line width pour c hang er l’épaisseur des tr aits, fill rect
pour r emplir un r ectangle , draw string pour affic her une c haîne de c ar a ctèr es,
etc. L e lecteur est in vité à visiter la pag e w eb du manuel O Caml pour une
descr iptio n co mplète de cette bibliothèque . I l est impor tant de noter que , bien que les
f o nctio nnalités de Graphics soient limitées, cette bibliothèque a l’avantag e d ’ êtr e
dispo nible sur de no mbr euses ar c hitectur es. S i o n souhaite une bibliothèque plus
sop histiquée , o n pourr a utiliser (selo n le sy stème d ’ exploitatio n) :
• L ablTk : bibliothèque T c l/Tk f our nie av ec O Caml, qui per met de co nce v oir des
inter fa ces gr ap hiques (GUI) av ec menus dér oulants, bouto ns, etc.
• L ablGtk : similair e à L ablTk mais basée sur la bibliothèque gr ap hique Gtk. El le
ne fait pas par tie de la distr ibutio n du langag e O Caml ; o n peut la téléc harg er à
l’a dr esse http://lablgtk.forge.ocamlcore.org/ .
• O Camlsd l : bibliothèque SDL pour O Caml utilisée pr incipalement pour r
éaliser des jeux vidéos ( http://ocamlsdl.sourceforge.net/ ).
2.4 Ensemble de Mandelbr ot
Notions intr oduites
• déc lar atio n de f o nctio ns
• f o nctio ns r écursiv es
• t y pe unit et valeur ()
N otr e pr ogr amme 4 (v oir pag e 32) dessine l’ensemble de Mandelbr ot de la
figur e 2.4, défini co mme l’ensemble des points ( ,b ) du plan pour lesquels aucune
des deux suites r écurr entes suivantes ne tend v ers l’infini (en valeur absolue).
x = 00
y = 00
2 2x = x −y +an+1 n n
y = 2x y +bn+1 n nPr emièr e partie : pr ogr ammation avec OCaml
30
Figur e 2.4
Ensemble de Mandelbrot
Bien qu ’ il n’y ait pas de méthodes exa ctes pour déter miner cette co nditio n, o n peut
2 2démo ntr er que l’une de ces suites tend v ers l’infini dès quex +y > 4. Ce r ésultatn n
per met tout d ’abor d de déduir e que les points de l’ensemble de Mandelbr ot
appartiennent au disque de r a y o n 2 centr é en (0,0). Ensuite , il per met de dessiner une
appr o ximatio n de l’ensemble de Mandelbr ot que l’o n définit co mme l’ensemble
2 2des points ( ,b) pour lesquels x +y ≤ 4 pour les k pr emièr es valeurs de cesn n
suites. N oto ns que la pr écisio n de cette appr o ximatio n dépend alors uniquement
du no mbr ek de valeurs c alculées.
L e pr ogr amme co mmence par une dir ectiv e open Graphics pour simplifier
l’utilisatio n des f o nctio ns de la bibliothèque gr ap hique . I l définit ensuite deux
var iables globales width et height co ntenant r espectiv ement la larg eur et la hauteur
de la f enêtr e gr ap hique que l’o n souhaite ouv r ir (800×800 par ex emple) :
let width = 800
let height = 800
On fix e ensuite le no mbr e maximal k de valeurs à c alculer (pour une bo nne
appr o ximatio n, 100 valeurs so nt suffisantes) :
let k = 100
L a déc lar atio n suivante définit une f o nctio n norm2 qui pr end deux arguments x et
2 2y et r en v oie la valeur de l’expr essio n x + y .
let norm2 x y = x *. x +. y *. y
N ous do nno ns plus de détails sur cette co nstr uctio n sy ntaxique à la fin de cette
sectio n. N éanmoins, noto ns dès à pr ésent que , co mme pour un appel de f o nctio n, les

Un pour Un
Permettre à tous d'accéder à la lecture
Pour chaque accès à la bibliothèque, YouScribe donne un accès à une personne dans le besoin