| |
|
|
| Introduction |
|
Instructions et fonctions
Cette partie contient la description de toutes les instructions et fonctions disponibles, pas forcément dans l'ordre alphabétique. Il se peut que certaines instructions ou fonctions soient différentes du GFA Basic sur ATARI ST. Ce manuel fera la distinction.
La différence entre instruction et ordre, qui avait un sens historiquement, est désormais levée (Il était d'usage d'appeler ordre ce qui concernait le mode direct et qui contribuait à l'élaboration des programmes). Les instructions, par contre, s'utilisaient à l'interieur d'un programme. Comme toutes les instructions peuvent être employées aussi bien en mode direct que dans un programme, cette distinction n'est plus necessaire).
La description des instructions et des fonctions s'organise en quatre parties.
1- Syntaxe:
Ici est décrit le format de l'instruction ou de la fonction.
Les mots écrits en majuscules sont des mots-clés.
Les expressions entre crochets sont optionnelles, c'est à dire facultatives. Trois petits points "..." indiquent que l'expression qui se trouve avant peut être répétée autant de fois que l'on veut.
Les expressions qui interviennent dans le format de l'instruction sont expliquées dans la suite de la description.
2- Exemple:
Dans cette partie, on présente un exemple simple de programmes.
D'une part, l'exemple doit mettre en évidence les différentes syntaxes possibles de l'instruction.
D'autre part, l'exemple sert à concrétiser l'utilisation de l'instruction ou de la fonction.
Si, après l'explication de l'instruction ou de la fonction, des doutes subsistent quant à son emploi ou son utilitée, il est conseillé de taper et de tester soi-même l'exemple fourni.
Comme certains exemples utilisent des boucles sans fin, il est important de savoir que l'on peut interrompre l'execution d'un programme avec la touche [ON].
3- Fonction:
Décrit en peu de mots quelle est l'utilisation de l'instruction ou de la fonction (c'est-à-dire ce que fait l'instruction ou la fonction).
4- Explication:
Dans cette partie, on explique de façon détaillée ce qu'il est important de connaître pour la mise en application de l'instruction ou de la fonction.
Si on peut préciser le domaine d'application de l'instruction.
Instruction I/O (relative aux entrées/sorties).
Instruction graphique.
Instruction arithmétique.
Instruction de structure.
...
ce dernier sera précisé dans l'en-tête de la description.
Dans la description concernant les instructions graphiques, nous supposons que la résolution de la calculatrice est en noir & blanc et que la taille de l'écran est de 240 x 128 pixels.
A noter qu'il existe des constantes, les constantes dynamiques ont un rapport avec le modèle de la calculatrice où le programme est executé et non développé.
Attention:
La liste ci-dessous contient énormément d'instructions/fonctions non implantées et est incompléte (certaines fonctions ne sont pas encore documentées mais elles sont implantées dans GFA-Basic).
Veuillez vous reporter au fichier beta.txt disponible dans le pack pour connaître les instructions/fonctions développées et utilisables.
|
|
| Liste des instructions/fonctions |
|
|
|
|
|
|
|
FONCTION
|
==
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
ABS
|
|
|
| Syntaxe: |
ABS(x)
|
|
| Exemple(s): |
CLS
A=-2329
PRINT ABS(A)
PRINT ABS(&X1010)
PRINT ABS(3*(-7))
|
|
| Fonction: |
Retourne la valeur absolue de x.
|
|
| Explications: |
|
x est une expression numérique quelconque.
ABS(x) est la fonction mathématique valeur absolue. La valeur absolue d'une expression numérique est toujours supérieur ou égale à 0. Elle vaut:
- si x>0, alors ABS(x)=x
- si x=0, alors ABS(x)=0
- si x<0, alors ABS(x)=-x
|
|
|
|
|
|
|
|
|
FONCTION
|
ARRPTR
|
|
|
| Syntaxe: |
ARRPTR(var)
|
|
| Exemple(s): |
CLS
A$="BASIC"
PRINT ARRPTR(A$)
PRINT DPEEK(ARRPTR(A$))
PRINT DPEEK(ARRPTR(A$)+2)
|
|
| Fonction: |
Détermine l'adresse du descripteur d'une chaîne de caractères ou d'un tableau.
|
|
| Explications: |
|
'var' est une variable alphanumérique (chaîne de caractères) ou un tableau.
Les chaînes de caractères et les tableaux sont placés en mémoire suivant un schéma précis à l'aide d'un descripteur.
ARRPTR détermine l'adresse du premier octet du descripteur qui est différent selon une chaîne de caractères ou un tableau. Dans l'exemple on détermine le numéro de handle et la longeur de A$.
A noter que si le type d'une variable est différent d'une chaîne de caractère, une erreur est retournée. Pour obtenir l'adresse du contenu d'une variable, utilisez la fonction Varptr.
|
|
|
|
|
|
|
|
|
FONCTION
|
ASC
|
|
|
| Syntaxe: |
ASC(x$)
|
|
| Exemple(s): |
CLS
A$="Gfa"
PRINT ASC(A$)
PRINT ASC("!")
PRINT ASC("!ATTENTION!")
|
|
| Fonction: |
Retourne le code ASCII du premier caractère de la chaîne x$.
|
|
| Explications: |
|
Les caractères disponibles sur TI68K sont ordonnés suivant le code ASCII. Il y a 256 caractères repérables par leur code compris entre 0 et 255 (les codes 0 à 31 représentent des caractères de contrôle). Une table de correspondance entre les caractères et leurs codes se trouve dans le menuel de votre calculatrice.
'x$' est une chaîne de caractères quelconque (string). La fonction ASC retourne le code ASCII du premier caractère d'une chaîne. Ainsi, ASC("!ATTENTION!") est équivalent à ASC("!"), et vaut 33. Si la chaîne x$ est une chaîne vide, la valeur retournée est 0.
|
|
|
|
|
|
|
|
|
FONCTION
|
ATN
|
|
|
| Syntaxe: |
ATN(x)
|
|
| Exemple(s): |
CLS
INPUT pente
RAD=ATN(pente/100)
DEGRE=RAD*180/PI
PRINT DEGRE
|
|
| Fonction: |
Retourne l'arctangente de x.
|
|
| Explications: |
|
'x' est une expression numérique qui représente la valeur de la tangente d'un certain angle (en radian) que l'on veut calculer.
La fonction ATN retourne une valeur comprise entre -PI/2 et PI/2. L'angle obtenu a pour unité le radian. Si l'on veut convertir cet angle en degrés, il faut le multiplier par 180/PI (PI représente le périmètre d'un cercle de diamètre 1. Sa valeur est obtenue directement grâce à la fonction PI du BASIC Gfa).
|
|
|
|
|
|
|
|
|
FONCTION
|
BASEPAGE
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
BIN$
|
|
|
| Syntaxe: |
BIN$(x)
|
|
| Exemple(s): |
CLS
A=-1
B=&O22
PRINT BIN$(A)
PRINT BIN$(234)
PRINT BIN$(B)
|
|
| Fonction: |
Convertit la valeur de x en une chaîne de caractères représentant l'écriture binaire de x.
|
|
| Explications: |
|
'x' est un entier relatif (compris entre -2147483648 et +2147483647) écrit dans une représentation quelconque (c'est à dire la représentation décimale normale (sans préfixe), la représentation hexadécimale (préfixe &H), la représentation octale (préfixe &O) ou la représentation binaire (préfixe &X)) ou une variable.
BIN$ convertit x en une chaîne de caractères qui est la représentation binaire de x (c'est-à-dire que la variable B de notre exemple est convertie en la chaîne "10010").
BIN$, tout comme HEX$ et OCT$, utilise la représentation interne des nombres sur 32 bits: le résultat obtenu n'est donc jamais précédé d'un signe. Ce n'est pas le cas avec la représentation décimale qui traite le signe des nombres entiers.
(voir aussi HEX$(x), OCT$(x) et STR$(x)).
|
|
|
|
|
|
|
|
|
FONCTION
|
C:
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
CHR$
|
|
|
| Syntaxe: |
CHR$(x)
|
|
| Exemple(s): |
CLS
PRINT CHR$(65)
PRINT CHR$(577)
PRINT CHR$(-191)
|
|
| Fonction: |
Retourne le caractère dont le code ASCII est x.
|
|
| Explications: |
|
Les caractères disponibles sur TI68K sont numérotés suivant le code ASCII. Il y a 256 caractères dont les codes sont comrpis entre 0 et 255 (les codes 0 à 31 représentent des caractères de contrôle). Une table de correspondance entre les différents caractères et leurs codes se trouve dans le maneul de votre calculatrice.
'x' est un entier relatif. 'x' est tout d'abord converti en un entier comrpis entre 0 et 255 grâce à la formule x AND 255.
On obtient une chaîne de caractères de longueur 1 avec le caractère correspondant au code ASCII. Ainsi les trois exemples ci-dessus renvoient tous la chaîne de caractères "A".
|
|
|
|
|
|
|
|
|
FONCTION
|
COS
|
|
|
| Syntaxe: |
COS(x)
|
|
| Exemple(s): |
1) CLS
INPUT RAD
PRINT COS(RAD)
INPUT DEG
PRINT COS(DEG*PI/180)
2) CLS
PLOT 120,64
FOR I=1 TO 5400
X=I/36*COS(I*PI/180)
Y=I/36*SIN(I*PI/180)
DRAW TO 120+X,64+Y
NEXT I
|
|
| Fonction: |
Retourne le cosinus de x.
|
|
| Explications: |
|
'x' est une expression numérique qui représente l'angle (en radians) dont on veut calculer le cosinus.
Si l'on veut introduire l'angle en degrè, il faut remplacer x par deg*PI/180, où PI est une fonction du BASIC Gfa qui renvoie la valeur de pi (c'est-à-dire le périmètre d'un cercle de diamètre 1).
Le premier exemple calcul tout d'abord le cosinus d'un angle donné en radians, puis celui d'un angle donné en degrès. Le deuxième exemple dessine une spirale degré par degré.
L'exemple n°2 n'est pas fonctionnel dû à des d'instructions et des fonctions non implantées.
|
|
|
|
|
|
|
|
|
FONCTION
|
CRSCOL
CRSLIN
|
|
|
| Syntaxe: |
°CRSCOL
CRSLIN
|
|
| Exemple(s): |
CLS
Ox=CRSCOL
Oy=CRSLIN
PRINT AT(9,9);"TEST"
PRINT AT(Ox,Oy);
|
|
| Fonction: |
Permet d'obtenir la position du curseur (colonne et ligne).
|
|
| Explications: |
|
La fonction CRSLIN resp. CRSOL retournent la ligne resp. la colonne où se trouve le curseur. Dans l'exemple, on sauve la position du curseur, on affiche un message et enfin, on replace le curseur à sa position initiale.
(voir aussi PRINT AT).
Sur Atari ST le curseur change de coordonnées en même temps que le texte avance. Contraiment sur TI68K où seulement les coordonnées du cursuer avec PRINT AT et INPUT AT sont mémorisées.
|
|
|
|
|
|
|
|
|
FONCTION
|
CVI
CVL
CVF
|
|
|
| Syntaxe: |
CVI(x$)
CVL(x$)
CVF(x$)
|
|
| Exemple(s): |
CLS
A=0.1111
A$=MKF$(A)
PRINT CVF(A$)
|
|
| Fonction: |
Convertit une chaîne de caractères en une valeur numérique.
|
|
| Explications: |
|
'x$' est une chaîne de caractères quelconque.
Les différentes fonctions convertissent x$ en une valeur numérique, à savoir:
CVI convertit une chaîne de 2 octets en un entier de 16 bits.
CVL convertit une chaîne de 4 octets en un entier de 32 bits.
CVF convertit une chaîne de 10 octets réalisant le format spécifique des flottants sur TI68K en valeur numérique.
(fcts inverses: MKI$, MKL$, MKF$).
Les données à convertir doivent se trouve sur une adresse paire! Dans le cas contraire, une barre noire en haut de l'écran avec le message d'erreur 'Address error' s'affichera et vous serez obligé d'effectuer un RESET de la calculatrice!
Le GFA Basic sur TI68K ne supporte pas les fonctions CVS et CVD contrairement à l'ATARI ST. Il est a noté que le format des flottants sur ATARI ST est différent du format des flottants sur TI68K, un flottant sur l'ATARI ST est stocké sur 6 octets contrairement à 10 octets sur TI68K.
|
|
|
|
|
|
|
|
|
FONCTION
|
DATE$
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
DFREE
|
|
|
| Syntaxe: |
DFREE(x)
|
|
| Exemple(s): |
CLS
PRINT DFREE(0)
PRINT DFREE(1)
|
|
| Fonction: |
Indique la place mémoire disponible sur chaque unité de mémoire.
|
|
| Explications: |
|
'n' est une expression numérique qui correspond au numéro de l'unité de mémoire.
L'instruction retourne la place mémoire disponible sur l'unité de mémoire n
Si n=0, il s'agit de l'unité de mémoire RAM, dans le cas contraire il s'agit de l'unité de mémoire d'archive (mémoire Flash).
Sur ATARI ST, cette fonction renvoie l'espace mémoire disponible sur une disquette de l'unité n.
|
|
|
|
|
|
|
|
|
FONCTION
|
DIM?
|
|
|
| Syntaxe: |
DIM?(tableau())
|
|
| Exemple(s): |
CLS
DIM A$(3,4,5),N%(12,12)
PRINT DIM?(A$()),DIM?(N%())
|
|
| Fonction: |
Retourne le nombre d'éléments d'un tableau.
|
|
| Explications: |
|
'tableau' est une variable tableau quelconque.
La fonction donne le nombre d'éléments d'un tableau qui a précédemment été défini avec l'instruction DIM, Notez que les indices commencent à 0: Ainsi, l'exemple ci-dessus affiche les valeurs 120 et 169.
Si on demande la dimension d'un tableau non défini, on obtient en retour la valeur 0.
|
|
|
|
|
|
|
|
|
FONCTION
|
DIR$
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
EOF
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
ERR
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
EVEN
|
|
|
| Syntaxe: |
EVEN(x)
|
|
| Exemple(s): |
CLS
REPEAT
INPUT "Entrez un nombre pair, s.v.p : ";N
UNTIL EVEN(N)
|
|
| Fonction: |
Détermine la parité d'un nombre.
|
|
| Explications: |
|
'n' est une expression numérique. Si n est pair, EVEN(n) retourne -1. Si n est impair, on obtient 0.
(voir ODD).
|
|
|
|
|
|
|
|
|
FONCTION
|
EXIST
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
EXP
|
|
|
| Syntaxe: |
EXP(x)
|
|
| Exemple(s): |
CLS
PRINT EXP(1)
PRINT EXP(0.5)
PRINT EXP(-2)
|
|
| Fonction: |
Calcule l'exponentielle de x (e^x e=2.7182818285).
|
|
| Explications: |
|
'x' est une expression numéritque quelconque.
La fonction EXP(x) calcule e (base du logarithme népérien) à la puissance x.
Il est possible d'utiliser la syntaxe de la touche exponentielle de la TI.
|
|
|
|
|
|
|
|
|
FONCTION
|
FATAL
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
FIX
|
|
|
| Syntaxe: |
FIX(x)
|
|
| Exemple(s): |
CLS
A=3.1415
PRINT FIX(A)
PRINT FIX(-12)
PRINT FIX-1.99)
|
|
| Fonction: |
Retourne la partie de x située avant la virgule.
|
|
| Explications: |
|
'x' est une expression numérique quelconque.
Cette fonction est identique à INT ainsi qu'à la fonction TRUNC. FIX récupère la partie entière située avant la virgule soit dans notre exemple nous obtenons les valeurs suivantes: 3, -12 et -1.
Sur Atari ST la fonction INT n'est pas identique à la fonction FIX, elle gère différement les nombres négatifs.
|
|
|
|
|
|
|
|
|
FONCTION
|
FRAC
|
|
|
| Syntaxe: |
FRAC(x)
|
|
| Exemple(s): |
CLS
A=-10.1234
PRINT FRAC(3.1415)
PRINT FRAC(A)
PRINT TRUNC(A)+FRAC(A)
|
|
| Fonction: |
Retourne la partie de x située après la virgule.
|
|
| Explications: |
|
'x' est une expression numértique quelconque.
FRAC(x) tronque la partie de x avant la virgule et restitue la partie de x après la virgule. Pour des valeurs entières de x, FRAC(x) retourne donc la valeur 0.
On a : FRAC(x)=x-TRUNC(x)
FRAC est la fonction complémentaire de TRUNC (FIX) et de INT et non de ROUND.
(voir INT et TRUNC).
Sur Atari ST, la fonction INT est différente, elle n'est pas identique à TRUNC ou FIX, elle gère différement les nombres négatifs.
|
|
|
|
|
|
|
|
|
FONCTION
|
FRE
|
|
|
| Syntaxe: |
FRE[(x)]
|
|
| Exemple(s): |
CLS
PRINT FRE(A%)
DIM N$(1000)
PRINT FRE
|
|
| Fonction: |
Calcule la taille en octets de la place mémoire encore disponible en mémoire RAM.
|
|
| Explications: |
|
Les parenthèses et le paramètre x, qui peut être une expression numérique, ne sont pas pris en compte.
A l'appel de la fonction FREE, le BASIC Gfa calcule, en nombres d'octets, la place encore disponible de la mémoire RAM après avoir effectué une 'Garbage-collection' (collecte et effacement de la place (occupée des objets 'morts') non utilisée dans la RAM).
|
|
|
|
|
|
|
|
|
FONCTION
|
HEX$
|
|
|
| Syntaxe: |
HEX$(x)
|
|
| Exemple(s): |
CLS
A=-1
B=&O22
PRINT HEX$(A)
PRINT HEX$(234)
PRINT HEX$(B)
|
|
| Fonction: |
Convertit x en une chaîne de caractères représentant l'écriture héxadécimale de x.
|
|
| Explications: |
|
'x' est un entier relatif (entre -2147483648 et +2147483647) dans une représentation quelconque (c'est-à-dire la représentation décimale normale (sans préfixe), la représentation héxadécimale (préfixe &H), la représentation octale (préfixe &O) ou la représentation binaire (préfixe &X)) ou une variable du type correspondant.
HEX$(x) convertit la valeur x est une chaîne de caractères représentant l'écriture héxadécimale de x (cela signifie que la variable B de l'exemple est convertie en la chaîne "12").
HEX$, de même que BIN$ et OCT$, considèrent les entiers relatifs comme une série de 32 bits, et les représentent donc sans signe, à l'inverse de la représentation décimale normale.
(voir aussi OCT$(x), BIN$(x) et STR$(x)).
|
|
|
|
|
|
|
|
|
FONCTION
|
HIMEM
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
INKEY$
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
INP
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
INP?
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
INPUT$
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
INSTR
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
INT
|
|
|
| Syntaxe: |
INT(x)
|
|
| Exemple(s): |
CLS
A=3.1415
PRINT INT(A)
PRINT INT(678)
PRINT INT(-1.001)
|
|
| Fonction: |
Calcul la partie entière de x.
|
|
| Explications: |
|
'x' est une expression numérique quelconque.
La fonction INT est identique à la fonction TRUNC et FIX. Cette fonction revient à tronquer la partie de x située après la virgule.
A noter que sur Atari ST cette fonction se comporte différement avec les nombres négatifs. INT arrondit x dans le sens des x négatifs. Ainsi l'exemple INT(-1.001) retourne -2 contrairement sur TI68K ou on obtient -1.
|
|
|
|
|
|
|
|
|
FONCTION
|
LEFT$
|
|
|
| Syntaxe: |
LEFT$(x[,n])
|
|
| Exemple(s): |
CLS
N$="BASIC Gfa"
PRINT LEFT$(N$)
PRINT LEFT$(N$,3)
PRINT LEFT$(N$,12)
|
|
| Fonction: |
Prend le premier caractère ou les n premiers caractères (de gauche) de la chaîne 'string'.
|
|
| Explications: |
|
'string' est une chaîne de caractères ou une variable chaîne de caractères.
'n' est normalement un entier naturel ou une variable de même type (cependant, on peut entrer un nombre décimal. L'éditeur ne prendra en compte que sa partie entière).
Si la paramètre facultatif n est absent, la fonction retourne uniquement le premier caractère de la chaîne 'string'.
Autrement, la fonction retourne une sous-chaîne de 'string' qui est composée des n premiers caractères (caractères de gauche). Les caractères blancs sont également pris en compte.
Si n est supérieur au nombre de caractères de 'string', la fonction retourne la chaîne 'string' elle-même. Si n=0, on obtient la chaîne vide.
|
|
|
|
|
|
|
|
|
FONCTION
|
LEN
|
|
|
| Syntaxe: |
LEN(x$)
|
|
| Exemple(s): |
CLS
A$="Gfa"
PRINT LEN(A$)
PRINT LEN("BASIC"+A$)
|
|
| Fonction: |
Calcule la longueur de la chaîne de caractères x$.
|
|
| Explications: |
|
'x$' est une chaîne de caractères quelconque.
LEN calcule le nombre de caractères de la chaîne x$. Les caractères non affichables et les caractères blancs sont également pris en compte. On obtient dans l'exemple les valeurs 4 et 9.
|
|
|
|
|
|
|
|
|
FONCTION
|
LOC
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
LOF
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
LOG
LOG10
|
|
|
| Syntaxe: |
LOG(x)
LOG10(x)
|
|
| Exemple(s): |
CLS
A=2.7182818285
PRINT LOG(A)
PRINT LOG(A^2)
PRINT LOG10(10*10*10)
PRINT LOG10(2.456)
|
|
| Fonction: |
Calcule le logarithme népérien (LOG) ou le logarithme à base 10 (LOG10).
|
|
| Explications: |
|
'x' doit être une expression numérique dont la valeur est supérieure à 0.
LOG(x) calcule le logarithme népérien de x (logarithme de base e=2.71828182...).
LOG10(x) calcule le logarithme décimal de x (logarithme de base 10) soit LOG(x)/LOG(10).
|
|
|
|
|
|
|
|
|
FONCTION
|
LPOS
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
MAX
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
MENU
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
MID$
|
|
|
| Syntaxe: |
MID$(string,i[,n])
|
|
| Exemple(s): |
CLS
N$="BASIC Gfa"
PRINT MID$(N$,5)
PRINT MID$(N$,1,3)
PRINT MID$(N$,0,3)
PRINT MID$(N$,3,12)
|
|
| Fonction: |
Extrait une sous-chaîne de 'string' de n caractères à partir de la ième position.
|
|
| Explications: |
|
'string' est une chaîne de caractères (constante ou variable).
'i' et 'n' sont normalement des entiers naturels (constantes ou variables). (Cependant, on peut également introduire des nombres décimaux. L'éditeur ne prendra en compte que la partie entière).
Si le paramètre facultatif 'n' est absent, la fonction extrait tous les caractères de la chaîne 'string' à partir de la ième position.
Sinon, on obtient une sous-chaîne qui commence par le ième caractère et qui comprend n caractères (les caractères blancs sont aussi pris en compte).
Pour i=0, on obtient le même résultat que pour i=1.
Si n est supérieur au nombre de caractères de 'string' situés à droite du ième caractère (inclus), on obtient MID$(string,i).
Si n est nul, on obtient la chaîne vide.
|
|
|
|
|
|
|
|
|
FONCTION
|
MIN
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
MKI$
MKL$
MKF$
|
|
|
| Syntaxe: |
MKI$(n)
MKL$(n)
MKF$(n)
|
|
| Exemple(s): |
CLS
A=0.111
PRINT MKF$(A)
FOR I=0 TO 9
Z=PEEK(VARPTR(A)+I)
PRINT Z,CHR$(Z)
NEXT I
|
|
| Fonction: |
Convertit une valeur numérique en une chaîne de caractères.
|
|
| Explications: |
|
'n' est une expression numérique. Les fonctions convertissent les valeurs de ces expressions numériques en chaîne de caractères, à savoir:
MKI$ convertit un entier sur 16 bits en une chaîne de deux caractères.
MKL$ convertit un entier sur 32 bits en une chaîne de caractères de quatre caractères.
MKF$ met 'n' sous le format flottant spécifique aux TI68K (10 octets).
Toute donnée numérique que l'on veut stocker sur un fichier à accès direct doit d'abord être convertie en une chaîne de caractères à l'aide des fonctions précédentes.
L'exemple montre que le BASIC Gfa stocke les nombres en mémoire interne sous un format de 10 octets, que l'on peut également obtenir en utilisant la fonction MKF$.
Les fonctions inverses respectives sont:
CVI, CVL, CVF.
A noter que sur Atari ST que le format des flottants tient sur 10 octets. Les fonctions MKS$, MKD$ n'existent pas sur TI68K contrairement à la version Atari ST.
|
|
|
|
|
|
|
|
|
FONCTION
|
MOUSEX
MOUSEY
MOUSEK
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
OCT$
|
|
|
| Syntaxe: |
OCT$(x)
|
|
| Exemple(s): |
CLS
A=-1
B=&H22
PRINT OCT$(A)
PRINT OCT$(234)
PRINT OCT$(B)
|
|
| Fonction: |
Convertit la valeur de x en une chaîne de caractères qui est la représentation octale de x.
|
|
| Explications: |
|
'x' est un nombre entier compris entre -2147483648 et +2147483647 dans une représentation quelconque (à savoir l'écriture décimale normale (sans prefixe), l'écriture hexadécimale (préfixe &H), la représentation octale (préfixe &O), la représentation binaire (préfixe &X)) ou une variable du même type. OCT$(x) convertit la valeur x en une chaîne de caractères qui est la représentation octale de x. (c'est-à-dire que la variable B de l'exemple est transformée en "42").
OCT$, tout comme BIN$ et HEX$, considèrent les nombres comme suite de 32 bits et les représentent sans signe, à l'inverse de la représentation décimale normale.
(voir aussi HEX$(x), BIN$(x) et STR$(x)).
|
|
|
|
|
|
|
|
|
FONCTION
|
ODD
|
|
|
| Syntaxe: |
ODD(n)
|
|
| Exemple(s): |
CLS
REPEAT
INPUT "Entrez un nombre pair SVP ";N
UNTIL NOT ODD(N)
|
|
| Fonction: |
Permet d'obtenir la parité d'un nombre.
|
|
| Explications: |
|
'n' est une expression entière.
ODD(n) retourne -1 si n est impaire, et 0 si n est pair.
(voir aussi EVEN).
|
|
|
|
|
|
|
|
|
FONCTION
|
OUT?
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
PEEK
DPEEK
LPEEK
|
|
|
| Syntaxe: |
PEEK(x)
DPEEK(x)
LPEEK(x)
|
|
| Exemple(s): |
CLS
A$="A"
D=ARRPTR(A$)
A=LPEEK(D)
L=DPEEK(D+4)
C+PEEK(A)
PRINT "Adresse descripteur:"'D
PRINT "Adresse:"'A
PRINT "Longueur:"'L
PRINT "Code-ASCII:"'C
|
|
| Fonction: |
Donne le contenu de 1,2 ou 4 octets à partir de l'adresse x.
|
|
| Explications: |
|
'x' est une expression numérique qui représente une adresse.
PEEK(x) renvoie le contenu de l'octet situé à l'adresse x.
DPEEK(x) retourne le contenu de deux octets consécutifs dont les adresses respectives sont x et x+1. DPEEK convertit le nombre binaire contenu dans les 16 bits en un nombre décimal.
Exemple:
Si le premier octet vaut 11 et le deuxième 189, le résultat obtenu est 11*256+189 = 3005.
LPEEK(x) est semblable à DPEEK(x), mais se rapporte à 4 octets.
Exemple:
Le contenu de l'adresse x vaut 8, le contenu de l'adresse x+1 vaut 45, le contenu de l'adresse x+2 vaut 156 et le contenu de l'adresse x+3 vaut 126.
LPEEK(x) vaut 8*256^3+45*256^2+156*256+126 = 137206910.
Dans l'exemple, LPEEK permet d'extraire du descripteur l'adresse à laquelle est mémorisée le contenu de A$. DPEEK retourne la longueur de la chaîne de caractères. Enfin, toujours dans l'exemple, PEEK donne le code ASCII de la lettre 'A'.
(voir à ce sujet, les variables et leur organisation).
|
|
|
|
|
|
|
|
|
FONCTION
|
POINT
|
|
|
| Syntaxe: |
POINT(x,y)
|
|
| Exemple(s): |
CLS
PLOT 50,50
PRINT POINT(49,50)
PRINT POINT(50,50)
|
|
| Fonction: |
Teste si un point est affiché.
|
|
| Explications: |
|
(x,y) sont les coordonnées d'un point sur l'écran. L'origine des coordonnées se trouve dans le coin supérieur gauche de l'écran. Le coin inférieur droit a pour coordonnées (239-127) sur les TI92+/V200, (159,99) sur les TI89/TI89SE/TI89T.
La fonction POINT retourne la valeur -1 (TRUE) ou 0 (FALSE), selon que le pixel (point graphique) pointé est 'allumé' ou 'éteint'.
|
|
|
|
|
|
|
|
|
FONCTION
|
POS
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
RANDOM
|
|
|
| Syntaxe: |
RANDOM(x)
|
|
| Exemple(s): |
CLS
REPEAT
L=RANDOM(6)+1
PRINT L
UNTIL L=3
|
|
| Fonction: |
Retourne un nombre entier aléatoire compris entre 0 (inclus) et x.
|
|
| Explications: |
|
'x' est un nombre quelconque. RANDOM(x) donne un nombre entier aléatoire compris entre 0 (inclus) et x (exclus). Pour garantir une répartition de Laplce (équiprobabilité de tous les événements), il faut donner à x une valeur entière.
RANDOM(x)=TRUNC(x*RND)
L'exemple simule les lancés successifs d'un dé jusqu'à ce qu'on obtienne un 3.
|
|
|
|
|
|
|
|
|
FONCTION
|
RIGHT$
|
|
|
| Syntaxe: |
RIGHT$(string[,n])
|
|
| Exemple(s): |
CLS
N$="BASIC GfA"
PRINT RIGHT$(N$)
PRINT RIGHT$(N$,5)
PRINT RIGHT$(N$,12)
|
|
| Fonction: |
Extrait le dernier ou les n derniers caractères (de droite) de la chaîne 'string'.
|
|
| Explications: |
|
'string' est une chaîne de caractères ou une variable de ce type.
'n' est normalement un nombre entier ou une variable entière (cependant, il est possible de donner à n une valeur décimale. Seule la partie entière sera prise en compte par l'éditeur).
Si le paramètre facultatif n est absent, la fonction retourne le denrier caractère de la chaîne 'string'.
Sinon, la fonction extrait la sous-chaîne composée des n derniers caractères (de droite) de 'string' (les caractères blancs sont pris en compte). Si n est supérieur au nombre total formant la chaîne 'string', on obtient la chaîne 'string' elle-même. Si n=0, on obtient une chaîne vide.
|
|
|
|
|
|
|
|
|
FONCTION
|
RND
|
|
|
| Syntaxe: |
RND[(x)]
|
|
| Exemple(s): |
CLS
FOR I=1 TO 20
PRINT RND
NEXT
|
|
| Fonction: |
Retourne un nombre aléatoire entre 0 et 1.
|
|
| Explications: |
|
Le paramètre facultatif (x) n'est pas pris en compte. RND retourne un nombre aléatoire entre 0 (inclus) et 1 (exclus).
En utilisant la formule:
Z=INT(RND*n)+1
On obtient un nombre entier aléatoire compris entre 1 et n (tous les deux inclus).
(voir RANDOM).
|
|
|
|
|
|
|
|
|
FONCTION
|
SGN
|
|
|
| Syntaxe: |
SGN(x)
|
|
| Exemple(s): |
CLS
INPUT A
B=SGN(A)*A
PRINT B
|
|
| Fonction: |
Teste si x est positif, négatif ou nul.
|
|
| Explications: |
|
'x' est une expression numérique quelconque.
SGN(x) est la fonction mathématique Signe.
Elle retourne, selon le cas, la valeur -1, 0 ou 1, à savoir:
0 ,si x=0
+1 ,si x>0
-1 ,si x<0
L'exemple simule la fonction mathématique valeur absolue (voir ABS).
|
|
|
|
|
|
|
|
|
FONCTION
|
SIN
|
|
|
| Syntaxe: |
SIN(x)
|
|
| Exemple(s): |
1) CLS
INPUT RAD
PRINT SIN(RAD)
INPUT DEGRE
PRINT SIN(DEGRE*PI/180)
2) CLS
X_Middle=(LCD_WIDTH+1) DIV 2
Y_Middle=(LCD_HEIGHT+1) DIV 2
PLOT X_Middle, Y_Middle
FOR I=1 TO 5400
X=I/36*COS(I*PI/180)
Y=I/36*SIN(I*PI/180)
PLOT X_Middle+X,Y_Middle+Y
NEXT I
|
|
| Fonction: |
Retourne la valeur du sinus de x.
|
|
| Explications: |
|
'x' est une expression numérique qui indique l'angle (en radians) dont on veut calculer le sinus.
Si l'on veut introduire un angle en degrès, on remplace 'x' par 'deg*PI/180', où PI est une fonction du BASIC GfA qui donne la valeur de la constante universelle pi.
Le premier exemple calcul le sinus d'un angle donné en radians, puis le sinus d'un angle donné en degré.
Le deuxième exemple dessine une spirale degré par degré.
|
|
|
|
|
|
|
|
|
FONCTION
|
SPACE$
|
|
|
| Syntaxe: |
SPACE$(x)
|
|
| Exemple(s): |
CLS
FOR I=0 TO 20
PRINT SPACE$(I),I
NEXT I
|
|
| Fonction: |
Définit une chaîne de caractères composée de x caractères blancs.
|
|
| Explications: |
|
'x' est une expression numérique dont la valeur doit être comprise entre 0 et 32767. Seul est pris en compte la partie entière de x.
Cette instruction donne le même résultat que STRING$(x,32).
|
|
|
|
|
|
|
|
|
FONCTION
|
SPC
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
SQR
|
|
|
| Syntaxe: |
SQR(x)
|
|
| Exemple(s): |
CLS
INPUT X
INPUT Y
DISTANCE=SQR(X*X+Y*Y)
PRINT DISTANCE
|
|
| Fonction: |
Calcule la racine carrée de x.
|
|
| Explications: |
|
'x' est une expression numérique dont la valeur doit être supérieure ou égale à 0.
SQR(x) calcule la racine carrée de x.
Dans l'exemple ci-dessus, on calcule la distance d'un point de coordonnées (X,Y) par rapport au point origine.
Si on veut calculer la racine n-ième d'un nombre avec n<>2 (par exemple la racine troisième), il faut se servir de la formule mathématique suivante:
Racine n-ième de x = x^(1/n)
Ainsi, la racine troisième de 8 est égale à 8^(1/3) = 2.
A noter qu'il est possible d'utiliser le signe mathématique racine carrée disponible sur la TI.
|
|
|
|
|
|
|
|
|
FONCTION
|
STR$
|
|
|
| Syntaxe: |
STR$(x)
|
|
| Exemple(s): |
CLS
A=3.5E56
B=&O22
PRINT STR$(A)
PRINT STR$(234)
PRINT STR$(B)
|
|
| Fonction: |
Convertit la valmeur numérique x en une chaîne de caractères.
|
|
| Explications: |
|
'x' est un nombre dans une représentation quelconque (c'est-à-dire l'écriture décimale normale (sans préfixe), l'écriture hexadécimale (préfixe &H), la représentation octale (préfixe &O), la représentation binaire (préfixe &X)) ou une variable numérique.
STR$(x) convertit la valeur x en une chaîne de caractères correspondant à l'écriture décimale de x (c'est-à-dire que la variable B de l'exemple devient la chaîne "18").
(voir aussi HEX$(x), OCT$(x) et BIN$(x)).
|
|
|
|
|
|
|
|
|
FONCTION
|
STRING$
|
|
|
| Syntaxe: |
STRING$(n,string)
STRING$(n,c)
|
|
| Exemple(s): |
CLS
Z$="A"
PRINT STRING$(50,Z$)
PRINT STRING$(50,"A")
PRINT STRING$(50,65)
PRINT STRING$(25,"AA")
|
|
| Fonction: |
Fournit une chaîne de caractères qui est constituée de n fois la chaîne 'string' ou n fois CHR$(c).
|
|
| Explications: |
|
'n' est un nombre entre 0 et 32767.
'string' est une expression alphanumérique quelconque.
'c' est une expression numérique qui représente le code ASCII d'un caractère.
Une table de correspondance entre les caractères et leurs codes est données en annexe C.
'c' est transformé par l'interpréteur en un nombre entier compris entre 0 et 255.
La fonction retourne une chaîne de caractères qui est constituée de n fois de la chaîne 'string' ou du caractère CHR$(c).
La longueur de la chaîne obtenue ne doit pas dépasser la valeur 32767. L'exemple donne dans tous les quatre cas une chaîne de caractères composée de 50 fois la lettre 'A'.
|
|
|
|
|
|
|
|
|
FONCTION
|
TAB
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
TAN
|
|
|
| Syntaxe: |
TAN(x)
|
|
| Exemple(s): |
CLS
INPUT RAD
PRINT TAN(RAD)
INPUT DEGRE
PRINT TAN(DEGRE*PI/180)
|
|
| Fonction: |
Calcule la tangente de x.
|
|
| Explications: |
|
'x' est une expression numérique qui représente l'angle (en radians) dont on veut calculer la tangente.
Si l'on veut entrer l'angle en degrès, il faut remplacer x par 'deg*PI/180', où PI est une fonction du BASIC Gfa qui retourne une valeur approchée de la constante universelle pi (il est aussi possible d'utiliser le symbole mathématique pi de la TI).
Dans l'exemple, on calcule la tangente d'un angle donné en radians, puis celle d'un angle donné en degrès.
|
|
|
|
|
|
|
|
|
FONCTION
|
TIME$
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
TIMER
|
|
|
| Syntaxe: |
TIMER
|
|
| Exemple(s): |
CLS
T=TIMER
REPEAT
Z=INT((TIMER-T)/2)/100
PRINT AT(10,3);Z''
UNTIL RR_ESC
|
|
| Fonction: |
Calcule et transmet le temps écoulé depuis la mise en route du système, en 1/200 de secondes.
|
|
| Explications: |
|
L'appel de cette fonction permet d'obtenir le temps écoulé depuis le lancement du programme. Cette durée varie par pas de 1/200 secondes.
L'exemple simule un chronomètre affichant les centièmes de secondes.
|
|
|
|
|
|
|
|
|
FONCTION
|
TRUNC
|
|
|
| Syntaxe: |
TRUNC(x)
|
|
| Exemple(s): |
CLS
A=3.1415
PRINT TRUNC(A)
PRINT TRUNC(-12)
PRINT TRUNC(-1.99)
|
|
| Fonction: |
Retourne la partie entière de x obtenue en tronquant la partie après la virgule.
|
|
| Explications: |
|
'x' est une expression numérique quelconque.
La fonction TRUNC est identique à la fonction FIX.
A noter que sur ATARI ST la fonction TRUNC est différente de la fonction INT contrairement aux TI68K
|
|
|
|
|
|
|
|
|
FONCTION
|
TYPE
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
UPPER$
|
|
|
| Syntaxe: |
UPPER$(string)
|
|
| Exemple(s): |
CLS
A$="basic"
PRINT UPPER$(A$)
PRINT UPPER$("1a")
PRINT UPPER$("GfA")
|
|
| Fonction: |
Transforme toutes les lettres minuscules (voyelles infléchies incluses) d'une chaîne de caractères en lettres majuscules.
|
|
| Explications: |
|
'string' est une expression alphanumérique quelconque.
Les caractères qui ne sont pas des lettres alphabétiques restent inchangées.
(Voir aussi LOWER$).
|
|
|
|
|
|
|
|
|
FONCTION
|
VAL
|
|
|
| Syntaxe: |
VAL(x$)
|
|
| Exemple(s): |
CLS
A$="75007 PARIS"
PRINT VAL(A$)
PRINT VAL("1.5E05")
PRINT VAL("GfA")
Print VAL("&HFF")
|
|
| Fonction: |
Convertit, dans la mesure du possible, la chaîne de caractères x$ en une valeur numérique.
|
|
| Explications: |
|
'x$' peut être une chaîne de caractères ou une variable du même type (alphanumérique) quelconque.
La fonction VAL extrait la plus grande sous-chaîne de x$ (en partant de la gauche) qui représente une expression numérique (aussi bien dans la représentation décimale normale (sans préfixe), que dans l'écriture hexadécimale (préfixe &H), ou la représentation octale (préfixe &O) ou encore la représentation binaire (préfixe &X)), et retourne la valeur numérique de cette sous-chaîne.
Pour une chaîne de caractères qui ne représente aucun nombre ou une chaîne vide, on obtient la valeur 0.
|
|
|
|
|
|
|
|
|
FONCTION
|
VAL?
|
|
|
| Non implantée. |
|
|
|
|
|
|
|
|
FONCTION
|
VARPTR
|
|
|
| Syntaxe: |
VARPTR(var)
|
|
| Exemple(s): |
CLS
A%=17
N$="GfA"
PRINT VARPTR(A%)
PRINT LPEEK(VARPTR(A%))
PRINT VARPTR(N$)
PRINT PEEK(VARPTR(N$))
PRINT PEEK(VARPTR(N$)+1)
PRINT PEEK(VARPTR(N$)+2)
|
|
| Fonction: |
Détermine l'adresse (de début) d'une variable.
|
|
| Explications: |
|
'var' est une variable numérique, alphanumérique ou booléenne quelconque. Les variables et leurs contenus sont placés en mémoire selon un schéma bien précis (voir chapitre sur l'organisation des variables dans la FAQ).
VARPTR(var) détermine l'adresse du premier octet où est mémorisé 'var'.
Ainsi, avec l'instruction VARPTR(A%) tirée de l'exemple, on obtient l'adresse du premier des quatres octets qui contiennent A%.
PEEK(VARPTR(N$)) (également tirée de l'exemple ci-dessus) renvoie le code ASCII du premier caractère de la chaîne N$, à savoir 71.
|
|
|
|
|
|
|
|
|
FONCTION
|
VDIBASE
|
|
|
| Non implantée. |
|
|
|
| |
| |
