Table des matières

Transcription

Table des matières

UJF, UFR IMA, Algorithmique et programmation fonctionnelle
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
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 ℕ = ℤ +
➢
Compléter l'implantation de ℕ :
IMPLANTATION DU TYPE :
type nat = ...... (* ......... *) ;;
➢
Observer la réaction de l'interprète après avoir saisi l'implantion de la fonction suivante :
SPÉCIFICATION MATHÉMATIQUE
Profil
moyenne : ℕ  ℕ → ℝ
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.
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 : ch1 ^ ch2 est la concaténation des chaînes ch1 et ch2
Profil
Sémantique :
➢
@ : Texte  Texte → Texte
txt1 @ txt2 est la concaténation des textes txt1 et txt2
Observer la différence entre le type Chaîne et ℕ 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 :
page
4
Profil
moyenne_de_chaine : EntierCh  EntierCh → ℝ
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 ;;
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 I1, par
exemple I1 = (10,20) ; puis énumérer diverses valeurs significatives d'intervalles I2, I3, etc,
en plaçant les segments correspondants par rapport au segment correspondant à I1. Nommer
chacun des jeux d'essai en utilisant la construction let (cst_I...) = .... Implanter les
deux fonctions et les tester.
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 : ℕ → Chaîne
Implantations :
let (essaicond : nat ->
a -> if a < 10 then
"ajourné"
else
a
;;
a -> if a < 10 then
a
else
"reçu"
;;
a -> if a < 10 then
a
;;
a -> if a < 10 then
"ajourné"
else
"reçu"
;;
➢
➢
string) = function
string) = function
string) = function
string) = function
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 ∈ ℤ , 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.
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 ℕ 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
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
d'écrire les let.
est indentée : c'est de cette façon qu'il est conseillé
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 :
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
poCoupleE : ℤ × ℤ → ℤ × ℤ
Sémantique : 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.
Exemple :
a) poCoupleE(3,4) = …...
b) poCoupleE(4,3) = …...
➢
Compléter puis tester la réalisation de cette fonction :
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
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 :
➢
➢
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 (<, ≤, >, ≥).
poCouple (3,2);; poCouple (33.3,14.5);; poCouple (3, 14.5);;
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 2k-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
page
10
déf
déf
Chiffre = {'0',...,'9'}
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.
Implantation :
let (carVchaîne : char -> string) = function
c -> String.make 1 c
;;
page
11

Table des matières

Transcription

Documents pareils

Fête de la musique 2013

annales ep1 ep2 ep3 veuillez cliquer sur la pub google

SPÉCIFICATION TYPE – BLOC AUTOCLAVE

Téléchargez la fiche produit

CAP Agent d`entreposage et de messagerie EP1 - Eco

Les rois de la plancha

Knock, knock ! Trick or treat ! It`s Halloween Let`s play a joke Let`s eat

Comme à la maison La plancha, il n`y a que ça ! Un

Les maestros dè la plancha

1 Let`s go to London zoo : évaluation Compréhension de l`oral

GuitarCure Première Soutenance Rapport de Soutenance