.\ Utilisation de la librairie
• A propos de l'utilisation
A part le paragraphe "Syntaxe de base", les instructions
suivantes peuvent être considérées comme assez complexes. Si vous n'y comprenez rien,
rassurez-vous : elles ne sont pas indispensables. Contentez-vous de vous familiariser avec la
librairie, le reste viendra à temps.
Si au contraire tout ceci vous parait limpide, vous pourrez trouver des astuces plus avancées
dans la partie "Conseils d'utilisations et d'optimisation".
• Syntaxe de base
Pour utiliser Vertel, il suffit de l'appeler, depuis
l'écran HOME ou un programme en Ti-Basic, comme un programme classique : vertel().
Cependant cet appel n'aura aucun effet, et pour cause : il est vide. Les
effets dépendront de ce que vous mettez comme valeurs entre les parenthèses, sous la forme
d'un nom de fonction et de ses arguments si elle en a. Prenons le cas d'une fonction sans
argument, comme "paus" qui est une fonction qui attend que l'utilisateur appuie sur une
touche (voir "Liste et description des fonctions"); il suffit de rentrer vertel("paus"), la
calculatrice se mettra alors en pause jusqu'à ce que vous appuyez sur une touche.
Pour les fonctions a arguments, le principe est le même, et il suffit
d'ajouter à la suite de la fonction ses arguments séparés par des virgules. La fonction "pixl"
a pour effet de dessiner un pixel à l'écran, et a besoin d'au moins deux arguments : les
coordonnées x et y du pixel à afficher. Le fait d'entrer vertel("pixl",20,20) dessinera donc
un pixel aux coordonnées 20,20.
Il est possible d'entrer plusieurs fonctions à la suite sans quitter Vertel,
ce qui offre un gain de place et de vitesse. Pour cela, séparez les fonctions avec une chaine
vide : "". Pour dessiner un pixel tout en haut à gauche de l'écran puis attendre un appui sur
une touche, il est donc possible d'entrer : vertel("pixl",0,0,"","paus").
• Extensions de la syntaxe
La syntaxe des arguments est assez flexible, et autorise
donc quelques variations plus ou moins utiles. Si votre source est destinée à être lue par
d'autres, évitez toutefois d'utiliser une syntaxe difficile à lire si elle n'apporte aucun
avantage.
Premièrement, si l'ordre des arguments de même type entre eux est important,
ce n'est pas le cas des arguments de types différents (nombres et chaines). En d'autres
termes, vous pouvez entrer tous les arguments numeriques en premier, ou en dernier, peu
importe du moment qu'ils restent dans le même ordre entre eux : vertel("a",1,"b",2),
vertel("a","b",1,2) et vertel(1,2,"a","b") sont trois syntaxes exactement équivalentes. Notez
que cela est aussi valable pour les noms de fonctions, qui sont des chaines : vous pouvez
placer les arguments numériques d'une fonction avant d'indiquer son nom, mais cela n'a aucun
interet sinon rendre votre source difficile à lire.
Deuxièmement, tous les arguments numeriques omis sont fixés à 0 par défaut.
Ainsi vertel("fonc",0) est exactement équivalent à vertel("fonc"). Attention toutefois, les 0
peuvent être nécessaire si d'autres arguments numériques non-nuls doivent suivre : dans le cas
de vertel("fonc",0,1), il est impossible de supprimer le 0 (le 1 serait alors considéré comme
étant le 1er argument numérique, alors qu'il est le 2eme).
• Listes en argument
L'utilisation correcte des listes en argument est l'une
des clés à maitriser pour réaliser des programmes très largement plus rapides. Le fait de
placer une liste en argument répete la fonction pour chacun des élements de la liste. Voici
un exemple simple : vertel("pixl",{10,20,30},20). La fonction "pixl" va alors tracer 3 pixels,
aux coordonnées 10,20, puis 20,20 et enfin 30,20.
Vous pouvez utiliser plusieurs listes, en reprenant le même exemple :
vertel("pixl",{10,20,30},{50,40,30}). 3 pixels seront dessinés également, aux coordonnées
10,50, 20,40 et 30,30.
Si une des listes s'arrête avant les autres, Vertel stoppe la lecture et
ignore les élements supplémentaires des listes plus longues.
• Lecture ininterrompue : Tag "|" (sachant que)
Par défaut, Vertel arrete la lecture des listes si l'une
d'entre elles est terminée. Les élements supplémentaires des autres listes ne seront donc pas
lus, dans un tel appel : vertel("pixl",{10,20},{10,20,30}), le "30" de la deuxième liste est
ignoré puisque la première liste n'a que deux élements et que Vertel arrête la lecture.
La lecture ininterrompue consiste justement à continuer la lecture même si
une ou plusieurs listes sont terminées : En plaçant un "|" devant une liste, elle est
considérée comme ininterruptible. Le tag ni comme un argument numérique ni comme une chaine, et
ne sert qu'à enclancher ce mode de lecture. Le dernier élement de la liste sera alors répeté
autant de fois que nécessaire pour combler les élements "manquants" par rapport aux autres
listes.
Avec l'exemple précedent, vertel("pixl","|",{10,20},{10,20,30}), 3 pixels
seront dessinés à 10,10, 20,20 et 20,30 : Vertel répete le dernier élement "20" de la première
liste (qui est en mode ininterruptible) pour continuer avec la seconde liste, plus longue.
Attention, le tag n'affecte que la liste qui le suit. Si vous voulez placer
plusieurs listes ininterruptibles, il faut mettre un tag "|" devant chacune d'elle.
• Lecture sequencielle : Tag "->" (fleche STO)
Pour activer la lecture séquencielle, il faut placer un
"->" avant la liste qui doit être séquencée, et le tag ne sera pas considéré comme un argument.
L'utilisation des listes est, par défaut, simultanée. Cela signifie que si
plusieurs listes sont placées en argument, leurs premiers élements seront lus au premier cycle,
puis leurs seconds, etc... En d'autres termes les listes "avancent" en même temps.
La lecture séquencielle affecte la liste choisie, et celle qui la précede :
Seule la liste choisie avancera à chaque cycle, sa précedente ne changera pas. Une fois la liste
choisie terminée, la tête de lecture retournera au début et la liste précedente avancera d'un
rang.
Voici un exemple pour expliquer la différence entre lecture simultanée et
lecture séquencielle : vertel({1,2},{3,4}), et vertel({1,2},"->",{3,4}) (ces exemples ne sont
là que pour l'illustration, étant donné qu'ils n'ont aucun effet). Le premier exemple est
interpreté comme 1,3 puis 2,4, alors que le second est interpreté comme 1,3, puis 1,4, puis
2,3, et enfin 2,4. En effet, la deuxième liste est marquée comme séquencielle par rapport à la
première, elle est donc seule à avancer à chaque cycle. La 1ere liste n'avance que quand la 2eme
est terminée.
La lecture séquencielle peut servir dans plusieurs situations. Il est par
exemple simple de remplir l'écran d'une série de PIC : en indiquant les coordonnées x dans une
liste, les coordonnées y dans l'autre, une image peut être affichée à toutes les positions de
l'écran.
Il est possible d'utiliser des listes séquencielles multiples : par exemple
dans l'appel vertel({1,2},"->",{3,4},"->",{5,6}), la 2eme liste n'avancera que quand la 3eme
arrivera à la fin, et la 1ere n'avancera que quand la 2eme arrivera à la fin (en remettant les
têtes de lecture des deux autres à zéro, bien sûr).
Attention, n'importe quelle chaine qui commence par "->" sera considérée
comme un tag de lecture séquencielle. Pour éviter cela, vous pouvez préceder une chaine par
"/" : ce caractère ne sera pas prit en compte dans la chaine mais il l'empechera d'être
prise pour un tag de lecture séquencielle.
• Indirections internes : Tag "#" (dièse)
Il s'agit là d'une autre astuce très utile à maitriser,
mais qui doit également être la plus complexe.
Au lieu de passer la valeur d'une variable en argument d'une fonction, par exemple en
appelant vertel(var), vous pouvez utiliser une indirection interne : vertel("#var"). Ceci aura
à peu près le même effet : au moment de lire la chaine, Vertel verra le # et essaiera d'ouvrir
la variable, pour en récupérer le contenu. Le fait d'utiliser les indirections internes a
deux conséquences principales : accelerer l'appel, et retarder l'évaluation.
L'acceleration se constate en fait si vous passez des grandes listes en
argument : en executant par exemple {1,2,...,199,200}->list:vertel(list), AMS évalue la liste
"list" une seconde fois lors de l'appel, ce qui prend un temps non négligeable. En utilisant
une indirection interne, avec vertel("#list"), AMS n'évalue pas la liste, seule Vertel s'en
charge, d'ou un gain de temps appréciable.
Le retard d'évaluation est une autre conséquence qui peut s'avérer utile :
en appelant vertel("fnc1",var1,"","fnc2",var2), AMS évalue var1 et var2 lors de l'appel et
passe à Vertel les valeurs qu'elles contiennent. En remplaçant cet appel par celui-ci :
vertel("fnc1","#var1","","fnc2","#var2"), AMS n'évalue pas les variables, seule Vertel lis
le contenu des variables, mais ne le fait qu'au moment d'executer les fonctions
correspondantes. Ainsi, si "fnc1" modifie le contenu de "var2", l'appel classique sans
indirections n'en tiendra pas compte, tandis que l'autre si. Vous trouverez des informations
complémentaires dans la partie "Conseils d'utilisation et d'optimisation".
Dernier détail : vous pouvez grâce aux indirections internes imbriquer des
listes, par exemple {2,"#b"}->a:{3,4}->b:vertel({1,"#a"} est traité comme 1, puis 2, 3 et 4.
Attention, de la même façon que pour les autres tags, n'importe quelle
chaine qui commence par "#" sera considérée comme une indirection interne. Vous pouvez là aussi
préceder les chaines du caractère "/", qui ne sera pas prit en compte mais empechera que Vertel
la considère comme une indirection interne.
Vertyos