Une appvar, c'est quoi exactement ?
A l'origine cela vient du terme application variable. Ce sont des plages de mémoire faites pour les applications de la calculatrice, mais on peut les utiliser en Axe aussi !
Pour voir les appvars présentes sur votre calculatrice, allez dans le menu
.
Créer, modifier, archiver, supprimer une appvar
Pour manipuler une appvar, il faut d'abord que celle-ci soit désarchivée impérativement ! Ensuite on utilisera la commande GetCalc() (
Code : Autre
GetCalc("appvAPPVAR")→Pointeur
Où APPVAR est le nom de l'appvar et Pointeur, le pointeur permettant d'accéder à l'appvar.
appv se trouve en faisant . L'Axe Parser transformera automatiquement le v en appv.
Attention, le pointeur n'est pas statique, donc il vous faut utiliser une variable : Code : Autre
GetCalc("appvAPPVAR")→A
Cela enregistre l'adresse de l'appvar APPVAR dans la variable A. On peut ensuite accéder aux données dans l'appvar en utilisant A comme un pointeur :
Code : Autre
1→{A}
Le code ci-dessus enregistre 1 dans le premier octet de l'appvar APPVAR. En fait c'est exactement pareil que les listes et les datas !
Mais moi je n'ai aucune appvar sur ma calculatrice, comment je fais pour en créer une ?
Quand l'appvar n'existe pas, on peut facilement la créer. Toujours en utilisant la commande GetCalc(), mais cette fois en y ajoutant un deuxième argument qui est la taille de l'appvar:
Code : Autre
GetCalc("appvAPPVAR",Taille)→Pointeur
Où Taille est la taille en octets de l'appvar que l'on veut créer.
Quand on n'a plus besoin de l'appvar, on peut la supprimer, comme ceci : Code : Autre
DelVar "appvAPPVAR"
On trouve la commande DelVar ici :
Cela marchera aussi bien si l'appvar est archivée ou désarchivée !
Mais dès qu'il y a un RAM cleared je perds tous mes scores ! Comment y remédier ?
Heureusement vous pouvez archiver vos appvars et ainsi mettre en sûreté vos données : Code : Autre
Archive "appvAPPVAR"
De même vous pouvez les désarchiver : Code : Autre
UnArchive "appvAPPVAR"
Les commande Archive et UnArchive se trouve dans le menu
Toutefois, on ne pourra plus sauvegarder des données dans l'appvar tant qu'elle sera archivée.
Cela prendra de plus en plus de temps à s'exécuter si vous n'avez pas fait de Garbage Collect récemment. De plus n'abusez pas des fonctions d'archivage et de désarchivage dans un programme, cela le ralentit énormément et augmente le nombre de Garbage Collect encore une fois.
Utiliser les fichiers
Pour éviter les Garbage Collect incessant, il existe un moyen de lire les données de l'appvar sans avoir à la désarchiver : Code : Autre
GetCalc("appvAPPVAR",Fichier)
Où Fichier est le symbole d'une fonction (Y0,..., Y9) que l'on trouve dans le menu . Une fois que l'appvar est copié dans un Fichier, on peut la lire comme un pointeur.
Citation : zéro
Super, je vais pouvoir utiliser la mémoire comme de simples Datas !
NON
, les fichiers ne peuvent qu'être lus comme des Datas, et seulement de la manière suivante : Code : AutreGetCalc("appvAPPVAR",Y0) {Y0}→A
Ici cela sauvegarde le premier octet de l'appvar dans la variable A.
Pour récapituler, laissez tomber l'idée d'utiliser les fichiers avec des commandes comme DispGraph(Y0), Pt-On(Y0) et bien d'autre.
Un autre avantage des fichiers : on n'a pas à s'en soucier, ils seront supprimés automatiquement à la fin du programme. On peut donc utiliser un même Fichier pour lire une appvar puis une autre.
Code : Autre
GetCalc("appvAPPVAR",Y0) GetCalc("appvAPPVAR2",Y0)
Ce code copiera l'appvar APPVAR dans le Fichier Y0, puis ça copiera l'appvar APPVAR2 dans le Fichier Y0. Désormais, lorsqu'on utilise le pointeur Y0, on accède aux données de APPVAR2.
Encore une fois, retenez bien que de cette manière, on peut uniquement lire des données ! Exercice
Pour voir si vous avez bien compris les concepts cités précédemment, rien de mieux qu'un peu d'exercice.
Le but de cet exercice va être de créer une appvar qui contiendra le nombre de fois que le programme a été ouvert et qui l'affiche à l'écran de la TI. Pour cela, vous aurez besoin de ce que nous avons vu ci-dessus ainsi qu'un peu de réflexion.
Voici le résultat !
Secret (cliquez pour afficher)
Tout d'abord, comme on ne sais pas si l'appvar est archivée ou pas, dans le doute il vaut mieux tenter de la désarchiver : Code : Axe
:"appvAPPVAR"→Pic1 :UnArchive Pic1
A présent, si l'appvar n'existe pas, nous devons la créer, et dans le même temps l'initialiser à 0 : Code : Axe
:!If Getcalc(Pic1)→P
:Return!If GetCalc("appvAPPVAR",1)→P :0→{P}
:End
Une appvar d'un octet devrait être suffisant pour contenir le nombre de fois où on a lancé le programme.
N'oubliez pas d'arrêter le programme si l'appvar n'a pas put être créé ou sinon vous risquez le Ram Cleared.
Ensuite, il ne reste plus qu'à incrémenter l'appvar une fois : Code : Axe
:{P}++
Pour terminer, on archive l'appvar pour éviter qu'elle soit supprimée par un RAM Cleared, ce qui donne comme code final : Code : Axe
:.APPV
:"appvAPPVAR"→Pic1 :.Nom de l'appvar
:UnArchive Pic1 :.On essaye de la désarchiver :!If GetCalc(Pic1)→P :.Si il n'y a pas d'appvar de ce nom :Return!If GetCalc(Pic1,1)→P :.Alors on la créé :0→{P} :.Et on l'initialise
:End:{P}++ :.On incrémente le premier octet de l'appvar :Disp {P}►Dec :.Puis on l'affiche
:Archive Pic1 :.On archive
:Pause 2000 :.Et on laisse un peu de temps pour voir le chiffre
Manipuler un programme...
...à partir d'un programme en Axe
Pour accéder aux programmes, on procède de la même manière que pour une appVar, mais en remplaçant appv par prgm. Encore une fois, ne le tapez pas en toutes lettres, sélectionnez-le dans le catalogue : et 14 fois
.
On a donc, pour créer (ou écraser) un programme prgmFILE de 4 octets et le pointer sur F : Code : Axe
:GetCalc("prgmFILE",4)→F
Ainsi toutes les commandes vues pour les appvars marchent pour les programmes exactement de la même manière ! Secret (cliquez pour afficher)
Code : Axe
:DelVar "prgmFILE"
:Archive "prgmFILE"
:UnArchive "prgmFILE"
:GetCalc("prgmFILE",Y0) :{Y0}→A
... à partir de l'éditeur de programme !
Je vous vois déjà en train de vous ruer sur l'éditeur de programmes pour voir ce qui se passe lorsqu'on met des données dans un programme.
Secret (cliquez pour afficher)
Vous l'aurez remarqué très vite mais l'éditeur de programme convertit tous ses octets en tokens !
Ainsi il est très facile de faire un programme en Axe qui stockera une chaîne de caractères tokens dans un programme éditable : Code : Axe
:.PGM
:"prgmPG"→Str1 :UnArchive Str1 :!If GetCalc(Str1)
:Return!If GetCalc(Str1,500) :End:Fill(→P,500,ᴱ29)
:input
:Copy(→A,P,length(A))
ᴱ29 est le token correspondant à un espace, donc ici votre programme sera entièrement blanc après la chaîne de tokens.
Un petit screen :
Les "vraies" variables et plus encore...
Les "vraies" variables
Accéder aux vraies variables est assez simple à présent.
Tout d'abord, il faut obtenir un pointeur vers une vraie variable : Code : Autre
GetCalc("varA")→Pointeur
Où A peut être remplacer par n'importe quelles vraies variables, de A à Z ainsi que θ, et Pointeur est l'endroit où l'on souhaite que la donnée contenue dans la variable pointe.
Le token var se trouve en faisant + . Axe transformera automatiquement le token u en var.
Ensuite, pour modifier la valeur de la vraie variable, il faut d'abord comprendre deux choses : la première c'est qu'en Axe on ne manipule que des variables de deux octets, alors que les "vraies variables" sont de 9 octets ; on les appelle floats.
Heureusement il existe une commande pour convertir un float en un format de 2 octets, c'est tout simplement la commande float : .
Il suffit de faire : Code : Autre
:GetCalc("varA")→P :float{P}→A :1→float{P}
Ce code stockera la vraie variable A dans la variable Axe A, puis enregistrera 1 dans la vraie variable A. Bien entendu, on ne peut enregistrer que des entiers allant uniquement de 0 à 65535 dans les vraies variables, puisque l'Axe Parser supporte seulement des nombres de 2 octets.
Il n'y a pas besoin d'utiliser r après la commande float si on sauvegarde un nombre de 2 octets.
Encore plus de variables !
En fait toutes les variables de la calculatrices sont manipulables, voici le tableau des tokens à mettre entre parenthèses pour les manipuler :
Exemple Variable
"prgmABC" Le programme ABC.
"appvABC" L'appvar ABC.
"grpABC" Le groupe ABC (seulement archivé).
"LABC" La liste ABC.
"L1" La liste L1
"varA" La "vraie" variable A
"Str1" La chaîne de caractères Str1.
"GDB1" La base de données graphique GDB1.
"Pic1" L'image Pic1.
"Y1" La fonction Y1.
"[A]" La matrice A.
Je fais très vite le tour de ceux qu'on n'a pas encore vus, dans tous les cas le principe reste toujours le même : Les groupes ne sont manipulables qu'avec les fichiers.
Les listes sont composées de nombres réels, pour afficher le nombre de nombres réels dans cette liste : Code : Axe
:GetCalc("L1")→A :Disp {A-2}r▶Dec
Les chaînes de caractères (String) sont de simples chaînes de caractère tokens. On peut obtenir la longueur d'une String en lisant les deux octets se trouvant avant celle ci :
Code : Axe
:GetCalc("Str1")→A :Disp {A-2}r▶Dec
Les bases de données graphiques font 117 octets.
Les images (Pic) de base font 756 octets seulement car la ligne du bas est ignorée.
Les fonctions (Y1, Y2,...) sont également des chaînes de tokens, elles se terminent par un zéro.
Les matrices ([A], [B],...) sont constituées de nombres réels, la largeur X*Y de la matrice se retrouve dans les deux octets précédent celle-ci :
Code : Axe
:GetCalc("[A]")→A :Disp {A-1}▶Dec :.X :Disp {A-2}▶Dec :.Y