Label

Salut à tous,


J'aurais aimé savoir, si il est mieux d'utiliser des chiffres ou de l'alphabet pour les Lbl des programmes.

Par exemple si il vaut mieux utiliser AA ou AB au lieu de 45 par exemple.
Et si possible de m'expliquer pourquoi si il y a une différence.


Merci.

Bonjour,

Ca reviens au même, c'est considéré comme des caractères (en réalité des tokens mais c'est pour faire simple) plutôt que des chiffres/lettres...
Après tu peux respecter certaines conventions dans tes prgm (rien d'officiel mais tu peux t'en tenir à une certaine logique):
Lbl M pour le menu, J pour le jeu, dans le cas où tu as plusieurs choix dans un menu Lbl 1, 2, 3, 4, 5..., Q pour quitter, ou S pour sortir ou 0, bref tu es libre
A la rigueur préfère utiliser un seul caractère avant de passer aux combinaisons doubles.

Donc utiliser tout l'alphabet puis les chiffres c'est bon ?

Oui tu peux utiliser l'alphabet puis les chiffres. Tu as 37 possibilités à un seul caractère.
Tout est libre et le poids dépend seulement du nombre de caractères.
(et on a 37^2=1369 possibilités à 2 caractères)

Et puis il faut réaliser que le TI-Basic est interprété, pas compilé, donc chaque octet à parcourir prend du temps pour être interprété. (sauf lors d'une fermeture de boucle, car dans ce cas le saut est immédiat)
Donc toute économie est bonne à prendre.

26 Alphabet + 10 chiffres ?

Dernier c'est quoi ? Theta ?

Oui.

D'accord, merci.

Le label, ca sort de bien des situations qu'on ne peut resoudre avec une simple boucle. Le probleme, c'est que contrairement aux boucles, les sauts de labels NE SONT PAS immédiats. Plus le label est situé loin dans le programme, plus la calculatrice met du temps pour arriver au label. Ce cas n'est pas que pour le ti-basic, c'est la meme chose pour le C et le java, sauf que ces langages ne fonctionnent pas sur des machines merdiques comme la ti-82, donc le saut ne se sent pas, surtout lorsque l'appareil concerné a une forte bande passante (exemple, la ps3 avec 3.2 Go/s de largeur de bande).
sauf que la ti82 stats(.fr) est un appareil muni d'un z80 tournant a 6Mhz, alors que le CELL de la ps3 fait du 3*3.2ghz.
On ne peut pas se permettre de faire n'importe quoi avec ce genre d'appareils. Il est donc RECOMMANDE de limiter l'utilisation des labels a des endroits ou on est coincés. Et pas l'utiliser a tout bout de champ sinon on ne s'en sort pas et le programme est lent au bout du compte.

D'accord pour la mise en garde.
Cependant il y a points à éclaircir (et une correction).

Le temps de recherche d'un Label :
Oui le TI-Basic recherche le Label en parcourrant tout le programme.
Oui la vitesse d'une machine peut masquer des pertes idiotes comme celle-ci.
Non le langage C et les languages compilés n'ont pas ce problème : le saut est immédiat au travers d'adresses mémoire.
Les adresses et données stockées en dur sont selon moi l'intérêt de la compilation.

Le principal problème des sauts Goto/Label est d'abord le conflit entre l'algorithmie et les sauts.
Je ne sais pas si la compilation s'occupe de gérer les échapements de blocs par les Gotos (donc sans continue,break,return explicite), mais je sais que ce n'est pas le cas dans le TI-Basic et je m'attend à ce qu'aucun langage interprété ne le gère.

Je signalerai qu'on peut a priori toujours s'en sortir sans les Goto/Label, mais que cela peut devenir très compliqué.
Le juste milieu est difficile à trouver, mais dans tous les cas il est déconseillé de mélanger les sauts avec l'algorithmie sans réfléchir aux conséquences.

Edit: Doublé par Linka, je poste quand même

Ce n'est pas tout à fait exact.

Linka décrit plus en détails certains mécanismes des Lbl ici (à la fin) : http://tout82.free.fr/forum/sujet.php?sujet=2691

En gros:
Un Goto XX cherche depuis le début du programme un retour à la ligne suivi d'un Lbl XX.
Donc dans le cas d'un Goto/Lbl, on démarre la recherche depuis le début du programme, mais seules les débuts de ligne sont inspectées (ce qui est relativement rapide).

Une structure If cherche un End (dans le cas où il faut sauter certaines instructions). Ce End n'est pas cherché seulement après un retour à la ligne, il prend aussi en compte le ":" marquant la limite entre 2 instructions sur la même ligne (contrairement au Goto). De plus il doit alors vérifier qu'il s'agit bien d'un End qui lui est adressé (il n'est pas dans une chaine ("End->Str1 ne marche pas, "TEST->Str1:End" non plus (cf article de linka donnée plus haut); et il faut compter les End par rapport aux autres IF-Then/Boucles qui pourraient s'interposer).
Il s'agit d'une recherche plus précise (même si incomplète dans le cas d'un DelVar ou d'un guillemet mal fermé), qui prend plus de temps, mais qui démarre au niveau du If-Then/Else qui l'a déclenché.

Il s'agit de la même chose pour une boucle du type While 0, qui n'est jamais exécutée.

En revanche, dans le cas d'une boucle qui est exécutée au moins une fois (tout type de Repeat et un While dont la condition est initialement juste), il n'y a pas cette recherche, puisque quand on atteint un End on teste si la condition est vraie/fausse et on repart juste après le End si c'est bon.
Preuve (pour la boucle While):

Code:

1->A
While A
Goto 1
End
Disp 1
Return
Lbl 1
DelVar ADisp 0
End
//Affiche 0 et quitte

While 0
Goto 1
End
Disp 1
Return
Lbl 1
Disp 0
End
//Affiche 1 et quitte

Donc il ne faut pas recommander de limiter les Goto/Lbl, simplement de les utiliser au bon moment (avec des Lbl situés vers le début du programme quand on a besoin de rapidité), et de ne pas faire n'importe quoi avec (éviter de les mêler aux boucles sauf si on sait ce qu'on fait http://tout82.free.fr/forum/sujet.php?sujet=2757 ). Même lorsqu'on a besoin de rapidité, lorsque le programme devient complexe, il peut devenir plus judicieux d'utiliser des Goto/Lbl que des boucles (qui peut être moins flexibles).

Un autre petit test qui montre un bogue intéressant (mais inexploitable):

Code:

While 0
End1
//Plante Err Syntaxe au niveau du End1

If 0
Then
While 0
End1
End
Disp 1
//Affiche 1
// Le End1 a donc été traité comme un simple End dans ce cas, la ti n'a pas regardé ce qu'il y avait après

//Impossible à reproduire avec les Goto/Lbl:
Goto 1² //Plante (err syntaxe)

Goto 1A² //Plante

Lbl 1A² //plante également

comme je dis, les labels peuvent aider lors de situations difficiles a realiser avec un If/While/Loop/For/Repeat traditionnel. Mais bien se mettre en garde que les labels sont plus lents que les boucles.

Code:

En comparant ca:
Lbl 1
tagadatagada le code quoi
Goto 1
et avec ca:
While 1
tagadatagada le code quoi
End

surtout que les labels ne gerent aucune sorte de condition, donc voila

Certes les sauts peuvent aider, et cela est sous-entendu quand je dis que l'algorithmie peut devenir compliquée.

La vitesse importe peu lorsque nous craignons des bugs d'algorithmie.

D'autre part ta comparaison des vitesses n'est pas toujours vraie !
Les procédés de scrutation de code pour éviction ne sont pas le même pour le saut et l'algorithmie.
La vitesse de l'algorithmie est avantageuse vers la fin des longs programmes et les portions courtes ou peu juxtaposées.
La vitesse des sauts est avantageuse quand l'arrivée est au début du programme et quand les lignes sont longues en particulier quand des commandes sont juxtaposées.

Et tu dis que les Goto/Lbl ne gèrent aucune condition, ce n'est pas tout à fait vrai. Il suffit de coupler avec un If et ça peut devenir bien plus puissant.

Exemple de structure qu'il est plus compliqué d'obtenir avec des boucles/If seulement (et qui est rapide si placé au début du programme:

Code:

Lbl A
//Quelques actions
If condition1
Goto A
//D'autres actions
If condition2
Goto A

Avec des boucles ça donnerait:

Code:

Repeat non(condition1 ou condition 2
//Premières actions
If non(condition1
Then
//D'autres actions
End
End

Cette deuxième solution est moins appropriée, et les sauts sont plus avantageux (ils permettent d'avoir une meilleure vitesse lorsque condition1 n'est pas vérifiée). Il ne faut donc pas négliger les sauts, qui peuvent devenir avantageux lorsque la situation est complexe.

Et dans l'autre sens il ne faut pas abuser des Goto même s'il n'y a pas de conflit avec l'algorithmie, car de tels programmes sont difficiles à relire et à comprendre avec des sauts dans tous les sens.

Et des critères de fluidité peuvent eux-aussi être choisis, car gagner du temps dans un cas et pas l'autre créera des déséquilibres de durée.

Le While vérifie la condition au début, contrairement à l'équivalence proposée par Goto/Lbl. Il faudrait utiliser un Repeat et complémenter la condition ou bien ajouter un test avant le Lbl.

rpgcreator a écrit:surtout que les labels ne gerent aucune sorte de condition, donc voila

m@thieu41 a écrit:Et tu dis que les Goto/Lbl ne gèrent aucune condition, ce n'est pas tout à fait vrai. Il suffit de coupler avec un If et ça peut devenir bien plus puissant.

Hélas il faut songer qu'il faut un If mais surtout pas If-Then-End, car c'est ainsi que tous les novices tentent un pong ou un serpent qui ralentit et plante sans raison évidente à leur niveau.

C'est vrai je n'y avais pas pensé, je rectifie la boucle.

je disais aucune condition toute seule sans If ni rien...

Un label tout seul tu veux dire?
Mais... et alors?