Types, expressions et fonctions Environnement utilisé : The Objective Caml compiler, version 3.xx 1995-2005 INRIA Un interprète est un logiciel capable d'évaluer des expressions et d'exécuter des programmes. L'objectif principal des exercices d'expérimentation proposés ici est de renforcer la compréhension des concepts et outils développés en cours et en TD. Les savoir et savoir-faire exigibles sont : Maîtriser les notations concernant les types de base, les types Texte et Chaîne et le produit de types, Exploiter les messages de l'interprète concernant les types. En particulier, identifier les erreurs typiques liées à des incohérences de types. Implanter en CAML notations mathématiques, concepts et outils des cours/td. Toute expression CAML soumise à évaluation doit être suivie de deux points-virgules (). L'interprète du langage attend la saisie d'une expression en affichant le symbole d'invite #. L'usager la fournit alors suivie d'un appui sur la touche Entrée. Deux réactions sont alors possibles : - Tout se passe bien : l'interprète répond en affichant un type et une valeur. - L'expression fournie ne respecte pas les contraintes de typage : l'interprète répond alors par un message d'erreur et la partie de l'expression qui pose problème est soulignée. Table des matières EP1.1 Évaluation d'une expression...1 EP1.2 Maximum de deux entiers...2 EP1.3 Moyenne de deux entiers...3 EP1.4 Moyenne olympique (suite DM distribué en cours)...5 EP1.5 Relations sur des intervalles d'entiers (suite exercice TD)...5 EP1.6 Expressions conditionnelles...7 EP1.7 Signe du produit (variation de l'exercice vu en TD)...7 EP1.8 Une date est-elle correcte? (suite exercice TD)...8 EP1.9 Numération en base 16...8 EP1.10 Nommer une expression...8 EP1.11 Somme des chiffres d'un nombre (suite exercice TD)...9 EP1.12 Permutation ordonnée d'un couple d'entiers...9 EP1.13 Définition du type Durée et des opérations associées (énoncé : DM distribué en cours)...10 EP1.14 Codage des caractères...10 EP1.15 Texte représentant un entier en base 16...11 Rappel définir = donner une définition ; définition = spécification + réalisation spécifier = donner une spécification ; spécification = profil + sémantique + examples réaliser = donner une réalisation ; réalisation = algorithme (langue naturelle) + implantation (CAML) implanter = donner une implantation Dans certains cas, certaines de ces rubriques peuvent être omises. EP1.1 Évaluation d'une expression À titre d'exemple, essayez de prédire le type de chacune des expressions suivantes (délimitées par ), puis les saisir une par une dans la fenêtre de l'interprète et observer sa réponse avant de saisir l'expression suivante : 24 3+4 "3"+4 "3+4" "bonjour" "x" 'x' ['x'] x P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 1
EP1.2 Maximum de deux entiers (i) Spécification, réalisation d'une fonction De manière générale, la définition d'une fonction, appelée f, aura la forme suivante, présentée ici dans le cas d'une fonction ayant deux paramètres de types t1 et t2 et un résultat de type t3 (t1, t2, t3 dénotent des noms de types, en particulier de base). En CAML, un commentaire est délimité au début par (* et à la fin par *). (* -------------------------------------------------------------------------- titre -------------------------------------------------------------------------- S profil : f : t1 x t2 -> t3 P sémantique : description de ce que fait la fonction en langage naturel (le «quoi») É ex et prop : - exemples et/ou C - propriétés -------------------------------------------------------------------------- R algorithme : description du «comment» É tests : - traduction en CAML du paragraphe ex et prop A de la section SPÉC ci-dessus L implantation : *) (* /!\ conditions d'utilisation de f (x,y) : conditions sur x et y *) let (f : t1*t2 -> t3) = function (nom_param_formel_1,nom_param_formel_2) -> expr. algébrique implantant la fonction Par exemple, on peut définir une fonction max2 de calcul du maximum de deux entiers : (* -------------------------------------------------------------------------- MAXIMUM DE DEUX ENTIERS -------------------------------------------------------------------------- S profil : max2 : N x N -> N P sémantique : max2 (a,b) est la plus grand des nombres a et b É ex et prop : (a) max2 (3,4) = 4 C (b) max2 (4,3) = 4 (c) quelque soit a dans N, max2 (a,a) = a -------------------------------------------------------------------------- R algorithme : le max est à mi-distance à droite du milieu É tests : - ex (a) et (b) A - max2 (3,3) = 3 L implantation : *) (* /!\ conditions d'utilisation de max2 (a,b) : a, b >= 0 *) let (max2 : int * int -> int) = function (a,b) -> ((a+b)+abs(a-b)) / 2 Soumettre cette définition de fonction à l'interprète CAML, et observer la réponse du système : de manière générale, lors de la définition d'une fonction, CAML répond en donnant le profil de la fonction (c'est-à-dire : nom_de_la_fonction : types des paramètres -> type_du_résultat). Par contre l'implantation (c'est à dire le code qui définit la fonction) n'est pas réaffichée. La valeur absolue est une fonction prédéfinie. Observer la réaction de l'interprète après la saisie de l'expression abs. Donner la spécification de abs selon le modèle ci-dessus. Vérifier sur un jeu d'essai pertinent que cette fonction fait bien ce qui est écrit dans la section sémantique de la partie SPÉCIF. Modifier la réalisation précédente de la fonction max2 comme suit, et observer la réponse de l'interprète. let (max2 : int * int -> int) = function P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 2
(a b) -> ((a+b)+abs(a-b)) / 2 Conclure sur le rôle des virgules dans l'énoncé des paramètres formels. (ii) Utilisation d'une fonction L'utilisation d'une fonction dans une expression a la forme suivante (cas de deux paramètres) : nom_de_fonction (paramètre_effectif_1, paramètre_effectif_2) Pour connaître le profil d'une fonction il suffit de fournir l'expression nom_de_fonction à l'interprète comme vous venez de le faire pour abs. Appliquez la fonction max2 à quelques jeux d'essai et en particulier des jeux ne satisfaisant pas le profil de la fonction, par exemple, max2 ("def", "abc"). Pour calculer la somme de quatre valeurs on peut se ramener à la somme de deux valeurs, en écrivant par exemple a+(b+(c+d)). On veut définir de manière analogue une fonction max4 pour calculer le maximum d'un 4-uplet d'entiers (c'est à dire un vecteurs de 4 entiers). Donner la spécification puis une réalisation de cette fonction, en termes de la fonction max2. EP1.3 Moyenne de deux entiers (i) Types numériques : entiers (int) et réels (float) Observer le type des valeurs suivantes : 3.5 3,5 Observer le résultat (type et valeur) de l'évaluation de l'expression (4 + 3) / 2. Conclure en donnant la spécification des opérateurs + et /. Observer la réaction de l'interprète pour chacune des expressions suivantes : (4 + 3) /. 2 (4.0 + 3.0) /. 2 (4.0 +. 3.0) /. 2 (4.0 +. 3.0) /. 2.0 Conclure en donnant la spécification des opérateurs +. et /. (ii) Fonctions de conversion Rappels : DÉFINITION DE TYPE : déf N = Z + Compléter l'implantation de N : IMPLANTATION DU TYPE : type nat =... (*... *) Observer la réaction de l'interprète après avoir saisi l'implantion de la fonction suivante : Profil moyenne : N N R Sémantique calcule la moyenne du couple d'entiers donné RÉALISATION INFORMATIQUE Algorithme : la moyenne est le milieu du segment [a,b] Implantation : let (moyenne : nat * nat -> float) = function (a,b) -> (a +. b) /. 2.0 Pour convertir un entier en réel, CAML offre la fonction float_of_int. Devinez le profil de cette fonction et vérifiez votre réponse en l'appliquant à un entier, puis à un réel. Donnez un spécification de float_of_int. Puis donner une spécification et une ou plusieurs réalisations correctes de la fonction moyenne. Les tester avec des jeux d'essai significatifs. P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 3
En s'inspirant du nom de la fonction float_of_int, deviner le nom de la fonction permettant de convertir un réel en un entier. En donner une spécification, puis la tester. (iii) Textes et Chaines En CAML, les guillemets (") servent à délimiter une valeur constante de type Chaine (chaîne de caractères, string en CAML) différent du type Texte qui correspond aux séquences de caractères (char list en CAML). Le typage du langage CAML est strict, il fait la distinction string char list. Rappels : DÉFINITION DE TYPE : déf Texte = Séq(Car) Implanter le type Texte en CAML. Le symbole dénotant l'opérateur de concaténation (mise bout à bout) de deux chaînes (^) n'est donc pas le même que l'opérateur qui sert à concaténer deux séquences (@). Rappels : Profil ^ : Chaîne Chaîne Chaîne Sémantique : ch 1 ^ ch 2 est la concaténation des chaînes ch 1 et ch 2 Profil @ : Texte Texte Texte Sémantique : txt 1 @ txt 2 est la concaténation des textes txt 1 et txt 2 Observer la différence entre le type Chaîne et N au travers des expressions suivantes : 358 "358" 32+45 "32"+"45" "32"^"45" Observer la différence entre le type Chaîne, le type Texte et un identificateur au travers des expressions suivantes : "nom" ['n';'o';'m'] nom (['n';'o';'m'] : texte) ("nom":texte) Expliquez le rôle de l'opérateur (_:_) En s'inspirant du nom de la fonction float_of_int, deviner les noms des deux fonctions permettant la conversion (dans un sens ou dans l'autre) entre un nombre sous forme de chaine de caractères (string) et l'entier en base 10 (int) correspondant. Donner leur spécification, puis tester ces fonctions sur quelques exemples simples et expliciter d'éventuelles contraintes sur les données. Modifier leur spécification en conséquence. Donner des exemples d'expressions ne respectant pas ces contraintes et observer la réaction du système lors de leur évaluation. On appelle chiffre décimal les chiffres 0,, 9. DÉFINITION DE TYPE déf. EntierCh = {chaîne formée uniquement de chiffres décimaux} IMPLANTATION DU TYPE type entierch = string (* formée uniquement de chiffres décimaux *) Réaliser la fonction moyenne_de_chaine spécifiée ci-dessous, puis la tester : P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 4
Profil moyenne_de_chaine : EntierCh EntierCh R Sémantique : moyenne_de_chaine (ch1,ch2) est la moyenne des deux entiers correspondant au couple de chaînes (ch1,ch2). Exemple : moyenne_de_chaine ("35", "46") = 40.5 Indication : réutiliser la fonction moyenne déjà programmée. Spécifier et réaliser la fonction moyenne_détaillée qui prend les mêmes arguments mais rend un résultat de la forme "la moyenne de 35 et 46 est 40.5". Indication : quel est le type du résultat? EP1.4 Moyenne olympique (suite DM distribué en cours) (i) Composition de fonctions Implater la fonction moyol en termes des fonctions min2, max2, min4, max4. Les réalisations de ces fonctions ayant beaucoup de points communs et pour ne pas tout réécrire, utiliser les possibilités de copie et de collage de l'éditeur. Tester la fonction moyol avec des jeux d'essai significatifs. (ii) Trace de l'évaluation d'une fonction Pour que la fonction de nom moyol soit «tracée» chaque fois qu'elle est évaluée, il faut appliquer la directive #trace au nom de la fonction : #trace moyol Remarque : les directives CAML commencent toutes par # ; il faut taper un # en plus de celui qui correspond à l'invite de l'interprète. Inversement, pour ne plus tracer l'évaluation, il faut appliquer la commande #untrace : #untrace moyol. Ici encore, ne pas oublier le #. Tracer moyol ainsi que toutes les fonctions intermédiaires utilisées par moyol, puis appliquer moyol à un jeu d'essai. Indenter la trace fournie par l'interprète (en utilisant des marges adéquates) de manière à faire apparaître l'emboîtement des appels successifs. EP1.5 Relations sur des intervalles d'entiers (suite exercice TD) (i) Relation d'ordre sur les nombres, opérateurs logiques Rappels : en CAML, les opérateurs de comparaison des valeurs numériques sont notés =, <>, <, <=, >, >=. Par ailleurs, true et false dénotent les deux valeurs booléennes. Les opérateurs logiques sont notés && (et), (ou), not (non). Observer le résultat (type et valeur) des expressions suivantes : true false "false" vrai true and true true && true 2 < 3 2 >= 3 2 > = 3 2 <> 2 2<3<4 2<3 && 3<4 2=3=true 2=(3=true) not (4 <= 2) not 4 <= 2 Implanter les expressions booléennes suivantes en CAML, en parenthésant les opérations de diverses manières. En déduire les priorités des opérateurs logiques && (et), (ou), not (non). - non vrai et faux - vrai ou vrai et faux Mettre en évidence la règle d'évaluation des opérateurs && et : le deuxième terme est-il toujours évalué, ou au contraire n'est-il évalué que si nécessaire? Pour cela observer la réaction de l'interprète avec les expressions suivantes : 10 mod 0 10 mod 5 P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 5
let (essaiet1 : int * int -> bool) = function (a,b) -> b <> 0 && a mod b = 0 essaiet1 (10,5) essaiet1 (10,3) essaiet1 (10,0) let (monet : bool * bool -> bool) = function (x,y) -> x && y let (essaiet2 : int * int -> bool) = function (a,b) -> monet (b <> 0,a mod b = 0) essaiet2 (10,0) Que calculent les fonctions essaiet1 et essaiet2? (ii) n-uplets Rappels : un n-uplet de valeurs est un vecteur à n composantes, séparées par une virgule. Le type d'un n-uplet est le produit cartésien ( ) des types de chacune des composantes. Observez le résultat des expressions CAML suivantes : (10,20,30) ((10,20),30) "10", 20,30.0 (10+1,"2"^"1",string_of_float (30.0)) 4,0 /. 2,0 (4,0) /. (2,0) 4,0.0/. 2,0 4,0.0/. 2.0,0 Puisque les virgules sont utilisés pour écrire des vecteurs, il faut trouver un symbole différent de la virgule pour séparer la partie entière de la partie décimale d'un réel. Conclure sur les significations respectives des symboles point (.) et virgule (,) et sur le rôle des parenthèses. (iii) Nommer un type ou une valeur ; relations entre points et intervalles Relire l'exercice correspondant dans le polycopié de TD. Compléter l'implantation de l'ensemble Intervalle : type intervalle =... (* {(bi,bs)} tels que bi<=bs *) Donner un ensemble significatif de jeux d'essai permettant de tester les fonctions précède, dans et suit. Nommer les jeux d'essai en utilisant la construction let, par exemple : let (cst_i:intervalle) = (-30, 50) let x1= -40 Compléter l'implantation suivante de la fonction précède. let (précède :...) = function (x, (bi, bs)) ->... Remarquer comment la définition de l'ensemble Intervalle facilite la compréhension du profil de la fonction. Observer l'évaluation des expressions : précède (3,4,5) précède (3,(4,5)). Tester les trois fonctions avec les jeux d'essai définis plus haut. (iv)relations entre intervalles, couples d'intervalles Donner un ensemble significatif de jeux d'essai permettant de tester les fonctions côteàcôte et chevauche (cf exercice polycopié). Pour cela fixer la valeur d'un intervalle I 1, par exemple I 1 = (10,20) ; puis énumérer diverses valeurs significatives d'intervalles I 2, I 3, etc, en plaçant les segments correspondants par rapport au segment correspondant à I 1. Nommer chacun des jeux d'essai en utilisant la construction let (cst_i...) =... Implanter les deux fonctions et les tester. P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 6
EP1.6 Expressions conditionnelles Observer la réaction du système après la saisie des réalisations ci-dessous d'une fonction d'essai : Profil essaicond : N Chaîne Implantations : let (essaicond : nat -> string) = function a -> if a < 10 then "ajourné" else a let (essaicond : nat -> string) = function a -> if a < 10 then a else "reçu" let (essaicond : nat -> string) = function a -> if a < 10 then a let (essaicond : nat -> string) = function a -> if a < 10 then "ajourné" else "reçu" Une seule de ces implantations est correctement typée. Laquelle? NB : observez comment la construction if_then_else est indentée : c'est de cette façon qu'il est conseillé d'écrire les if_then_else. Déterminez la règle non respectée dans les autres implantations, puis vérifiez vos réponses en les donnant une par une à l'interprète CAML. EP1.7 Signe du produit (variation de l'exercice vu en TD) On reprend la fonction signprod de l'exercice vu en TD, en modifiant le format d'affichage, distinguant le cas d'un résultat nul. Profil signprodv2 :... Sémantique : signprodv2 (x,y) est le signe de x y. Exemple : a) signprodv2 (-2, -3) = "-2*-3 : strictement positif" b) x Z, signprodv2 (x, 0) = "x*0 : nul" c) signprodv2 (2, -3) = "2*-3 : strictement négatif" (i) Version 1 : analyse dirigée par le résultat Donner une liste de jeux d'essai significatifs pour tester la fonction signprodv2. Implanter une première version de signprodv2 en s'inspirant de l'algorithme 1 étudié en TD, puis utiliser les jeux d'essai pour la tester. (ii) Version 2 : analyse dirigée par les données Implanter une deuxième version de signprodv2 en s'inspirant de l'algorithme 2 étudié en E1.6, puis utiliser les jeux d'essai pour la tester. P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 7
Les jeux d'essai proposés pour la version 1 testent-ils tous les cas apparaissant dans cette deuxième version? Si des cas ne sont pas testés compléter les jeux d'essai. EP1.8 Une date est-elle correcte? (suite exercice TD) Définir en CAML une liste de jeux d'essai significatifs pour tester la fonction estjourdansmois. Implantez et testez la version 2. Que répond CAML à estjourdansmois_2 (18, 13), estjourdansmois_2 (0, 4)? Comment interprétez-vous ces résultats? Donner une troisième implantation basée sur l'algorithme suivant : Algorithme 3 : composition conditionnelle sous forme de filtrage. L'utilisation d'expressions conditionnelles est interdite. Vérifier que estjourdansmois_3 donne les mêmes résultats que estjourdansmois_2 sur les jeux d'essais définis plus haut, y compris pour (18, 13) et (0, 4). Donner une nouvelle implantation (n 4) du type Mois par énumération (voir cours). Modifier l'implantation de estjourdansmois_3 en conséquences. Vérifier que estjourdansmois_4 donne les mêmes résultats sur la même liste de jeux d'essais que estjourdansmois_2. Que répond CAML à estjourdansmois_4 (18, 13), estjourdansmois_4 (0, 4)? Quel jeu d'essai correspond au jour 0 du mois d'avril pour estjourdansmois_4? Tester estjourdansmois_4 sur ce jeu d'essai. Comment interprétez-vous les réponses de CAML? Modifier l'implantation de la fonction estdate vue en TD pour qu'elle puisse utiliser estjourdansmois_4 au lieu de estjourdansmois_2, puis tester. EP1.9 Numération en base 16 (i) Caractères Observer la différence entre le type Car, le type N et le type Chaîne au travers des expressions suivantes : 3 '3' "3" '32' '3'+45 '3'^"45" 'x' "x" x (ii) Valeur entière associée à un chiffre hexadécimal Les chiffres hexadécimaux sont les signes élémentaires utilisés pour noter les nombres dans la numération par position en base 16 : on utilise les chiffres décimaux (0, 1,, 9) et les 6 premières lettres de l'alphabet (A, B,, F). On définit les types Carhex et Base16 : DÉFINITION DE TYPE déf Carhex = Chiffre {'A',..., 'F'} déf Base16 = {0,...,15} On spécifie une fonction nommée carhexvbase16 de la manière suivante : Profil carhexvbase16 : Carhex Base16 Sémantique : carhexvbase16 (c) est l'entier associé au caractère hexadécimal c Donner une implantation des types Carhex et Base16 Donner une réalisation de cette fonction en veillant à ne pas réécrire du code déjà écrit. EP1.10 Nommer une expression Pour chacune des expressions suivantes, observer les réactions de l'interprète, et expliquer les résultats en explicitant les liaisons de noms. let x=3 and y=4 in x+y let (x,y)=(3,4) in x+y let x=3 and y=x+4 in x+y P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 8
let x=10 in let x=3 and y=x+4 in x+y let x=10 in (let x=3 and y=x+4 in x+y) + x let x=10 in let x=3 and y=x+4 in x+y + x x Observez comment la construction let est indentée : c'est de cette façon qu'il est conseillé d'écrire les let. EP1.11 Somme des chiffres d'un nombre (suite exercice TD) Relire l'exercice E1.3. Compléter la réalisation de la fonction div : RÉALISATION INFORMATIQUE Algorithme : utilisation des opérateurs / «division entière» et mod «reste», définis en CAML. Implantation : (* /!\ conditions d'utilisation de div(n,d) :... *) let (div :... ->...) = function... Impanter la fonction sc. Tracer les fonctions div et sc et observer les appels successifs de div lors de l'application de sc à un jeu d'essai. EP1.12 Permutation ordonnée d'un couple d'entiers (i) Permutation ordonnée d'un couple d'entiers On veut construire la permutation ordonnée d'un couple d'entiers donné : par exemple, (3, 4) est la permutation ordonnée de (4, 3). On introduit ainsi une fonction nommée pocouplee : Profil Sémantique : Exemple : a) pocouplee(3,4) =... b) pocouplee(4,3) =... pocouplee : Z Z Z Z Soit (x',y') = pocouplee(x,y). (x',y') est la permutation ordonnée de (x,y), définie comme suit : (x',y')= (x,y) si x y, = (y,x) sinon. Compléter puis tester la réalisation de cette fonction : RÉALISATION INFORMATIQUE Algorithme : expression... Implantation : let (pocouplee : int * int -> int * int) = function (x,y) ->... Observer la réaction de l'interprète lors de l'évaluation de l'expression suivante : pocouplee (33.3,14.5) (ii) Surcharge des opérateurs de comparaison P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 9
Observer le résultat (type et valeur) des expressions suivantes : 2 < 3 2.0 < 3.0 Le même symbole < est utilisé pour dénoter deux opérations de comparaison différentes l'une portant sur des entiers, l'autre sur des réels, alors que pour les opérations arithmétiques l'addition par exemple deux symboles différents sont utilisés. On dit que le symbole < est surchargé. Les deux opérandes doivent avoir le même type et la signification précise du symbole en est déduite. Vérifier sur plusieurs exemples que tous les opérateurs de comparaison sont surchargés (égalité, relation d'ordre), la seule règle étant que les opérandes soient de même type. Réaliser la fonction pocoupler pour construire la permutation ordonnée d'un couple de réels. Pour cela, exploiter la surcharge des opérateurs de comparaison : par rapport à la fonction pocouplee, seuls le nom de la fonction et son profil doivent être changés. (iii) Fonctions génériques : paramètres dont le type est générique Observer la réaction du système pour la fonction suivante let (pocouple : 'Élém * 'Élém -> 'Elém * 'Elém) = function (x,y) -> if x <= y then (x,y) else (y,x) Dans le profil de la fonction, les types sont indiqués par des identificateurs (autres que ceux des types définis par ailleurs), précédés par un accent aigu ('). Ceci signifie que la spécification proposée ne dépend pas du type des paramètres : on parle de fonctions génériques ou de polymorphisme. On observe que la réponse du système utilise la même convention, les noms des types donnés initialement étant ignorés ('Élém * 'Élém dans l'exemple) et remplacés par des lettres ('a * 'a). Attention à ne pas confondre 'a (pour nommer un type polymorphe), a (pour nommer un paramètre) et 'a' (la constante de type caractère première lettre de l'alphabet en minuscule). Observer la réaction du système pour les expressions suivantes : pocouple (3,2) pocouple (33.3,14.5) pocouple (3, 14.5) Deviner le profil des opérateurs <,, >, et, puis vérifiez vos conjectures à l'aide de CAML. Appliquer la fonction pocouple à des couples de caractères. Observer que la relation d'ordre sur les caractères, définie par CAML, est celle sur les codes des caractères (voir EP1.14). Ceci est vrai pour tous les opérateurs de comparaison (<,, >, ). EP1.13 Définition du type Durée et des opérations associées (énoncé : DM distribué en cours) EP1.14 Codage des caractères (i) Le code ASCII d'un caractère La fonction int_of_char associe à tout caractère l'entier qui lui est associé dans le code ASCII qui sert à représenter le caractère en machine. En utilisant cette fonction, observez les codes des chiffres, des lettres majuscules et des lettres minuscules. CAML offre une fonction nommée char_of_int. L'appliquer sur des exemples simples : entier négatif, entier positif. Trouver le domaine de définition de la fonction, sachant que la borne supérieure est de la forme 2 k -1. (ii) Valeur entière associée à l écriture décimale d'un entier Observer l'évaluation des expressions suivantes : int_of_string ("8")int_of_string ('8') int_of_char ('8') int_of_char ('8') int_of_char ('0') Observer l'évaluation de l'expression char_of_int (8 + int_of_char ('0')) DÉFINITION DE TYPE P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 10
déf Chiffre = {'0',...,'9'} déf Base10 = {0,...,9} Profil chiffrevbase10: Chiffre Base10 base10vchiffre: Base10 Chiffre Sémantique : chiffrevbase10 (c) est l'entier associé au caractère décimal c, base10vchiffre (n) est le caractère décimal associé à l'entier n Déduire de la question précedente une manière de réaliser les fonctions chiffrevbase10 et base10vchiffre, sans utiliser d'expression conditionnelle. Implanter les types Chiffre et Base10, puis les fonctions chiffrevbase10 et base10vchiffre. EP1.15 Texte représentant un entier en base 16 DÉFINITION DE TYPE déf Hexa4 = {0,..., 16 4-1} Profil écriture_hex : Hexa4 Chaîne Sémantique : écriture_hex (n) est la chaîne de caractères représentant n en hexadécimal ; n est un entier dont la représentation hexadécimale comporte au plus quatre chiffres. Réaliser le type Hexa4 puis en se basant sur la structure générale de la fonction sc de l'exercice EP1.11, réaliser la fonction écriture_hex. Indications : Introduire une fonction base16vcarhex, inverse de la fonction carhexvbase16 étudiée en EP1.9). On prendra soin de ne pas réécrire du code déjà écrit. Pour construire une chaîne à partir d'un caractère, utiliser la fonction suivante : Profil carvchaîne : Car Chaîne Sémantique : carvchaîne(c) est la chaîne composée du seul caractère c. RÉALISATION INFORMATIQUE Implantation : let (carvchaîne : char -> string) = function c -> String.make 1 c P.-C. Scholl, F. Puitg, M. Périn janvier 2009 page 11