Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : AMOS - Les boucles
(Article écrit par Jean Monos et extrait de off-soft.com - janvier 2016)
|
|
Bonjour, attachez vos ceintures, nous allons parler des boucles pour notre AMOS chéri. Vous êtes prêts ? Non ?
Une boucle dans un programme informatique permet de boucler. Oui, vous allez me dire. C'est logique. Mais c'est quoi
boucler un programme ? Hum hum... eh bien de revenir au début et de pouvoir répéter des actions, et
donc de nous simplifier la tâche. Nous allons aujourd'hui passer en revue les boucles qui sont disponibles sur
le BASIC d'AMOS.
Les boucles
GOTO
Ne rigolez pas. C'est un enclencheur de boucle, donc je l'indique. GOTO permet de dire au programme "va ici maintenant".
Donc faites cette programmation pour voir.
ICI:
Inc X
Print X
GOTO ICI
|
Lancez ce petit programme. Vous allez voir, la machine va compter et afficher la valeur de X. Ceci dit,
GOTO est bien sur les plus vieilles machines avec le BASIC qui ne possède que ça, mais nous entrons vite fait
dans le chantier avec du code dit spaghetti. Pour sortir de cette boucle, il faut ajouter une condition et
un autre GOTO pour se brancher sur une autre partie du programme par exemple. Bon vous avez vu le topo.
Do Loop
Ah, nous entrons dans un autre domaine. J'avoue que j'aime beaucoup utiliser le "Do Loop". Surtout dans ma boucle principale.
En gros, c'est simple, quand le programme arrive à Loop, il repart au dernier "Do" rencontré.
Votre Amiga va de nouveau compter. Pour sortir de la boucle, c'est simple, c'est la commande "Exit",
genre "If X=100 then Exit".
Do
Inc X
Print X
If X=100 then Exit
Loop
|
A 100, c'est la fin ! Bon c'est quand même un peu comme GOTO, il faut quand même ajouter une ligne si nous
voulons sortir de cette boucle. Ou mieux, il existe une fonction pour cela.
Do
Inc X
Print X
Exit if X=100
Loop
|
For/Next
Alors celui-là, beaucoup de monde l'aime. Il permet de boucler le morceau du programme un nombre de fois prédéfini.
Voici l'exemple pour compter jusque 100 :
For X = 0 to 100
print X
Next
|
Quand le programme rencontre Next, le compteur incrémente "X" de un. Ce qui fait qu'à la sortie de la boucle, dans
cet exemple, X ne vaut pas 100 mais 101 !
Une autre chose à savoir quand le programme commence à lire "For X=0 to 100", si "x" vaut une autre valeur que 0,
il est réinitialisé à 0 (ou une autre valeur de départ). Donc il ne faut pas utiliser la boucle For/Next directement
pour des tests. Bon, nous pouvons ajouter "Step 2" sur la première ligne par exemple : une fois arrivé à "Next", le "X"
va être incrémenté de 2. Cela peut être utile.
For X = 0 to 100 Step 2
print X
Next
|
Sur les manuels en BASIC, le Next de la fin doit s'écrire "Next X" ou "X" est bien sur le nom de la variable.
Mais vous pouvez l'oublier et marquer seulement Next.
Le saviez-vous : sur Amstrad CPC, c'était un gain de temps machine en inscrivant directement "Next" que de faire "Next X" ?
C'est peut-être aussi le cas sur Amiga, nous ferons des tests de rapidité plus tard.
Bref, j'aime cette boucle pour poser des tuiles ("tiles") par exemple sur la zone de jeu, initier des tableaux,
enfin plein de choses. Et bien sûr, nous pouvons imbriquer des boucles les unes dans les autres.
Ceci est la routine qui permet d'afficher cinq tuiles sur cinq de 16 pixels de longueur et de hauteur avec la boucle For/Next.
J'ai bien écrit "Next X" et "Next Y" pour bien voir qu'il faut respecter les "Next" par rapport au "For".
Attention à cela quand votre code commence à être gros dans des boucles !
For Y=0 to 4
For X=0 to 4
Paste Icon X*16,Y*16,1
Next X
Next Y
|
While/Wend
Ceci permet de jouer la boucle tant que la condition est vraie. Une fois la condition fausse, la boucle n'est plus jouée
tout simplement.
While X<100
Inc X
Print X
Wend
|
Le programme va bien compter jusqu'à 100. Mais une fois sortie du programme, la valeur de "X" est de 100,
la condition n'est plus respectée, la boucle n'est pas jouée.
Repeat/Until
Repeat
Inc X
Print X
Until X>99
|
Attention cette fois-ci, la boucle fonctionne jusqu'à ce que la condition soit exacte. Dans cet exemple, nous rejouons la
boucle tant que "X" n'est pas supérieur à 99. Donc la boucle va se jouer une fois de plus à 99 pour nous
donner 100 et là, la condition est vraie. Fin, nous passons à la suite du programme.
Voilà donc les quatre boucles utilisées.
- Do/Loop.
- For/Next.
- While/Wend.
- Repeat/Until.
Sans oublier le GOTO qui peut quand même servir de temps en temps, non ? Ok, non alors !
Test de boucle
Nous allons tester quelques trucs pour voir un peu la rapidité des boucles. Nous allons tester un "comptage" à
l'aveugle du proco et d'AMOS dans des boucles.
Nous allons travailler avec un grand chiffre pour bien voir la différence : 100 000. Bien sûr, ce n'est que théorique !
J'ai fait le test sur AMOS Pro 2.0 avec la configuration suivante : WinUAE (sur PC Windows 7, 64 bits, 16 Go de mémoire,
processeur I7 6700 à 3,4 GHz et une carte graphique Gforce 9600 GTX) en émulation d'un Amiga 1200 (Kickstart 3.1 (40.68),
2 Mo de mémoire Chip et 8 Mo de mémoire Zorro III).
Nous allons débuter avec For/Next.
TD=Timer
For X=0 to 100000
Next
TF=Timer
Print TF-TD
Wait key
|
Ce premier exemple nous donne entre 45 et 46.
Do
Inc X
Exit If X=100000
Loop
|
Oula, 311. Et si je réunis sur la même ligne "Inc : Exit If X=100000", cela nous fait 320/321.
AMOS n'aime pas les multi-fonctions sur la même ligne !
Et si je fais une condition : "If X=100000 then Exit", nous passons à 342 !
Donc pour sortir d'une boucle "Do Loop", un beau "Exit If" est plus rapide.
Et si nous remplaçons seulement "Inc X" par "X=X+1" ? Nous tombons à 483.
Aller, j'ai envie de voir avec "GOTO" :
DEB:
Inc X
if X = 100000 then goto FIN
Goto DEB
FIN:
|
Résultat : 379 !
Avec les "While" :
While X<100000
inc X
Wend
|
Le résultat nous donne 286, c'est donc plus rapide qu'un "Do Loop".
Et le dernier :
Repeat
inc X
until X>100000
|
Résultat : 280 (même avec X>99999).
Un "For Next" à vide semble rapide mais attention, chaque ligne entre un début et une fin de boucle fait
perdre énormément de temps même à vide ! Et même sur un GOTO !
Classement
- For/Next - 45.
- Repeat/Until et While/Wend - 280.
- Do Loop - 311.
- GOTO - 379.
Bien sûr, tout cela est relatif.
Soutenez le travail de l'auteur
|
|
|
