Les informations de début et fin de programme n'existent pas en TI-Basic.
Il est inutile de déclarer les variables, il faut seulement les initialiser.

Cette initialisation doit être écrite au début du programme.

Les types de variables sont prédéfinis dans une TI. Les lettres majuscules désigneront des nombres réels (ou complexe sur 82stats et après)
Donc aucune déclaration des variables n'est prévue par le TI-Basic.

Observez au passage l'instruction d'affectation : "->" saisi par la touche [sto->] comme "store" en anglais.

Les variables se saisissent par le clavier ou des menus, mais pas par le catalogue de fonctions.
Les lettres majuscules (nombres), listes L1 à L6, et les suites u,v,w sont sur le clavier.
Les autres listes (ti82stats et après) sont dans le menu liste=2nde+stats.
Les matrices dans le menu matrice ([2nde]+[x^-1] à partir de la 83plus/82plus).
Les variables finance dans le menu finance. ([Apps]+[1] à partir de la 83plus/82plus)
Le variable "n" des suites est sur la touche [x,t,¤,n] et dans le catalogue des fonctions.
Tout le reste des variables (sauf ce que je peux avoir oublié) est dans le menu de la touche [var].
Sur TI 82 2nde+var permet d'accéder aux équations de courbes au lieu de var+droite sur les autres TI.

Code

Entrées :
nombres réels a,b

Initialisation :
a initialisé à 1

Début
a<-2   // "a est affecté à la valeur 2" , "a prend la valeur 2"
b<-3*a
Fin

Code

1->A // ceci est l'initialisation
2->A // ceci est le traitement
3A->B

On voit bien que des choses n'ont pas besoin de détail.

Effacer l'écran se fait avec EffEcr. (ClrHome)
L'affichage se fait avec Disp.
La saisie se fait avec Prompt. Cela affiche automatiquement le nom de la variable et un "=?". On peut cumuler les variables.
Pour afficher quelque chose avant la saisie : Input "txt",variable .
Pour effectuer une pause attendant la touche entrer : Pause.
Pour afficher quelque chose avant la pause, on précise le texte à la fonction Pause "txt".
Pour placer un texte/variable en (X,Y) : Output(Y,X,txt)

Vous pouvez afficher une fraction avec : nombre>Frac , >Frac est dans math. Mais Frac n'est supportée que par Disp et Pause.
Vous pouvez utiliser Texte(y,x,arg1,arg2,...) pour afficher dans le graphique.
Avertissement : la fonction ">Frac" ne fonctionne pas dans Output et Texte.

Code

nombres réels c,d
Début

Effacer l'écran

Ecrire "LOL" // ces deux commandes sont la même chose, vocabulaire varié
Afficher "LOL"

  // ces deux saisies de suites montreront la cumulation des variables pour gagner du temps dans le programme avec la commande Prompt
Afficher "c=?"
Lire c
Afficher "d=?"
Lire d

  // affichage et saisie (Input)
Afficher "variable:"
Lire c

  // une simple pause
pause

  // une pause avec affichage
Afficher d
pause

  // montrera que l'affichage et la pause connaissent la commande ">Frac"
Afficher 2/3 sous forme de fraction
Afficher 4/3 sous forme de fraction
pause

Texte graphique au pixel (0;0) : "BONJOUR"

pause   // la pause permet d'admirer avant d'effacer
Effacer l'écran
Placer "coucou" en ligne 2 et colonne 1

Fin

Toutes les fonctions suivantes sont dans le menu prgm.

Code

EffEcr

Disp "LOL

Prompt C,D  // cumule les variables

Input "VARIABLE:",C

Pause

Pause D  // pause et affiche le nombre D

Disp 2/3>Frac      // fonction ">Frac" , ne supporte que Disp et Pause
Pause 4/3>Frac

Texte(0,0,"BONJOUR
Pause

EffEcr
Output(2,1,"COUCOU

Comparaisons pratiques des affichages sur la calculatrice.

Code

EffEcr // Effaçons l'écran
Output(6,14,"ABCDE  // cela dépasse de l'écran et "DE" revient à la ligne

 // Aperçu de l'écran
    ||             ABC||
    ||DE              ||

Disp "12344567890123456789   // la fin est perdue et 6 est remplacé par "..."

    ||123456789012345.||

Pause "AZERTYUIOPQSDFGHJKLM  // "..." signalés, touches fléchées pour défiler

   // aperçu de base
     ||AZERTYUIOPQSDF.||
   // aperçu après un premier défilement
     ||.ERTYUIOPQSDFG.||
   // aperçu après défilement maxi
     ||.UIOPQSDFGHJKLM||

Disp "A" // affichage quelconque, monte l'écran si c'est tout en bas
 // IDEM pour: Pause "A"

 // Vous pouvez afficher du vierge aussi
 // et cela peut aussi monter l'écran et effacer des lignes
Disp ""
Pause ""
Output(1,1,""

Ici j'illustre uniquement les écritures de conditions qu'on utilisera dans les tests Si et les boucles.

Les signes de comparaisons se saisissent chacun avec un unique caractère du menu test=2nde+math. J'utilise la syntaxe du langage C pour les symboles.

Code

Si c>8
Si c>=8  // ">=" représente "supérieur ou égal"
Si c<=8  // "<=" représente "inférieur ou égal"
Si c!=8  // "!=" ou "=/=" représente "différent", le égal barré
Si c>8 et c<20
Si c<8 ou c>20
Si non(c<8)     // complémente le résultat (Faux<->Vrai)

Si c=1 OuExclusif c=0  // n'existe pas sur ti82 basique

Code

If C>8
If C>=8  // ">=" se saisit en un seul caractère avec le menu 2nde+math(test)
If C!=8  // "!=" idem
If C>8 et C<20 // " et " est une fonction
If C<8 ou C>20 // " ou " idem
If non(C<8)    // "non(" idem

If c=1 OuExclusif c=0      // "xor" en anglais
 // cela s'écrit aussi : If c=1 et c!=0 ou c=0 et c!=1
 // ou encore : If c=1 et non(c=0) ou c=0 et non(c=1)
 // ces variantes sont même obligatoires sur ti82basique.

Sachez aussi que la priorité des oprérations est :
-parenthèses (et fonctions à parenthèses)
-calculs
-et
-"ouExclusif" et "ou" sont exécutées de gauche à droite

La TI utilise la fonction If en guise de Si.
Elle supporte le sous-entendu de la fin LORSQU'IL N'Y A QU'UNE INSTRUCTION DEDANS ET PAS D'AUTRE ALTERNATIVE.

Code

Nombres réels a,b,c
Début

Si c=3
alors
a<-2     // UNE SEULE INSTRUCTION POUR CET EXEMPLE
fin_Si

Si c=3
alors
a<-2   // une ou plusieurs instructions
b<-5
fin_Si

Si c=4
alors
a<-3
sinon
a<-5
fin_Si

Fin

Code

If C=3
2->A   // UNE SEULE INSTRUCTION, juste suivant le test

If C=3
Then
2->A   // une ou plusieurs instructions
5->B
End

If C=4
Then
3->A
Else
5->A
End

Vous pouvez aussi imbriquer plusieurs choses. L'exemple suivant est courant.

Code

Si condition1
alors
  // cas1
sinon
    si condition2
    alors
      // cas2
    sinon
      // cas3 (conditions 1 et 2 fausses)
    fin_si
fin_si

La TI connaît trois types de boucles.
Pour : For
Tant que : While
Repète : Repeat

Il faudra parfois adapter vos algorithmes aux instructions de la TI.
Fait xxx tant que yyy ==== Répète xxx jusqu'à non(yyy)

Je vous déconseille de tenter d'utiliser Goto/Lbl qui permettent de faire trop n'importe quoi et causent des bugs si mal utilisés. Le programme saute d'un Goto vers le Label correspondant.
Goto A1
Lbl A1

Une seule instruction ferme les boucles : End
Contrairement aux Fins dont on précise l'instruction ouvrante en algorithmie.

Code

nombres réels a,c,d
Début

Pour d variant de 1 à c par pas de 2
Ecrire d
Fin_Pour

Tant_que a<8
a<-a+1
Fin_Tant_Que

Répète
a<-a-1
jusqu'à a<5

Fait
a<-a+1
tant que a>10  // jusqu'à a>=10

Fin

Code

// ci dessous une syntaxe proche du C que je vois parfois

Pour d variant de 1 à c par pas de 2
Début_Pour
Ecrire d
Fin_Pour

TANT_QUE (A<8) FAIRE
DEBUT_TANT_QUE
A PREND_LA_VALEUR A+1
FIN_TANT_QUE

Répète
Début_répète
a<-a-1
jusqu'à a<5
Fin_répète

Fait
a<-a+1
tant que a>10  // jusqu'à a>=10   // Fin_Fait



Code

For(D,1,C,2
Disp D
End

While A<8
A+1->A
End

Repeat A<5
A-1->A
End

Repeat A>=10
A+1->A
End

NbrAléat (=rand) est la fonction qui donne x réel aléatoire équilibré tel que 0<x<1.

Pour obtenir des entiers variés, les 82stat(fr) ont une fonction simple.
Les Ti82 doivent obligatoirement effectuer un calcul pour obtenir d'autres aléatoires que décimaux.

Je génère ci-dessous un entier aléatoire équilibré entre 3 et 6 inclus. Généralisé à [A,B].

Solution simple :
-sur ti82stat : randInt(3,6)
-sur ti82statfr : entAléat(3,6)

// randInt(A,B) : entre A et B inclus

Solution décomposée : (toujours entre 3 et 6, avec 6-3+1=4)
-sur ti82 : 3+int 4rand
-sur ti82stat : 3+int(4rand)
-sur ti82statfr : 3+ent(4NbrAléat)

// A+int((B-A+1)rand : aléa de A à B

Cela consiste à multiplier l'aléatoire 0<X<1 par y entier pour obtenir 0<yX<y
Puis on le rend entier avec la fonction int. 0<=int(yX)<=y-1<y
Puis on ajoute z tel que z<=z+int(yX)<=z+y-1<z+y
Remarquez que z est inclus et z+y est exclus.
En choisissant y=B-A+1 et z=A, on obtient un entier aléatoire entre A et B inclus.

----------

Les parenthèses à proximité de rand ou NbrAléat doivent être correctement utilisées.
En effet la syntaxe peut commander une liste d'aléatoire au lieu de faire un produit.
NbrAléat(N) : répond une liste de N aléatoires
Donc à ne pas confondre avec le produit NbrAléat*(N).

----------

Vous pouvez initialiser l'aléatoire.

Code

nombre->NbrAléat

Chaque exécution d'une même initialisation sera suivie de la même série pseudo-aléatoire. La configuration d'origine de la TI est 0->NbrAléat.
L'initialisation ressemble à une affectation mais ce n'en est pas une.

La parité se teste de plusieurs manières, la plus courte utilise la fonction partDéc qui donne la partie décimale.
On peut aussi comparer un nombre à sa partie entière.
On peut même étudier le reste de la division. (reste nul si division juste ; voir prochain chapitre si ça vous intéresse)

Les fonctions partDéc(), partEnt() et ent() sont dans le menu math

Cela se généralise à la divisibilité par un nombre quelconque.

Code

Si A est pair

/////////////////////////

Si A divisible par B

Code

If non(parDéc(.5A   // rappelez vous, cela donne If parDéc(A/2)=0

// ou bien

If ent(A/2)=A/2

///////////////////////

If non(partDéc(A/B

// ou bien

If ent(A/B)=A/B

La racine carrée en anglais s'appelle "square root" abrégé en "sqrt" que vous pouvez rencontrer dans des algorithmes.

"floor(X)" en anglais est la fonction entière en math. Elle réduit à l'entier inférieur. Cela correspond à la fonction "int" de TI en anglais et "partEnt" de TI en français.
Je n'ai pas commis d'erreur, c'est TI qui est mal traduite.

La troncature se fait avec "iPart" en anglais et "ent" en français.

"ceil(X)" est l'augmentation à l'entier supérieur. TI n'a pas ça. Remplacez par
Si X-floor(X) est non-nul
alors
1+floor(X)
Fin_Si

Pour arrondir à N décimales, c'est "round(x,N)" en anglais et "arrondi" en français.

On calcule le quotient avec la fonction entière ou bien la troncature.
On calcule le reste avec les décimales ou le quotient.

Mais attention en divisant un nombre négatif :
La partie décimale et la troncature donnent un résultat différent d'Euclide. Le reste est alors négatif et le quotient supérieur à la fraction.
Tandis que la fonction entière donne le résultat rigoureux d'Euclide, le reste positif et le quotient inférieur à la fraction.

Attention à la mauvaise traduction de TI.

partie entière = int = partEnt // rigoureusement euclidien
troncature = iPart = ent

quotient classique en anglais
iPart(N/D)

quotient classique en français
ent(N/D)

quotient rigoureusement euclidien en anglais
int(N/D)

quotient rigoureusement euclidien en français
partEnt(N/D)

Reste classique en anglais :
DfPart(N/D) erreur faible possible
N-iPart(N/D) toujours juste

Reste rigoureusement euclidien en anglais :
N-int(N/D)

Reste classique en français :
DpartDéc(N/D) erreur faible possible
N-Dent(N/D) toujours juste

Reste rigoureusement euclidien en français :
N-DpartEnt(N/D)

Les maximums et les minimums s'obtiennent soit avec des tests soit avec les fonctions max(a,b) et min(a,b).
Avec des alternatives, souvenez vous que le cas d'égalité peut exister.
- ">" / "<="
- ">" / "=" / "<"
- ">=" / "<"

Code

Si A>B , alors X prend la valeur A , fin_si
Si A<=B , alors X prend la valeur B , fin_si

Code

Si A>B
alors
X prend la valeur A
sinon
X prend la valeur B
fin_si

Code

X affecté à la valeur maximale entre A et B

Code

max(A,B)->X

Code

If A>B
A->X
If A<=B
B->X

Code

If A>B
Then
A->X
Else
B->X
End