http://os-vps418.infomaniak.ch:1250/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=NicolasWiki du LAMA (UMR 5127) - Contributions [fr]2026-04-18T20:59:36ZContributionsMediaWiki 1.39.4http://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3857INFO401 corr TD TP2009-02-24T17:05:38Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Exercice 1 : Tuples'''<br /><br />
'''Question 4 :'''<br />
<br />
On définit la fonction curry par:<br />
<br />
<source lang="ocaml"><br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
</source><br />
<br />
Ou encore en simplifiant:<br />
<br />
<source lang="ocaml"><br />
Let curry f x y = f(x,y);;<br />
</source><br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
<source lang="ocaml"><br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = function (a,b) -> f a b;;<br />
</source><br />
<br />
<br />
Avantage de la première forme (à plusieurs arguments): Elle permet une application partielle: on peut appliquer cette fonction à une seule partie des arguments.<br />
<br />
Inconvénients de la seconde forme (à un argument): <br />
*il faut faire appel à fst, snd;<br />
*Caml doit séparer les paires: c'est une perte de temps<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
</source><br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br /><br />
<br />
'''Exercice 2 : Listes'''<br /><br />
'''Question 5 :'''<br /><br /><br />
suite à l'étude des fonctions <br />
*longueur<br />
<source lang="ocaml"><br />
let rec longueur l=<br />
match l with<br />
[] ->0<br />
| _ :: l -> 1+longueur l<br />
</source><br />
*applique<br />
<source lang="ocaml"><br />
let rec app f p =<br />
match p with <br />
[] -> []<br />
| a :: p -> f(a) :: app f p<br />
</source><br />
*concatene<br />
<source lang="ocaml"><br />
let rec cat l1 l2 =<br />
match l1 with<br />
[] -> l2<br />
| a :: l -> a :: (cat l l2)<br />
</source><br />
*renverse,<br />
<source lang="ocaml"><br />
let rec renverse l =<br />
match l with<br />
[] -> []<br />
| a :: l -> (renverse l)@[a]<br />
</source><br />
on remarque des similitudes. Ces fonctions ont le même schéma de base ( celui de la fonction reduit) <br />
<source lang="ocaml"><br />
let rec reduit l o f =<br />
match l with<br />
[] -> o<br />
| a :: l -> f a (reduit l o f)<br />
</source><br />
''NB :'' val reduit : 'a list -> 'b -> ('a -> 'b -> 'b) -> 'b = <fun><br />
<br />
'''Question 6 :'''<br/><br />
Reprogrammons les fonctions précédentes à partir de la fonction reduit ! <br/><br />
<source lang="ocaml"> <br />
let longueur l =<br />
let f _ r = 1 + r in <br />
reduit l o f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let app g l =<br />
let f <br />
reduit l [] f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let cat l1 l2 =<br />
let f a r = a :: r in <br />
reduit l1 l2 f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let renverse l =<br />
let f r a = [r]@[a] <br />
reduit l [] f<br />
</source><br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3856INFO401 corr TD TP2009-02-24T17:05:21Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Exercice 1 : Tuples'''<br /><br />
'''Question 4:'''<br />
<br />
On définit la fonction curry par:<br />
<br />
<source lang="ocaml"><br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
</source><br />
<br />
Ou encore en simplifiant:<br />
<br />
<source lang="ocaml"><br />
Let curry f x y = f(x,y);;<br />
</source><br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
<source lang="ocaml"><br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = function (a,b) -> f a b;;<br />
</source><br />
<br />
<br />
Avantage de la première forme (à plusieurs arguments): Elle permet une application partielle: on peut appliquer cette fonction à une seule partie des arguments.<br />
<br />
Inconvénients de la seconde forme (à un argument): <br />
*il faut faire appel à fst, snd;<br />
*Caml doit séparer les paires: c'est une perte de temps<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
</source><br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br /><br />
<br />
'''Exercice 2 : Listes'''<br /><br />
'''Question 5 :'''<br /><br /><br />
suite à l'étude des fonctions <br />
*longueur<br />
<source lang="ocaml"><br />
let rec longueur l=<br />
match l with<br />
[] ->0<br />
| _ :: l -> 1+longueur l<br />
</source><br />
*applique<br />
<source lang="ocaml"><br />
let rec app f p =<br />
match p with <br />
[] -> []<br />
| a :: p -> f(a) :: app f p<br />
</source><br />
*concatene<br />
<source lang="ocaml"><br />
let rec cat l1 l2 =<br />
match l1 with<br />
[] -> l2<br />
| a :: l -> a :: (cat l l2)<br />
</source><br />
*renverse,<br />
<source lang="ocaml"><br />
let rec renverse l =<br />
match l with<br />
[] -> []<br />
| a :: l -> (renverse l)@[a]<br />
</source><br />
on remarque des similitudes. Ces fonctions ont le même schéma de base ( celui de la fonction reduit) <br />
<source lang="ocaml"><br />
let rec reduit l o f =<br />
match l with<br />
[] -> o<br />
| a :: l -> f a (reduit l o f)<br />
</source><br />
''NB :'' val reduit : 'a list -> 'b -> ('a -> 'b -> 'b) -> 'b = <fun><br />
<br />
'''Question 6 :'''<br/><br />
Reprogrammons les fonctions précédentes à partir de la fonction reduit ! <br/><br />
<source lang="ocaml"> <br />
let longueur l =<br />
let f _ r = 1 + r in <br />
reduit l o f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let app g l =<br />
let f <br />
reduit l [] f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let cat l1 l2 =<br />
let f a r = a :: r in <br />
reduit l1 l2 f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let renverse l =<br />
let f r a = [r]@[a] <br />
reduit l [] f<br />
</source><br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3855INFO401 corr TD TP2009-02-24T17:03:13Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Question 4:'''<br />
<br />
On définit la fonction curry par:<br />
<br />
<source lang="ocaml"><br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
</source><br />
<br />
Ou encore en simplifiant:<br />
<br />
<source lang="ocaml"><br />
Let curry f x y = f(x,y);;<br />
</source><br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
<source lang="ocaml"><br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = function (a,b) -> f a b;;<br />
</source><br />
<br />
<br />
Avantage de la première forme (à plusieurs arguments): Elle permet une application partielle: on peut appliquer cette fonction à une seule partie des arguments.<br />
<br />
Inconvénients de la seconde forme (à un argument): <br />
*il faut faire appel à fst, snd;<br />
*Caml doit séparer les paires: c'est une perte de temps<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
</source><br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br /><br />
<br />
'''Exercice 2 : Listes'''<br /><br />
'''Question 5 :'''<br /><br /><br />
suite à l'étude des fonctions <br />
*longueur<br />
<source lang="ocaml"><br />
let rec longueur l=<br />
match l with<br />
[] ->0<br />
| _ :: l -> 1+longueur l<br />
</source><br />
*applique<br />
<source lang="ocaml"><br />
let rec app f p =<br />
match p with <br />
[] -> []<br />
| a :: p -> f(a) :: app f p<br />
</source><br />
*concatene<br />
<source lang="ocaml"><br />
let rec cat l1 l2 =<br />
match l1 with<br />
[] -> l2<br />
| a :: l -> a :: (cat l l2)<br />
</source><br />
*renverse,<br />
<source lang="ocaml"><br />
let rec renverse l =<br />
match l with<br />
[] -> []<br />
| a :: l -> (renverse l)@[a]<br />
</source><br />
on remarque des similitudes. Ces fonctions ont le même schéma de base ( celui de la fonction reduit) <br />
<source lang="ocaml"><br />
let rec reduit l o f =<br />
match l with<br />
[] -> o<br />
| a :: l -> f a (reduit l o f)<br />
</source><br />
''NB :'' val reduit : 'a list -> 'b -> ('a -> 'b -> 'b) -> 'b = <fun><br />
<br />
'''Question 6 :'''<br/><br />
Reprogrammons les fonctions précédentes à partir de la fonction reduit ! <br/><br />
<source lang="ocaml"> <br />
let longueur l =<br />
let f _ r = 1 + r in <br />
reduit l o f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let app g l =<br />
let f <br />
reduit l [] f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let cat l1 l2 =<br />
let f a r = a :: r in <br />
reduit l1 l2 f<br />
</source><br />
<br />
<source lang="ocaml"> <br />
let renverse l =<br />
let f r a = [r]@[a] <br />
reduit l [] f<br />
</source><br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3854INFO401 corr TD TP2009-02-24T16:51:39Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Question 4:'''<br />
<br />
On définit la fonction curry par:<br />
<br />
<source lang="ocaml"><br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
</source><br />
<br />
Ou encore en simplifiant:<br />
<br />
<source lang="ocaml"><br />
Let curry f x y = f(x,y);;<br />
</source><br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
<source lang="ocaml"><br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = function (a,b) -> f a b;;<br />
</source><br />
<br />
<br />
Avantage de la première forme (à plusieurs arguments): Elle permet une application partielle: on peut appliquer cette fonction à une seule partie des arguments.<br />
<br />
Inconvénients de la seconde forme (à un argument): <br />
*il faut faire appel à fst, snd;<br />
*Caml doit séparer les paires: c'est une perte de temps<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
</source><br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br /><br />
<br />
'''Exercice 2 : Listes'''<br /><br />
'''Question 5 :'''<br /><br /><br />
suite à l'étude des fonctions <br />
*longueur<br />
<source lang="ocaml"><br />
let rec longueur l=<br />
match l with<br />
[] ->0<br />
| _ :: l -> 1+longueur l<br />
</source><br />
*applique<br />
<source lang="ocaml"><br />
let rec app f p =<br />
match p with <br />
[] -> []<br />
| a :: p -> f(a) :: app f p<br />
</source><br />
*concatene<br />
<source lang="ocaml"><br />
let rec cat l1 l2 =<br />
match l1 with<br />
[] -> l2<br />
| a :: l -> a :: (cat l l2)<br />
</source><br />
*renverse,<br />
<source lang="ocaml"><br />
let rec renverse l =<br />
match l with<br />
[] -> []<br />
| a :: l -> (renverse l)@[a]<br />
</source><br />
on remarque des similitudes. Ces fonctions ont le même schéma de base ( celui de la fonction reduit) <br />
<source lang="ocaml"><br />
let rec reduit l o f =<br />
match l with<br />
[] -> o<br />
| a :: l -> f a (reduit l o f)<br />
</source><br />
''NB :'' val reduit : 'a list -> 'b -> ('a -> 'b -> 'b) -> 'b = <fun><br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3853INFO401 corr TD TP2009-02-24T16:48:11Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Question 4:'''<br />
<br />
On définit la fonction curry par:<br />
<br />
<source lang="ocaml"><br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
</source><br />
<br />
Ou encore en simplifiant:<br />
<br />
<source lang="ocaml"><br />
Let curry f x y = f(x,y);;<br />
</source><br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
<source lang="ocaml"><br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = function (a,b) -> f a b;;<br />
</source><br />
<br />
<br />
Avantage de la première forme (à plusieurs arguments): Elle permet une application partielle: on peut appliquer cette fonction à une seule partie des arguments.<br />
<br />
Inconvénients de la seconde forme (à un argument): <br />
*il faut faire appel à fst, snd;<br />
*Caml doit séparer les paires: c'est une perte de temps<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
</source><br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br /><br />
<br />
'''Exercice 2 : Listes'''<br /><br />
'''Question 5 :'''<br /><br /><br />
suite à l'étude des fonctions <br />
*longueur<br />
<source lang="ocaml"><br />
let rec longueur l=<br />
match l with<br />
[] ->0<br />
| _ :: l -> 1+longueur l<br />
</source><br />
*applique<br />
<source lang="ocaml"><br />
let rec app f p =<br />
match p with <br />
[] -> []<br />
| a :: p -> f(a) :: app f p<br />
</source><br />
*concatene<br />
<source lang="ocaml"><br />
let rec cat l1 l2 =<br />
match l1 with<br />
[] -> l2<br />
| a :: l -> a :: (cat l l2)<br />
</source><br />
*renverse,<br />
<source lang="ocaml"><br />
let rec renverse l =<br />
match l with<br />
[] -> []<br />
| a :: l -> (renverse l)@[a]<br />
</source><br />
on remarque des similitudes. Ces fonctions ont le même schéma de base ( celui de la fonction reduit) <br />
<source lang="ocaml"><br />
let rec reduit l o f =<br />
match l with<br />
[] -> o<br />
| a :: l -> f a (reduit l o f)<br />
</source><br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3846INFO401 corr TD TP2009-02-24T16:14:25Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Question 4:'''<br />
<br />
On définit la fonction curry par:<br />
<br />
<source lang="ocaml"><br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
</source><br />
<br />
Ou encore en simplifiant:<br />
<br />
<source lang="ocaml"><br />
Let curry f x y = f(x,y);;<br />
</source><br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
<source lang="ocaml"><br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
</source><br />
<br />
<source lang="ocaml"><br />
Let uncurry f = function (a,b) -> f a b;;<br />
</source><br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
</source><br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3844INFO401 corr TD TP2009-02-24T16:09:56Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
'''Question 4:'''<br />
<br />
On définit la fonction curry par:<br />
<br />
Let curry (f: 'a * 'b -> 'c) : 'a -> 'b -> 'c<br />
= fun x y -> f(x,y);;<br />
<br />
Ou encore en simplifiant:<br />
<br />
Let curry f x y = f(x,y);;<br />
<br />
<br />
On définit ensuite la fonction uncurry par:<br />
<br />
Let uncurry (f: 'a -> 'b -> 'c) : 'a * 'b -> 'c<br />
= fun x -> f (fst x) (snd x);;<br />
<br />
Ou encore de trois autres manières plus simplifiées:<br />
<br />
Let uncurry f = fun x -> f (fst x) (snd x);;<br />
<br />
Let uncurry f = fun x -> match x with (a,b) -> f a b;;<br />
<br />
Let uncurry f = function (a,b) -> f a b;;<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1) <br /><br /><br />
<br />
''exemple : ''fib 10 = (55, 88) pour exécuter la fonction Fibonacci(10), il y a 88 appels récursifs nécessaires...<br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3842INFO401 corr TD TP2009-02-24T16:02:57Z<p>Nicolas : /* Le TD2 */</p>
<hr />
<div>==Préliminaires==<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
<br />
==Le TD1 et le TP0==<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
::Pour améliorer la précision je suggère de passer les coordonnées en type Float. --[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)<br />
<br />
<br />
==Le TD2==<br />
<br />
<br />
'''Question 5 :'''<br />
<br />
D'après la fonction récursive Fibonacci définit par <br /><br />
f(0)=0 <br /><br />
f(1)=1 <br /><br />
f(n+2)=f(n+1)+f(n), <br /><br />
comment compter le nombre d'appels récursifs en Caml? <br /><br />
<br />
let rec fib n =<br />
if (n<2) then (n,0)<br />
else let t = fib (n-1) in<br />
let s = fib (n-2) in <br />
(fst t + fst s , snd t + snd s + 1)<br />
<br />
==Le TP1 - début==<br />
<br />
--- à venir ---</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO401_corr_TD_TP&diff=3798INFO401 corr TD TP2009-01-31T10:42:41Z<p>Nicolas : /* Le TD1 et le TP0 */</p>
<hr />
<div>=Préliminaires=<br />
<br />
Pour afficher correctement dans le wiki, allez voir un peu comment on fait. Vous pouvez regarder par exemple sur le [[INFO401 | wiki du cours]] ou directement sur des articles de [http://fr.wikipedia.org/wiki/Accueil Wikipedia]. La documentation de mediawiki se trouve [http://meta.wikimedia.org/wiki/Aide:Éditeur ici].<br />
<br />
Un truc important : pour rentrer du code Caml, il faut mettre les balises <tt><nowiki><source lang="ocaml">...</source></nowiki>"</tt> autour de votre code. Allez par exemple voir le début de la section sur [[#Le TD1 et le TP0 | le TD1 et TP0]].<br />
<br />
<br />
Vous pouvez aller discuter des corrections dans les sujets de discussions associes...<br />
<br />
=Le TD1 et le TP0=<br />
<br />
Pour vous montrer un exemple de ce que j'attends, voila la correction de la fonction factorielle. (C'était facile...) J'ai volontairement mis beaucoup de commentaires...<br />
<br />
<br />
<u>La fonction factorielle (TD1, exercice 2, question 2)</u><br />
<br />
Le but est de calculer la fonction <math>!n = 1\times2\times \cdots \times n</math> par récurrence. La version typée est verbeuse de la fonction correspondante en Caml donne :<br />
<br />
<source lang="ocaml"><br />
(* fonction factorielle : c'est la factorielle habituelle des mathématiciens... *)<br />
let rec fact (n:int) : int =<br />
if (n>1)<br />
then n * (fact (n-1))<br />
else 1 (* rq : pour que le programme ne boucle pas sur les valeurs négatives, on renvoie 1 dés que n<1 *)<br />
</source><br />
<br />
Comme la fonction est récursive, il ne faut pas oublier le <tt>rec</tt> au début de la définition.<br />
<br />
<br />
On aurait pu faire une autre version, qui fonctionne différemment sur les nombres négatifs :<br />
<br />
<source lang="ocaml"><br />
let rec fact' = function<br />
n when (n>0) -> n * fact' (n-1)<br />
| n when (n<0) -> n * fact' (n+1)<br />
| _ -> 1 (* si n n'est ni plus petit que 0 ni plus grand que 0, n est égal à 0, et on renvoie donc 1 *)<br />
</source><br />
<br />
J'ai volontairement mis une version qui contient plusieurs choses que nous n'avons pas encore vues en cours :<br />
* utilisation de "<tt>function</tt>" plutôt que <tt>fun</tt>,<br />
* le symbole "<tt>|</tt>",<br />
* le mot clé "<tt>when</tt>".<br />
<br />
Vous devriez pouvoir comprendre ce que fait la fonction. Sinon, voici une version que vous auriez pu écrire :<br />
<br />
<source lang="ocaml"><br />
let rec fact_bis = fun n -><br />
if (n=0)<br />
then 1<br />
else begin<br />
if (n>0)<br />
then n*fact_bis (n-1)<br />
else n*fact_bis (n+1) (* dans ce cas, n est forcement négatif *)<br />
end<br />
</source><br />
<br />
<br />
<u> Les fonctions sommes </u><br />
<br />
Il s'agit ici d'écrire la fonction qui va additionner les carrés des entiers de 1 jusqu'à un nombre donné.<br />
<br />
Cela donne :<br />
<source lang="ocaml"><br />
let rec somme_carre b =<br />
if (b=0) then 0<br />
else (b*b) + somme_carre (b-1);;<br />
</source><br />
<br />
Ensuite on nous demande de calculer la somme des cubes des entiers de 1 jusqu'à un nombre donné. On pourrait faire le même programme en remplaçant b*b par b*b*b, mais on va définir une fonction puissance (car elle n'existe pas d'origine sous Caml), qui nous servira aussi pour la suite... :<br />
<br />
<source lang="ocaml"><br />
let rec puissance x a =<br />
if (a = 0) then 1<br />
else x * puissance x (a-1);;<br />
</source><br />
<br />
On doit maintenant calculer la somme des <math>i^i</math>, i variant de 1 à un nombre donné :<br />
<br />
<source lang="ocaml"><br />
let rec somme_puissance b =<br />
if (b=0) then 0<br />
else (puissance b b) + somme_puissance (b-1);;<br />
</source><br />
<br />
On peut définir une unique fonction qui permettrait de faire toutes ces sommes, celle-ci aura pour argument une fonction quelconque :<br />
<br />
<source lang="ocaml"><br />
let rec somme_fonction n f = (* f étant une fonction *)<br />
if (n=0) then f 0<br />
else f n + somme_fonction (n-1) f;;<br />
</source><br />
<br />
cette fonction est de type "<tt>int -> fun -> int</tt>"<br />
<br />
<u> Nombres pairs et impairs (TP0 Partie 2 Question 2) </u><br />
<br />
Il faut écrire les fonctions récursives pairs et impairs, qui renvoient vrai si le nombre est pair (respectivement impair) et faux si le nombre est impair (respectivement pair);<br />
Ici nous devons déclarer simultanément les deux fonctions, car chacune fait appel à l'autre lors de son exécution.<br />
<br />
Cela donne :<br />
<br />
<source lang="ocaml"><br />
let rec pair n =<br />
if (n=0) then true<br />
else impair (n-1)<br />
and impair n =<br />
if (n=0) then false<br />
else pair (n-1);;<br />
</source><br />
<br />
<br />
<u> Suite de Fibonacci </u><br />
<br />
La suite de fibonacci est tel que u<sub>0</sub>=0 u<sub>1</sub>=1 et u<sub>n+2</sub>=u<sub>n+1</sub>+u<sub>n</sub>.<br />
<br />
<source lang="ocaml"><br />
let rec fib n =<br />
if (n=0) then 0<br />
else if (n=1) then 1<br />
else fib (n-1) + fib (n-2);;<br />
</source><br />
<br />
La plus grande valeur que l'on peut obtenir sans que cela soit trop long est 24157817, ce qui correspond à fib 37.<br />
Nous trouvons qu'il faut déjà 88 additions pour calculer fib 10.<br />
<br />
:'''Rq :''' fib de 37 prend effectivement beaucoup de temps. Il faut 39088168 additions avant d'en arriver à bout. Il est possible de faire une version de Fibonacci qui va très vite et qui calcule <tt>fib 37</tt> en seulement 36 additions...<br />
: Comment ?<br />
<br />
<u> Dragon ! </u><br />
<br />
<i> Le dragon est une créature mythique, présente dans de nombreuses cultures.<br />
On peut déterminer deux grands types de dragons : le dragon occidental et le dragon oriental</i><br />
<br />
La fonction dragon a pour but de dessiner un dragon, pour cela on utilise une fonction récursive qui admet pour argument le nombre n d'itération de la fonction, et les coordonnées de 2 points. A chaque itération, la fonction calcule pour chaque segment, un nouveau point et le relie ensuite aux deux autres.<br />
<br />
On obtient en tout 2<sup>n</sup> segments entremêlés, qui forment un dragon.<br />
<br />
Let's go !<br />
<br />
<source lang="ocaml"><br />
let rec dragon (n:int) (a:int) (b:int) (c:int) (d:int) : unit =<br />
if (n = 0) then (moveto a b ; lineto c d)<br />
else begin<br />
let x = (a+c+d-b)/2 in<br />
let y = (b+d+a-c)/2 in<br />
dragon (n-1) a b x y ;<br />
dragon (n-1) c d x y<br />
end ;;<br />
</source><br />
<br />
:'''Rq : ''' votre version du dragon est bien, mais pas très précises. (Je chipote un peu...) Pour les paramètres (<tt>dragon 11 100 100 400 400</tt>), de nombreux carrés ne sont pas bien tracés.<br />
:Comment expliquez-vous cela, et comment pouvez-vous le corriger ?<br />
<br />
__Pour améliorer la précision je suggère de passer les coordonnées en type Float __--[[Utilisateur:Nicolas|Nicolas]] 31 janvier 2009 à 11:42 (CET)</div>Nicolashttp://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=Discussion:INFO421_:_Programmation_fonctionnelle&diff=3696Discussion:INFO421 : Programmation fonctionnelle2009-01-21T12:46:49Z<p>Nicolas : /* Inscription sur le Wiki */</p>
<hr />
<div>== Comment commencer une discussion ==<br />
<br />
Pour commencer une discussion, il suffit de cliquer sur le '''<tt>+</tt>''' en haut de la page. Vous pouvez alors rentrer un sujet de discussion et éditer le texte comme pour le wiki.<br />
<br />
C'est mieux de signer vos intervention en utilisant l'avant dernier bouton d'édition, ou avec <tt><nowiki>--~~~~</nowiki></tt>.<br />
<br />
:Pour répondre, il faut « modifier » la section correspondante...<br />
:Par soucis de visibilité, il est parfois préférable de rajouter une marge à gauche (comme ici). Pour faire ça, il faut commencer votre ligne par un «<tt>:</tt>». (Ou un «<tt>::</tt>»...)<br />
<br />
--[[Utilisateur:Hyvernat|Hyvernat]] 12 janvier 2009 à 13:47 (CET)<br />
<br />
== Inscription sur le Wiki ==<br />
<br />
Voila, c'est juste pour dire que je me suis inscrit...<br />
<br />
--[[Utilisateur:Hyvernat|Hyvernat]] 21 janvier 2009 à 11:01 (CET)<br />
<br />
<br />
Inscription sur le Wiki<br />
--[[Utilisateur:LAYER|LAYER]] 21 janvier 2009 à 13:39 (CET)<br />
<br />
inscription terminée --[[Utilisateur:Laurent corantin|Laurent corantin]] 21 janvier 2009 à 13:40 (CET)<br />
<br />
:: Travail terminé! --[[Utilisateur:Caroline|Caroline]] 21 janvier 2009 à 13:42 (CET)<br />
<br />
:: Inscription ok --[[Utilisateur:JulienMorel|JulienMorel]] 21 janvier 2009 à 13:43 (CET)<br />
<br />
c bon<br />
<br />
inscription sur le wiki --[[Utilisateur:Thomas BILLOUD|Thomas BILLOUD]] 21 janvier 2009 à 13:44 (CET)<br />
<br />
inscription confirmée --[[Utilisateur:Costa jp|Costa jp]] 21 janvier 2009 à 13:44 (CET)<br />
<br />
inscrit ! --[[Utilisateur:Mauris Robin|Mauris Robin]] 21 janvier 2009 à 13:45 (CET)<br />
<br />
inscription--[[Utilisateur:Aulev|Aulev]] 21 janvier 2009 à 13:46 (CET)<br />
<br />
::hi all!!!--[[Utilisateur:Nicolas|Nicolas]] 21 janvier 2009 à 13:46 (CET)</div>Nicolas