TI-Basic

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

TI-Basic est le nom non officiel du langage de programmation des calculatrices graphiques Texas Instruments. Ce terme n'est jamais utilisé par Texas Instruments dans les documentations officielles. Par sa philosophie et ses capacités, ce langage se rapproche du BASIC, d'où son nom. Cependant, sa syntaxe est substantiellement différente de celle du BASIC. Le TI-Basic des calculatrices basées sur le Motorola 68000 (« 68 K ») n'est pas le même que celui des calculatrices basées sur le Z80. Chaque modèle de calculatrice dispose de fonctionnalités particulières exploitables par les programmes, mais le cœur du langage est commun.

Le TI-Basic est un langage impératif interprété. Selon les modèles de calculatrices, les instructions peuvent être soit choisies dans des menus, soit tapées en toutes lettres sur un clavier alphanumérique. Dans le premier cas, aucune phase de lexémisation n'est nécessaire, et le programme est directement stocké sous une forme de bytecode. Dans le second cas, une lexémisation est effectuée lors de la première exécution qui suit une modification. Dans tous les cas, l'interprète proprement dit travaille sur le bytecode.

Description succincte du langage[modifier | modifier le code]

Types de données[modifier | modifier le code]

Les variables utilisables sont celles accessibles depuis les écrans de calcul. Par exemple, dans le cas de la TI-82 :

  • les nombres à virgule flottante ;
  • les matrices ;
  • les listes (statistiques) ;
  • les fonctions de graphes ;
  • les variables système;
  • les tableaux de données.

La TI-82 ne permet pas le stockage et la manipulation d'autres types de données, comme les chaînes de caractères. Il est uniquement possible d'afficher des chaînes. Il s'agit d'un langage à typage fort, en considérant qu'il n'est pas possible de modifier ou de choisir le type de valeurs des variables. Les variables sont globales et n'ont pas besoin d'être déclarées avant d'être utilisées dans une expression.

D'autres types de données (par exemple, chaînes de caractères) sont disponibles sur d'autres modèles.

Syntaxe[modifier | modifier le code]

La syntaxe est très simple et adaptée à tout débutant en programmation. Ces machines constituent à l'instar du Basic un excellent moyen de s'initier à la programmation et de découvrir les mathématiques de façon plus « ludique » qu'un cours magistral.

Revers de la médaille, les possibilités sont assez réduites et concentrées uniquement sur les algorithmes mathématiques relativement simples. Certains ont réussi à programmer des programmes plus complexes, par exemple des jeux, mais il est presque impératif dans ce cas d'avoir recours à l'assembleur.

Sur les calculatrices à base de Z80, pour saisir les instructions dans le programme, il ne faut pas les taper au clavier alphanumérique, vu que les lettres représentent des variables. Elles doivent être sélectionnées à chaque fois dans le menu Prgm. Ainsi, pour terminer une expression, c'est le caractère double-point qui est utilisé, celui-ci étant automatiquement ajouté à chaque début de nouvelle ligne. Il est aussi disponible manuellement pour saisir plusieurs instructions sur une même ligne.

Les commandes de contrôle et de boucle doivent être terminées à l'aide du mot-clef End, qui sert de marqueur de fin de bloc (de la même façon que l'accolade dans les langages de la famille du C).

Les erreurs de syntaxe ou d'overflow sont signalées de la même manière que pour toute autre expression saisie sur la machine, et provoquent l'arrêt du programme avec un message d'erreur.

Contrôles[modifier | modifier le code]

Le TI-Basic supporte les concepts fondamentaux de contrôle, à savoir :

  • l'affectation avec la flèche orientée à droite (→) : l'expression située à gauche de la flèche est évaluée, et le résultat est rangé dans la variable située à droite ;
  • les instructions de branchements conditionnels If, Then, Else, EndIf ;
  • les boucles : While (Z80), Repeat (Z80) ou Loop (68K), For ;
  • les branchements, avec l'instruction Goto et les étiquettes désignées par Lbl. De plus, une commande Menu (Z80) ou ToolBar (68K) permet d'afficher un menu d'options, chacune effectuant un branchement vers une étiquette spécifiée.

Entrées/Sorties[modifier | modifier le code]

Les instructions d'entrées/sorties sont :

  • Input et Prompt, afin de demander à l'utilisateur de taper une valeur à affecter à une variable ;
  • Output, afin d'afficher une variable ou une chaîne à un emplacement de l'écran, contrairement à la suivante ;
  • Disp, qui ne permet que de sortir une variable dans le flux de l'écran principal ;
  • DispGraph, DispTable, qui affichent le graphe ou la table courante ;
  • Input permet également de récupérer les coordonnées du curseur affiché à l'écran;
  • ClrHome, ClrTable, qui effacent l'écran principal ou la table courante ;
  • PrintScreen(z80), imprime l'écran courant sur un périphérique externe si connecté ;
  • Get et Send auxquels s'ajoutent GetCalc et SendCalc sur 68K et SendChat pour nouvelles 68K; ils exportent ou importent une variable depuis un dispositif externe (une autre machine) ;
  • getKey permet enfin d'obtenir le code (scancode) correspondant à la dernière touche pressée.

Création de fonctions et programmes[modifier | modifier le code]

Dans les calculatrices basées sur le Motorola 68000, une fonction ou un programme peut être créé directement en utilisant la fonction Define, sa syntaxe est:

Define ma_fonction(v1,..,vN) = Func : fonction... : EndFunc

Ceci peut être utilisé à l'intérieur d'une autre fonction et implémente ainsi des fonctions et programmes locaux.

Dans les calculatrices basées sur le Z80, ceci est impossible. La seule possibilité est d'appeler des autres programmes enregistrés sur la machine, en supposant qu'ils sont bien présents, et ceux-ci ne supportent pas d'arguments.

Une stratégie répandue pour simuler l'appel de fonction, prenant un ou plusieurs arguments, et renvoyant une ou plusieurs valeurs est la suivante : si vous avez un programme PrgmA, dans lequel vous utilisez souvent un calcul (une sous-routine), vous pouvez remplacer, dans PrgmA, le morceau suivant :

X->Y

For(I,1,N)

X+cos(I*(I+1)/2)->X

End

par le morceau suivant :

{I,X,N} //est stocke dans Ans

PrgmB

Ans->{I,X,N,Y}

(Ans représente la valeur de la dernière expression calculée.)

Et il vous faut alors définir un autre programme, appelé ici PrgmB, qui aurait la forme suivante : //PrgmB :

Ans(1)->I

Ans(2)->X

Ans(3)->N

X->Y

For(I,1,N)

X+cos(I*(I+1))->X

End

{I,X,N,Y}

L'exemple choisi est bien sur assez ridicule, car on remplace 3 lignes du code du PrgmA par ... 3 lignes du code du PrgmB, qui lui même en prend 7; mais cette stratégie peut être utilisée pour réduire considérablement la taille des programmes, en particulier dans le cas d'une utilisation répétée d'un même morceau de code. Cette stratégie, assez simple à mettre en œuvre, permet aussi de clarifier le code du PrgmA.

Il faut néanmoins être prudent, en particulier sur les variables utilisées par le programme appelé (ici PrgmB), afin de ne pas modifier le contexte utilisé par le programme appelant (ici PrgmA).

Divers[modifier | modifier le code]

Sont disponibles dans les instructions les nombreuses fonctions mathématiques des diverses machines.

Il est possible d'échanger des programmes en reliant deux calculatrices par câble, ou encore en reliant la calculatrice à un ordinateur ; ceci permettant aussi d'avoir recours à un émulateur sur ordinateur afin de faciliter la frappe et la mise au point d'un programme.

Exemples de programmes[modifier | modifier le code]

Hello world[modifier | modifier le code]

Le mot-clef Disp permet d'afficher le traditionnel Hello world à l'écran :

:Disp "HELLO, WORLD !"

Mais l'on peut aussi utiliser une autre fonction, qui affichera hello world aux coordonnées définies par X et Y (coordonnées en pixels pour les TI-89 ou supérieurs, en ligne/colonnes de caractères pour les plus anciennes) :

:Output(Y,X,"HELLO WORLD")

Remarque : les programmes en Ti-Basic n'effectuant qu'une instruction par ligne, les deux exemples précédents sont simplifiables respectivement en :

:Disp "HELLO, WORLD !
:Output(Y,X,"HELLO WORLD

Il est important de préciser que la dernière ligne n'est pas une erreur : en effet l’interpréteur du TI-Basic accepte que des commandes ne soient pas parfaitement bien parenthésées; et il s'agit donc d'une optimisation commune que ne pas écrire les guillemets et les parenthèses en fin de ligne.

La seule faiblesse connue de cette optimisation se rencontre lorsqu'une commande finit par un guillemet, omis, et que la ligne suivante commence par un Lbl[0-9].

Carré d'un nombre[modifier | modifier le code]

Pour faire un programme qui affiche le carré d'un nombre, il faut :

  • entrer le nombre, avec l'instruction Input qui admet en premier argument le message d'invite et en second le nom de la variable qui va recevoir le nombre :
Input "A =",A
  • calculer le carré, grâce à la touche ² et assigner ce résultat à une variable (facultatif) avec à la touche  :
A²→R
  • afficher le nombre, avec l'instruction Disp qui affiche un argument par ligne :
Disp "A² =",R

Les instructions Input et Disp se trouvent dans le sous-menu I/O en appuyant sur PRGM durant l'édition du programme.

Jeu du pile ou face[modifier | modifier le code]

Ce programme est un jeu qui simule plusieurs fois le lancer d'une pièce. Elle retombe soit sur le côté pile, soit sur le côté face. Vous y apprendrez comment utiliser la fonction de génération d'entier aléatoire, autrement dit randInt(. Notez que ce programme est la racine du jeu, et qu'il est possible d'y ajouter des fonctionnalités ensuite.

:Lbl D                                                      Étiquette du Début du programme.
:0->N                                                       Initialisation de la variable N (Touche STO-> Pour ->)
:Menu("PILE OU FACE","PILE",A1,"FACE",A2,"QUITTER",Q)       Menu préprogrammé. S'il n'est pas dans vos fonctions, suivez l'aide ***
:Lbl A1                                                      Étiquette du choix PILE
:1->J                                                       La variable J prend la valeur 1. Le joueur a choisi PILE
:Goto B                                                     Aller à l'étiquette B
:Lbl A2                                                     Étiquette du choix FACE
:0->J                                                       La variable J prend la valeur 0. Le joueur a choisi FACE
:Lbl B                                                      Étiquette B
:randInt(0,1)->N                                            La variable N prend la valeur d'un entier (0,1,2,3,4,5...) entre 0 et 1.
:if N=J                                                     Si le nombre aléatoire est égal au nombre choisi par le joueur.
:Then                                                       Alors...
:Disp "GAGNE !                                              Afficher GAGNE !
:else                                                       Sinon...
:Disp "PERDU !                                              Afficher PERDU !
:End                                                        Fin Boucle Si
:Pause                                                      Maintenir le resultat affiché.
:Goto D                                                     Aller à l'étiquette du Début du programme.
:Lbl Q                                                      Étiquette Quitter le jeu.
:output(1,1,"                                               Retire le Done lors de l'arrêt du programme.


***Le menu est une fonctionnalité qui aide beaucoup, seulement si votre OS ne l'a pas vous pouvez utiliser :

:Disp "0. PILE
:Disp "1. FACE
:Input "VOTRE CHOIX",J

Trouver les diviseurs d'un nombre (dans ℕ)[modifier | modifier le code]

Ce programme permet de trouver les diviseurs d'un nombre. Il montre plusieurs structures essentielles de la programmation TI-Basic. Il stocke ces diviseurs dans une liste L1 qu'il affiche en fin d'exécution.

:0→P                   Initialisation de la variable
:Input "N=", N         Demande le nombre dont on veut trouver les diviseurs
:ClrList L1            Suppression de la liste L1 (si existante)
:For I,1,N             Début de la boucle For : Pour I variant de 1 à N
:N/I→A                 Divise le nombre choisi au départ par le Input par un diviseur possible
:If fPart(A)=0         Si la partie décimale de A est nulle...
:Then                  ...Alors...
:P+1→P                 ...On incrémente la variable...
:I→L1(P)               ...Et on stocke le diviseur dans L1
:End                   Fin de la boucle If
:End                   Fin de la boucle For
:Pause L1              Fin du programme par une pause sur les valeurs de L1 (les diviseurs de N), appuyez sur ENTER

NB : Il est inutile de tester tous les nombres de 1 à N, on peut se contenter d'aller jusque N/2, ou mieux \sqrt{N}, (Il ne faut alors pas oublier de mettre N, qui est un diviseur, dans la liste)

Trouver les racines réelles d'une fonction trinôme[modifier | modifier le code]

Ce programme permet de trouver les racines réelles d'une fonction du second degré. Il effectue le calcul du discriminant, et en fonction de celui-ci il calcule la ou les éventuelles racines.

:Lbl 1                      A ne mettre que si l'on écrit la boucle entrer/ annul (voir fin programme)
:EffEcr                     On efface l'écran
:Disp "FORME AX²+BX+C"      On indique à l'utilisateur à quoi correspondent les lettres A, B et C demandées plus tard 
:Prompt A,B,C               Pareil que :Input "A=", A  mais moins gourmand en caractères donc en mémoire, demande A, B et C
:B²-4AC→D                   Calcul de delta le discriminant
:Disp "DELTA=",D            On informe l'utilisateur de ce que vaut le discriminant
:If D<0                     Si D inférieur à 0, alors...  
:Disp "PAS DE RACINES"      écrit...
:If D>0:Then                Si D supérieur à 0, alors...
:Disp "IL Y A 2 RACINES"    écrit...
:((-B+√(D))/(2A)→E          calcul et stockage de la première racine
:((-B-√(D))/(2A)→F          calcul et stockage de la deuxième racine
:Disp E,F                   on affiche les deux racines
:End                        fin de la condition 
:If D=0:Then                Si D est égal à 0, alors...
:Disp "IL Y A 1 RACINE"     écrit...
:(-B)/(2A)→G                calcul et stockage de la racine
:Disp G                     on affiche la racine
:End                        fin de la condition
Pas obligatoire (en italique) : l'appui sur "annul" permet de quitter le programme, sur "entrer" de le recommencer  
:Repeat K = 105             tant que l'utilisateur n'appuie pas sur entrer...
:codetouche → K             La variable K est assimilée au codeTouche  
:If K = 45 : Goto 2         L'appui sur la touche annul envoi à Lbl 2
:End                        Fin de boucle
:Goto 1                     Retour au départ
:Lbl 2                      Après avoir appuyé sur "Annul"
:EffEcr                     Efface l'écran
:Output(1,1,"              Évite l'inscription de "Fait" à l'écran

Sources[modifier | modifier le code]

  • Manuel d'utilisation de la TI-82.

Voir aussi[modifier | modifier le code]

Liens externes[modifier | modifier le code]