Vertel



.\ 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.



Retour au sommaire

Vertyos