Obligement - L'Amiga au maximum

Lundi 29 mai 2017 - 05:53  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Soutien

N'hésitez pas à soutenir le projet Obligement



Contact

David Brunet

Courriel

 


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 de l'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, on entre 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é.

Do
Inc X
Print X
Loop

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 rajouter une ligne si on veut 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, on peut 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, on peut 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, on rejoue 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, on passe à 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 de l'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", on passe à 342 ! Donc pour sortir d'une boucle "Do Loop", un beau "Exit If" est plus rapide.

Et si on remplace seulement "Inc X" par "X=X+1" ? On tombe à 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
  1. For/Next - 45.
  2. Repeat/Until et While/Wend - 280.
  3. Do Loop - 311.
  4. GOTO - 379.
Bien sûr, tout cela est relatif.


[Retour en haut] / [Retour aux articles]