Tutorial 07

Les boucles

Nouvelles commandes :

> While = Début d'une boucle "Tant que..." (condition testée au début) [PRGM] [5]
> Repeat = Début d'une boucle "Jusqu'à-ce que..." (condition testée à la fin) [PRGM] [6]
> For(V,N1,N2[,i] = Boucle qui incrémente une variable de la valeur de début à celle de fin [PRGM] [4]
> End = Termine une boucle ou If-Then-Else [PRGM] [7]
> IS>(V,N = Incrémenter et omettre [PRGM] [A]
> DS<(V,N = Décrémenter et omettre [PRGM] [B]

Introduction :

Nous allons voir les boucles. Ah ah! Qu'est-ce? Comme son nom l'indique, il s'agit d'instructions exécutées en boucles tant qu'une instruction est vraie ou jusqu'à ce qu'une instruction soit vraie.
Ensuite, nous allons voir deux autre commandes peu utilisées en programmation mais qui peuvent être bon à utiliser. Ce ne sont pas des boucles mais je n'avais pas envie de faire de tutorial spécial car quelques uns d'entres vous préfereront peut-être les passer. C'est dommage car elles peuvent faire perdre pas mal d'octets à votre programme.

While :

Toute boucle commence par une commande puis se termine par End. While, en anglais, signifie "Tant que...". Vous devrez donc ajouter une condition après cette commande. Nous allons voir cela, comme d'abitude, avec un exemple.
Voici le programme :
:ClrHome Comme d'abitude : sa fonction n'a pas changée!!
:While K<>105 Tant que K est différent de 105
:Output(5,5,"EN PAUSE") Ici, sont insérées les instructions exécutées en boucle
:getKey->K Un petit effort de mémoire : change la valeur de K avec la dernière touche préssée
:End Fin de boucle : Retourne au While si la condition toujours fausse. Sinon, continue le cours du programme
Vous devez appuyer sur [ENTER] (valeur 105 pour K) pour quitter la pause.
Sachez que la condition est testée au début de la boucle donc, si elle est vraie dès le début, la boucle ne sera même pas exécutée une seule fois. Si vous réésayez d'exécuter le programme, "EN PAUSE" ne sera même pas affiché car K est maintenant égal à 105 ([ENTER]). Pour éviter ceci et si vous utilisez des variables dans la condition, vérifiez si la condition n'est pas exacte dès le début. Pour cela, juste après ClrHome il aurai fallut insérer 0->K. C'est un type d'erreur à prendre en compte lorsque vous programmez! Essayez d'ajouter cette ligne et exécutez le programme plusieurs fois : il marche!!
Ici, g n'est utilisé qu'une seule fois. Le programme aurrai alors pu s'écrire comme ceci :
:ClrHome Pas de commentaires : devinez...
:Output(5,5,"EN PAUSE")
:While getKey<>105
:End
Dans cette version, pas besoin de réinitialiser K au démarrage.

Repeat :

Nous allons reprendre, une fois de plus, le précédent exemple (faut que sa rentre!) en le modifiant pour l'exécuter avec la boucle Repeat. Cette commande est sensiblement la même, mis à part qu'elle veut dire "Jusqu'à ce que..." et que la condition est testée à la fin, ce que permet d'exécuter la boucle au moins une fois : contrairement à While.
:ClrHome
:Repeat K=105 Ici, pas besoins d'initialiser K car la condition est testée à la fin et...
:Output(5,5,"EN PAUSE")
:getKey->K ... si aucune touche n'est préssée, K sera initialisé ici
:End
Vous remarquerez que K<>105 a été changé en K=105. Réfléchissez en traduissant ça en français et vous comprendrez qui si vous voulez passer de la boucle While à la boucle Repeat pour que les instructions soient exécutées au moins une fois ou pas (dans la plupart des cas, c'est ce paramètre qui doit décider du choix de l'un ou de l'autre) il vous faudra inverser les conditions. Puisque K<>105 est bien l'inverse de K=105. Vous pourrez aussi passer d'une boucle à l'autre pas la fonction n. En effet, K<>105 est bien égale à not(K=105) qui est l'invers de K<>105? Ça chauffe, on dirait? Méditez cela et nous pourons continuer!!

Boucle infinie :

Pour faire une boucle infinie, vous avez deux solutions :
:While 1
:Instructions
:End
Ou bien alors :
:Repeat 0
:Instructions
:End
Vous remarquerez, une fois de plus, que 1 est l'opposé de 0. Ce qui confirme la règle précédente.
Des deux, vous choisissez celle que vous voullez! Ils seront toutes deux exécutées infiniement.

For :

For est une boucle assez spéciale. Pour la comprendre, exécutez ce programme :
Programme exemple pour la boucle For :
:ClrHome Ça c'est pas nouveau
:For(X,1,10) Commancement de la boucle For : Stoque 1 dans X et...
:Output(5,X,X) ...Écrit la valeur de X à la ligne 5 et à la colone X...
:Pause ...Pour vous laisser le temps de voir les effets...
:End ...Incrémente X et réexécute la boucle jusqu'à ce que X soit supérieur à 10
:Disp X Vous pouvez voir la dernière valeur de X, qui n'est pas forcément la dernière valeur affichée
Arrivé à la valeur 10, la TI incrémente X, ce qui fait 11 et qui est suppérieur à 10, donc la boucle est terminée. La variable X terminera la boucle avec la valeur 11 : il faut en tenir compte si vous voulez réutiliser sa valeur ultéruieurement dans le programme.
En claire, et comme vous avez pu le constater, la boucle For(variable,valeur1,valeur2) stoque valeur1 dans variable et l'incrémente de 1 à chaque répétition de la boucle et ce jusqu'à ce que variable ai dépassé la valeur2.
Maintenant, passons au paramètre optionnel ,i. Ce paramètre est la valeur d'incrémentation. Ainsi, vous pouvez compter de deux en deux et non de un en un comme dans le précédent exemple. Nous allons le refaire avec l'incrémentation 2 :
Boucle For avec incrémentation :
:ClrHome
:For(X,1,10,2) Commancement de la boucle For : Stoque 1 dans X et...
:Output(5,X,X)
:Pause
:End ...Incrémente X de 2 et réexécute la boucle jusqu'à ce que X soit supérieur à 10
:Disp X Vous pouvez voir la dernière valeur de X, qui n'est pas forcément la dernière valeur affichée
Arrivé à la valeur 9, la TI incrémente X de 2, ce qui fait 11 et qui est suppérieur à 10, donc la boucle est terminée.
Grace au paramètre d'incrémentation, on peut compter à rebourg en lui donnant la valeur -1.
Compter à rebourg avec la boucle For :
:ClrHome Ça c'est pas nouveau
:For(X,9,0,-1) Attention : le moins s'obtient ici avec la touche [(-)] en blanc car il ne s'agit pas du signe de soustraction
:Output(5,8,X)
:Pause
:End
:Disp X
Avec l'incrémentation -1, la boucle se termine si la variable est inférieur à la valeur2.
Arrivé à la valeur 0, la TI décrémente X, ce qui fait -1 et qui est inférieur à 1, donc la boucle est terminée.

Incrémentation et décrémentation :

La commande IS>( ajoute 1 à la variable donnée. Si le résultat est supérieur à la valeur indiquée après (qui peut être une expression), la commande suivante est omise.
Exemple :
:Input A Demande une valeur pour initialiser A
:IS>(A,6) Incrémente la variable A. Si A est plus grand que la valeur 6...
:Disp "PAS > 6" ...Alors cette instruction est omise (dans la cas contraire elle est exécutée)
Entrez la valeur 5 puis 6. Avec la valeur 5, l'instruction suivante est exécutée (5+1=6 : pas plus grand que la valeur donnée qui est justement 6) tandis qu'avec la valeur 6, A est augmenté de 1 et devient égal à 7, qui est supérieur à 6 donc l'instruction suivante est omise.
La commande d est à peu près similaire, à ceci près qu'elle décrémente la variable donnée et que l'instruction suivante est omise si la variable est inférieure à la valeur donnée.
Exemple :
:Input A Demande une valeur pour initialiser A
:DS<(A,6) Incrémente la variable A. Si A est plus petit que la valeur 6...
:Disp "> 6" ...Alors cette instruction est omise (dans la cas contraire elle est exécutée)
Entrez la valeur 6 puis 7. Avec la valeur 6, A est diminué de 1 et devient égal à 5, qui est inférieur à 6 donc l'instruction suivante est omise tandis qu'avec la valeur 7, l'instruction suivante est exécutée (7-1=6 : pas plus petit que la valeur donnée qui est justement 6).
Je vous l'accorde : ces deux fonctions demandent beaucoup de gym des neuronnes pour bien être domptées. Gardez ces deux programmes si vous êtes décidés à les utiliser et changer le 6 si besoin est.

Conclusion :

Tutorial dont on pourrai ce passer. En effet, on peut faire des boucles comme l'on a toujours fait jusque là : avec des labels et des Goto. Mais ces boucles sont moins estétiques, prennent queleques octets de plus en mémoire et, surtout, si plus tard vous voulez devenir programmeur vous apprendrez que les étiquettes dans un programme en language évolué doivent être évités au plus possible (pour la lisibilité, notemment). C'est juste une bonne habitude à prendre!

Retour : Sommaire
Aide : Liste des commandes
Précédent : Tutorial 06 : Utiliser les touches dans un programme
Suivant : Tutorial 08 : Comportement aléatoire