Lycée Malherbe MPSI Année scolaire 2017-2018 Option informatique partie A - Introduction au langage Caml TD n o I Corrigé Prise en main de Caml 1 Démarrage 1 Recopiez sur votre bureau le dossier H:\\MP2\Documents en consultation\wincaml6, et lancez l exécutable WinCaml (icône représentant une petite tête de chameau qui a des lunettes de soleil!). 2 Si nécessaire, dans le menu CamlTop, choisissez l option OCaml. 3 Commencez par essayer ce premier exemple (en tapant la première ligne dans l éditeur, vous devriez obtenir la deuxième ligne dans la fenêtre de résultats). # 1+4;; - : int = 5 Attention : le # des polys indique juste le prompt, donc ne le tapez pas! Pour le résultat, Caml affiche la nature (le type) avant la valeur : ici il indique int (pour entier ou integer en anglais) avant de calculer le résultat 5. Ceci est un fait général dans Caml : on infère le type d un objet avant de l évaluer. Il est important de réaliser que la compréhension du type par Caml est essentielle et qu elle précède toujours la partie calculatoire : Caml est un langage fortement typé. 4 Observez (et essayez) maintenant les commandes suivantes # let x = 3 ;; val x : int = 3 # x+2 ;; - : int = 5 Vous avez ici la commande pour la déclaration d une variable. En effet, le mot affectation est impropre en Caml : il s agit plutôt d une liaison entre un identificateur (un nom), et une valeur. Cette différence avec Python aura son importance dans la suite. 5 Que prouve l expérience suivante? # let a = 1 ;; val a : int = 1 # let b = a+1 ;; val b : int = 2 # let a = 2 ;; 1
val a : int = 2 # b ;; - : int = 2 Une fois affectées, les variables ne changent plus, elles ont été totalement évaluées. En Caml, on dispose aussi de la possibilité d affecter localement une variable (mot réservé in). C està-dire que la variable existe dans un certain bloc (terminé par ;;), mais pas ailleurs. # let c = 2 in c+2 ;; - : int = 4 # c ;; Error: Unbound value c Au passage, on observe notre première erreur sur cet exemple : Caml commente les erreurs (comme Python). 6 Calculer à l aide d une déclaration locale le quotient 5 `?3 ` expp? 3q lnp?. 3q let x = sqrt 3. in (5. +. x +. exp x) /. log x ;; 2 Types élémentaires Comme on l a dit dans le cours, Caml est un langage fortement typé. Lorsqu on programme, il est essentiel de vérifier le typage de chaque expression. Dans ce TD, nous étudions les types élémentaires. Plus tard, nous verrons les types composés, les types définissables par l utilisateur, et les types mutables. 2.1 Type unit Le type le plus simple de Caml est le type unit qui ne comporte qu une valeur (). ();; print_newline();; # - : unit = () # - : unit = () Même si son utilité n est pas évidente pour le débutant, ce type est essentiel pour les fonctions qui ne prennent pas d argument ou qui ne renvoient rien. 2
2.2 Types int et float Il existe principalement deux types de nombres : int et float, représentation machine respectives des entiers et des réels. Attention, en Caml, contrairement à Python, les deux types ne sont pas compatibles. 7 Essayer par exemple : # 2 ;; # 2. ;; # 2 + 2. ;; # 2 ;; - : int = 2 # 2. ;; - : float = 2. # 2 + 2. ;; Error: This expression has type float but an expression was int En conséquence, on n utilise pas les mêmes fonctions pour ces deux types. Ainsi, on emploiera +, *, etc., pour les entiers, et +., *., etc., pour les flottants. Les fonctions mathématiques usuelles ( sqrt, cos, sin, tan, acos, asin, atan, log, exp, **) utilisent le type float. 8 Essayer par exemple # exp 2 ;; # exp 2. ;; # exp 2 ;; Error: This expression has type int but an expression was float # exp 2. ;; - : float = 7.38905609893065 9 Rectifier la fonction suivante pour la faire fonctionner. 3
# let f x = 2 * exp x ;; Error: This expression has type float but an expression was int On rectifie facilement. # let f x = 2. *. exp x ;; val f : float -> float = <fun> Les fonctions min, max, <, >, <=, >= fonctionnent à la fois pour les flottants et les entiers. Les entiers sur Caml sont codés sur 32 bits. 10 Comment expliquez-vous ce que vous obtenez quand vous tapez...? 999999*999999*999999;; 999999*999999*999999*999999;; # - : int = 999997000002999999 # - : int = -1996229794797103359 On a vu la représentation des entiers en IPT... Python, qui permet de représenter des entiers de taille illimitée, peut nous aider à mener une petite expérience. >>> 2**62 4611686018427387904 Maintenant qu on a la valeur de 2 62, on revient à Caml : # 4611686018427387904 ;; - : int = -4611686018427387904 # 4611686018427387904-1 ;; - : int = 4611686018427387903 # -4611686018427387904 ;; - : int = -4611686018427387904 # -4611686018427387904-1 ;; - : int = 4611686018427387903 En fait, Caml stocke le représentant de l entier x modulo 2 63 entre 2 62 et 2 62 1 (sur 64 bits, 1 bit est gardé pour des raisons subtiles). Le quotient et le reste dans la division euclidienne sont obtenus respectivement par / et mod, en notation infixe (ie entre les arguments, comme en Python). 4
# 1893. /. 29. ;; (* division flottante *) - : float = 65.2758620689655231 # 1893 / 29 ;; (* quotient dans la division euclidienne *) - : int = 65 # 1893 mod 29 ;; (* reste dans la division euclidienne *) - : int = 8 Rappel : en Python... >>> 1893 / 29 # division flottante 65.27586206896552 >>> 1893 // 29 # quotient dans la division euclidienne 65 >>> 1893 % 29 # reste dans la division euclidienne 8 quotient reste Caml / mod Python 3 // % 11 Que répond Caml à la division euclidienne de a par b quand a ă 0? quand b ă 0? Comparez avec Python. Notons a bq ` r la division euclidienne obtenue. On a toujours r ă b. En Python, r est du signe de b. a 15 15 15 15 b 4 4 4 4 q 3 4 4 3 r 3 1 1 3 En Caml, r est du signe de a. a 15 15 15 15 b 4 4 4 4 q 3 3 3 3 r 3 3 3 3 2.3 Type bool Le type booléen comporte deux valeurs true et false (pas de majuscules, contrairement à Python). Les opérations logiques sont && pour la conjonction (et logique), pour la disjonction (ou logique), et not pour la négation. Le test d égalité est noté =. Comme Python, Caml pratique l évaluation paresseuse (short-circuit evaluation), et les arguments sont évalués de gauche à droite (ie and et or ne sont pas commutatifs en informatique!). Le tableau suivant donnent les opérateurs pour les tests d égalité et de différence, en Python et en Caml. 5
Python Caml test d égalité == = test de différence!= <> Pour les plus à l aise d entre vous... Ci-dessus, c est l égalité structurelle. L égalité physique, c est : Python Caml test d égalité is == test de différence not is!= 12 Essayez (et comprenez) par exemple : # (3=3) (1/0)=9 ;; # (2=3) && (1/0)=9 ;; # (3=4) (1/0)=9 ;; # (3=3) && (1/0)=9 ;; # (3=3) (1/0)=9 ;; - : bool = true # (2=3) && (1/0)=9 ;; - : bool = false # (3=4) (1/0)=9 ;; Exception: Division_by_zero. # (3=3) && (1/0)=9 ;; Exception: Division_by_zero. Quand le premier paramètre suffit à calculer le résultat, le deuxième n est pas évalué donc l erreur de la division par 0 n est pas détectée. En revanche, quand le premier paramètre ne suffit pas, Caml cherche à évaluer le second, d où l erreur. 2.4 Conversion Signalons qu il existe des fonctions permettant de convertir un argument d un type vers un autre : int_of_float ; float_of_int ; string_of_int ; Array.of_list ; Array.to_list. 6
Parfois, elle seront nécessaires, mais on évitera autant que possible de les utiliser. 13 Testez les phrases suivantes. # int_of_float 2. ;; # int_of_float 2 ;; # 2 +. 3. ;; # float_of_int 2 +. 3. ;; # int_of_float 2. ;; - : int = 2 # int_of_float 2 ;; Error: This expression has type int but an expression was float # 2 +. 3. ;; Error: This expression has type int but an expression was float # float_of_int 2 +. 3. ;; - : float = 5. 2.5 Affichage On pourra aussi avoir besoin d afficher des variables dans des fonctions, mais sans les renvoyer : print_int ; print_float ; print_string ; print_char ; Printf.printf. 14 Testez les phrases suivantes. # print_int 3 ;; # print_float 3 ;; # print_string 3 ;; # print_string "3" ;; # print_string '3' ;; # print_char '3' ;; # Printf.printf "Au concours en option informatique, je vais avoir %f/%d" 19.5 20 ;; 7
# print_int 3 ;; 3- : unit = () # print_float 3 ;; Error: This expression has type int but an expression was float # print_string 3 ;; Error: This expression has type int but an expression was string # print_string "3" ;; 3- : unit = () # print_string '3' ;; Error: This expression has type char but an expression was string # print_char '3' ;; 3- : unit = () # Printf.printf "Au concours en option %s, je vais avoir %f/%i" "informatique" 19.5 20 ;; Au concours en option informatique, je vais avoir 19.500000/20- : unit = () 2.6 Produits cartésiens Les produits cartésiens permettent de rassembler des objets de types différents (ce qui ne sera pas possible avec les listes ou les tableaux). C est-à-dire que les produits cartésiens sont des tuples d objets de types identiques ou différents. On les définit avec des parenthèses, souvent facultatives, et des virgules comme séparateurs. 15 En essayant les commandes (1, true, () );; (2.2, "abc", false);; observez comment Caml note les produits cartésiens. avec une étoile * # - : int * bool * unit = (1, true, ()) # - : float * string * bool = (2.2, "abc", false) 16 Prévoyez le type retourné par Caml pour les instructions suivantes, et ensuite vérifier. (1,2,3,4);; 1,2,3,4;; 8
(1,2),3,4;; (1,2),(3,4);; # - : int * int * int * int = (1, 2, 3, 4) # - : int * int * int * int = (1, 2, 3, 4) # - : (int * int) * int * int = ((1, 2), 3, 4) # - : (int * int) * (int * int) = ((1, 2), (3, 4)) On peut récupérer chacune des coordonnées d un couple avec les fonctions fst (première coordonnée) et snd (seconde coordonnée). 17 Testez let t = (1, 2) ;; fst t;; snd t;; 3 Fonctions 3.1 Définition et appel Pour définir soi-même une fonction, on fera simplement let f arguments = expression ;; (D autres versions existent que nous ne verrons pas dans un premier temps.) On appelle les fonctions Caml comme les fonctions mathématiques, à ceci près que les parenthèses inutiles peuvent être omises. 18 Essayer # let f x = log x +. sin x ;; # f 3. ;; # f 3 ;; # let f x = log x +. sin x ;; val f : float -> float = <fun> # f 3. ;; - : float = 1.23973229672797691 # f 3 ;; (* erreur, la fonction attend un flottant *) Error: This expression has type int but an expression was float Attention aussi aux prorités dans les calculs. 9
let f x = x**2. ;; f 3. *. 2. ;; f ( 3. *. 2. ) ;; 19 A l aide d une déclaration locale (une seule!), définir la fonction tangente hyperbolique en ne faisant qu un seul calcul d exponentielle. On rappelle que $ & R Ñ R th : % x ÞÑ ex e x. e x ` e x On a aussi thpxq e2x 1 e 2x ` 1. let th x = let a = exp(2.*.x) in (a-.1.)/.(a+.1.);; th ( log 3. ) ;; # val th : float -> float = <fun> # - : float = 0.8 On peut aussi écrire thpxq e x 1 e x e x ` 1. e x let th x = let a = exp(x) in (a-.1./.a)/.(a+.1./.a);; th ( log 3. ) ;; Remarque : la fonction th est prédéfinie dans Caml : c est tanh. 3.2 Typage des fonctions d une variable En Caml, une fonction est un objet à part entière, et admet un type comme tous les autres objets. A l issue de ce premier TD, vous devrez avoir bien compris le typage des fonctions par Caml. Ces types sont composés des types du ou des argument(s) et du type du résultat, séparés par des flèches ->. 20 Commençons par essayer (et expliquer) : # let f x = x+1 ;; # let g x = x+.1. ;; # let h x = x+.1 ;; 10
# let f x = x+1 ;; val f : int -> int = <fun> # let g x = x+.1. ;; val g : float -> float = <fun> # let h x = x+.1 ;; Error: This expression has type int but an expression was float L opération +/l entier 1 indiquent que l argument est entier, tandis que l opération +./le flottant 1. indiquent que l argument est flottant, d où la réponse de Caml. Pour la troisième fonction, il y a une contradiction. Quand Caml n arrive par à déterminer le type (c est-à-dire qu il y a une ambiguïté), il utilise le polymorphisme. 21 Essayer par exemple de définir la fonction identité : let f x = x;; Qu obtenez-vous comme type? On obtient # val f : 'a -> 'a = <fun> Ici 'a est une variable de type : elle représente, comme ce nom l indique, un type d objets quelconque. 3.3 Fonctions de plusieurs variables Comment Caml établit-il le type des fonctions de plusieurs variables? Tapez le code suivant : let f x y z = x *. float_of_int y *. z;; let g = f 2. ;; let h = g 2 ;; let k = f 2. 10 ;; On obtient : # val f : float -> int -> float -> float = <fun> # val g : int -> float -> float = <fun> # val h : float -> float = <fun> # val k : float -> float = <fun> Beaucoup de flèches pour une seule fonction pourrait-on se dire! En fait, Caml utilise l associativité à droite des types. Ainsi f : float -> int -> float -> float = <fun> est à comprendre comme 11
f : float -> ( int -> ( float -> float ) ) = <fun> Quand on tape f x1 x2 x3 x4 x5 = blabla, Caml place dans f la fonction f : x1 ÞÑ px2 ÞÑ px3 ÞÑ px4 ÞÑ px5 ÞÑ blablaqqqq Ainsi, fpx1q est une fonction, qui à une variable x2 associe une fonction, qui à une variable x3 associe, etc. 22 Comparez maintenant let f x y = x * y ;; let g (x,y) = x * y ;; Comment appeler ces fonctions? La première fonction est une fonction de deux variables. La deuxième est une fonction qui agit sur un couple. La réponse obtenue est : # val f : int -> int -> int = <fun> # val g : int * int -> int = <fun> Pour appeler les fonctions, on peut faire : let f x y = x * y ;; f 3 4 ;; let g (x,y) = x * y ;; g (3,4) ;; Dans la question ci-dessus, la première version est appellée curryfiée (du nom du logicien Haskell Curry, qui a posé les bases de la programmation fonctionnelle), et la deuxième version non-curryfiée. En raison de la facilité d abstraction de paramètre sur les fonctions curryfiées, la première version sera toujours à privilégier. Certaines fonctions ne renvoient rien. On dit qu elles agissent par effet de bord. Essayer par exemple (les types-enregistrement seront vus plus tard dans l année). let f () = 4;; let g x = ();; print_string;; type complexe = { x: float ; mutable y: float};; let conj z = z.y <- -.z.y;; let z = { x = 3. ; y = 5. } ;; conj z ;; z ;; On obtient : 12
# val f : unit -> int = <fun> # val g : 'a -> unit = <fun> # - : string -> unit = <fun> # type complexe = { x : float; mutable y : float; } # val conj : complexe -> unit = <fun> # val z : complexe = {x = 3.; y = 5.} # - : unit = () # - : complexe = {x = 3.; y = -5.} Le polymorphisme peut aussi être nécessaire pour les fonctions de plusieurs variables. 23 Essayer let f x y = x ;; On obtient # val f : 'a -> 'b -> 'a = <fun> Première projection. Cette fois, deux variables de type sont apparues... 'a et 'b. 24 Prévoyez le type des objets suivants (et ensuite vérifier). let sym f x = f (-.x) ;; sym exp ;; sym exp 3. ;; Ecriture mathématique de sym? # val sym : (float -> 'a) -> float -> 'a = <fun> # - : float -> float = <fun> # - : float = 0.0497870683678639445 sym est une fonction qui prend en argument deux variables f et x : comme on peut n en donner qu un, cette fonction répond bien à la question posée. Comme dans la réponse, on applique f à quelque chose, f est une fonction. Et comme le quelque chose est (-.x), forcément x est un flottant, et f est une fonction sur les flottants. Mais on ne sait pas l ensemble d arrivée de f, d où la variable de type 'a. On pourrait aussi proposer la solution suivante, bien moins jolie et moins stylée... let sym f = fun x -> f(-.x) ;; sym exp ;; sym exp 3. ;; En maths, sym : f ÞÑ px ÞÑ fp xqq 13
(les graphes de f est de sympfq sont symétriques l un de l autre par rapport à l axe des ordonnées). En Python, on pourrait écrire : from math import exp,cos def sym(f): def tmp(x): return (f(-x)) return tmp g = sym( lambda x: exp(x)-4*x+9*cos(10*x) ) # la fonction x -> exp(-x)+4x+9cos(10x) print(g(-1)) ou avec des fonctions anonymes : sym = lambda f : lambda x : f(-x) 25 Ecrire une fonction qui prend en argument une fonction f sur les entiers et renvoie la fonction x ÞÑ fpx ` 1q. Fonction avec 2 arguments ; on n en donne qu un seul pour répondre à la question... let trans f x = f (x+1) ;; # val trans : (int -> 'a) -> int -> 'a = <fun> La solution suivante est beaucoup moins bonne. let trans f = fun x -> f (x+1) ;; 26 Prévoyez le type des fonctions suivantes : let somme1 f g x = (f x) + (g x) ;; let somme2 f g x = (f x) +. (g x) ;; let somme3 f g x = (f (x*1)) +. (g x) ;; let somme4 f g x = (f (x*.1.)) +. (g x) ;; # val somme1 : ('a -> int) -> ('a -> int) -> 'a -> int = <fun> # val somme2 : ('a -> float) -> ('a -> float) -> 'a -> float = <fun> # val somme3 : (int -> float) -> (int -> float) -> int -> float = <fun> # val somme4 : (float -> float) -> (float -> float) -> float -> float = <fun> 14
f et g étant appliquées à un argument, ce sont des fonctions. Dans le 4ème cas par exemple, l opération *1 indique que x est du type int, donc f et g partent du type int. De plus, le calcul sur les images de f et g est +., donc l ensemble d arrivée de f et g est float. 27 Prévoyez le type des objets suivants : let composition f g x = f (g x);; let u x = x+1;; let v x = x*x;; composition v ;; let h = composition v u ;; h 3 ;; En maths?... # val composition : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun> # val u : int -> int = <fun> # val v : int -> int = <fun> # - : ('_a -> int) -> '_a -> int = <fun> # val h : int -> int = <fun> # - : int = 16 Dans la réponse, g est appliqué à x donc g est une fonction. Rien n indique le type de x ni l ensemble d arrivée de g, mais on prend l image par f de g x, donc l ensemble de départ de f est le même que l ensemble d arrivée de g. Enfin, rien n indique l ensemble d arrivée de f. On a donc trois variables de type 'a, 'b et 'c. Ensuite, u et v sont des fonctions de int dans int à cause de + et *. Dans composition v, on enlève un étage à la fusée, et 'a et 'b sont int, tandis que 'c reste inconnu et est renommé en 'a. Pour avoir le type de h, on repart du type de composition, mais avec deux étages en moins à la fusée, et avec cette fois les types 'a, 'b et 'c précisées en int. Enfin, h 3 prive encore la fusée d un étage : cette fois, on obtient un entier. En maths : composition : f ÞÑ pg ÞÑ px ÞÑ f gpxqqq. 28 Ecrire une fonction derivee f renvoyant une approximation de la fonction dérivée de f. let derivee f x = let h = 1e-6 in (f(x+.h)-.f(x-.h))/.(2.0*.h);; let g = derivee sin ;; g 0. ;; Ainsi derivee sin est la fonction dérivée de sin : gros avantage de la déclaration curryfiée. 29 Quelle est le type de la fonction suivante? 15
let max3 x y z = max max x y z ;; Comment la rectifier pour qu elle calcule le maximum de trois nombres (entiers ou flottants)? Le type de la fonction est : # val max3 : ('a -> 'a -> 'a) -> 'a -> 'a -> 'a = <fun> En effet, si un élément u est de type 'b, alors max u attend un autre élément v de même type et renverra un élément de ce type 'b (le plus grand entre u et v). Ainsi, max u est de type 'b -> 'b. Ici, u est max, de type 'b = '_a -> '_a -> '_a, donc max max est de type donc à cause de l associativité à droite : ('_a -> '_a -> '_a) -> ('_a -> '_a -> '_a) ('_a -> '_a -> '_a) -> '_a -> '_a -> '_a Il suffit de mettre des parenthèses pour faire ce qu on veut. let max3bis x y z = max (max x y) z ;; max3bis 1 2 3;; # val max3bis : 'a -> 'a -> 'a -> 'a = <fun> # - : int = 3 16