Programmation Basic Casio/Commandes de base

Cette page décrit les commandes de base qui permettent de mettre en place de premiers programmes fonctionnels. Toutes les manipulations de touches décrites supposent que vous soyez dans le mode RUN par défaut de la calculatrice tout à fait suffisant pour écrire des programmes simples !

Afficher du texte

Pour l'instant, exécuter votre programme ne sert à rien car il ne contient aucun code. Il faut Revenir dans l'éditeur puis entrer un texte entre guillemets (accessibles par la touche [ALPHA]), par exemple "LA POMME EST UN FRUIT". En exécutant le programme, on voit en principe le texte « LA POMME EST UN FRUIT » s'afficher.

À noter que si on avait omis les guillemets, le programme aurait effectué la multiplication de toutes les variables correspondant aux lettres du texte, puis aurait retourné la valeur du produit. Voir la section suivante expliquant le fonctionnement des variables. Voici une des premières spécificités du Basic Casio car il n'est pas besoin de mettre la commande PRINT devant le texte à afficher; seuls les guillemets suffisent.

Enchainer des opérations

Lorsque vous tapez 2+2 sur votre calculatrice vous exécutez déjà un programme, un simple programme qui effectue l'opération 2+2 et qui affiche le résultat. Vous pouvez rappeler ces programmes en utilisant les touches fléchées « replay » haut et bas et les modifier avec les touches fléchées gauche et droite. Par défaut si vous modifiez votre programme le texte se superpose au texte existant, pour insérer du texte au milieu d'un programme existant, utiliser le mode INS (shift + DEL).

Il est rare qu'un programme se limite a une seule opération, même si par le biais de recoupements et simplifications on peut limiter le nombre d'opérations (en programmation on parlera d'instructions), on voudra forcément à un moment effectuer plusieurs instructions de suite. Avec la fonction replay vous pourrez demander a la calculatrice de réeffectuer chaque opération, ou bien automatiser cela en utilisant des séparateurs d'instructions comme le retour chariot « ↵ » ou le deux-points « : ». Le retour charriot est accessible via shift EXE, le deux points dans le menu de programmation (shift vars f6 f5), à noter que ces deux séparateurs sont strictement identiques au niveau des fonctionnalités et changent uniquement au niveau de la lisibilité.

Vous pouvez faire des programmes comme « 1+1:2+2 », ou « 1+1↵2+2 » dorénavant (le retour chariot provoque un retour à la ligne sur votre calculatrice mais nous ne l'afficherons pas ici par souci de lisibilité), vous êtes limités a 64Ko cependant, mais avec 7 octets utilisés pour l'instant (le basic casio utilise généralement un octet pour chaque caractère) vous avez de la marge.

À noter que le résultat de la première opération n'est pas affiché, la casio n'affiche que le résultat de la dernière opération qu'elle a effectuée, pour afficher le résultat de la première opération 1+1 on utilise le séparateur d'instructions display (shift vars f5) qui ressemble à « ◢ » et qui affiche le résultat de l'instruction précédente, il attend également une pression sur EXE de l'utilisateur pour poursuivre le programme. « 1+1◢2+2 » affiche le résultat des deux opérations.

Les variables

Lorsque vous tapez 1+1 puis EXE puis appuyez sur un opérateur (+, -, ÷...) la calculatrice ajoutera automatiquement « Ans » à gauche de l'opérateur, qui signifie Answer, c'est à dire la réponse de la dernière opération. Ans+2 vaudra 4 (1 + 1 + 2) dans ce cas-là. Ans est une variable car sa valeur varie, vous pouvez forcer son emploi dans vos programmes via shift et moins (celui qui se trouve à gauche de EXE). Maintenant comment faire lorsqu'on veut utiliser le résultat d'une opération effectuée avant la dernière opération sachant que Ans ne contient que le résultat de la dernière opération ? Par exemple un programme qui fasse l'addition des deux précédentes opérations. Pour cela il va falloir utiliser des variables nommées plus permanentes appelées alphanumériques.

Alphanumériques

Les variables alphanumériques sont les lettres rouges affichées au-dessus des touches, elles sont au nombre de 28 en comprenant les 26 lettres de l'alphabet plus les signes thêta et rhô. Il faut appuyer sur la touche rouge Alpha pour y accéder, par exemple pour connaître la valeur de la variable A, appuyer sur [ALPHA] puis la touche correspondant à la lettre « A » ([X,O,T] en l'occurrence). Puis appuyer sur [EXE]. Si elle ne contient rien, il s'affichera 0.

Contrairement à Ans dont la valeur se met à jour automatiquement les valeurs des variables alphanumériques doivent être « assignées », pour cela on utilise la flèche présente en dessous de la touche tangente (tan) qui correspond à la valeur getkey^? 25. Si on veut affecter la valeur 2 à la variable A, il faut utiliser la syntaxe: 2->A (cet article utilise -> plutôt que → car certains ordinateurs n'affichent pas correctement ce dernier caractère). C'est la syntaxe inverse de nombreux langages de programmation qui mettent la variable assignée à gauche de l'opérateur d'assignement (généralement un signe égal « = ») et cela peut dérouter un programmeur expérimenté. En demandant l'affichage de la valeur de A comme expliqué dans le point précédent, on constate que la Variable A contient effectivement la valeur 2.

Il est possible d'effectuer des affectations composées comme 3+B->A. Cela aura pour effet d'assigner la valeur de B plus la constante 3 a la variable A. Pour incrémenter^? (augmenter de un) une valeur de 1, on peut s'y prendre ainsi: A+1→A. Le langage Casio ne gère pas la syntaxe comme A++ , familière de langages plus évolués.

Toutes les variables sont limitées à l'intervalle numérique [-1e-99 ; 1e+99] et ne gèrent que 10 chiffres significatifs.

Pour assigner le même nombre à toute une série de variables, on peut utiliser le tilde ~ (accessible par [ALPHA][F3]) entre les deux variables bornes. Par exemple 3->B~U met 3 dans toutes les variables entre B et U. On met très souvent 0->A~Z en début des programmes pour réinitialiser toutes les variables.

Les variables X et Y sont spéciales car elles contiennent les valeurs de retour de certaines fonctions graphiques (Plot par exemple) donc leur valeur peut être imprévisible et changer contre la volonté du programmeur, il faut donc faire attention quand on utilise ces variables dans des programmes graphiques.

Variables de liste

Les listes sont, comme leur nom l'indique, une "liste" de variables, ou d'un point de vue de programmation un groupe de plusieurs variables qui se suivent. Elles sont bien commodes pour ne pas être limité dans un programme par le nombre faible de variables alphanumériques. Ces listes sont en fait les listes que l'on utilise dans le menu STATS de la calculatrice. La Casio fournit 6 listes nommées List 1, List 2... List 6.

Pour s'en servir dans un programme, il faut la déclarer. Pour la déclarer, il y a 2 syntaxes : soit {1,2,3,4,5,6}->List 1 pour une liste dont on définit les valeurs immédiatement (les valeurs 1 2 3 4 5 6 sont bien entendu des exemples...) ; soit 6->Dim List 1. C'est une syntaxe qui correspond à une déclaration en extension. Ceci donne la dimension de la liste 1 (une liste de 6 valeurs dans l'exemple) et remplit ces 6 variables de 0. On l'utilise donc dans le cas d'une liste qu'on définira (remplira) plus loin dans un programme. À noter que la variable X->Dim ListY permet d'utiliser une valeur variable pour X mais pas pour Y, c’est-à-dire qu'on peut créer une liste de taille voulue, mais pas dans la liste voulue.

Une systaxe pour déclarer une liste en compréhension existe: Seq(expression,variable a faire varier,valeur de départ (incluse),valeur de fin (incluse),pas)->List (numéro) Par exemple Seq(10+X,X,10,20,1)->List 1 créé une liste de la sorte {20, 21, 22, 23, 24, 25, 26, 27 28, 29, 30}.

Comme on l'a dit précédemment une liste est un groupe de plusieurs valeurs qui se suivent, pour accéder à la troisième valeur de la liste 1 on peut l’adresser ainsi : List 1[3]. Les crochets disent que on peut accéder à une valeur précise dans la liste qui se trouve à l'adresse indiquée entre les crochets. Vu que les valeurs se suivent, on peut accéder à la valeur suivante ainsi List 1[3+1], ou même accéder à une valeur arbitraire List 1[A] (A est une variable alphanumérique qui contient un nombre comme on l'a vu précédemment), attention à ce que la valeur de A soit dans les limites de la liste, si A vaut -1 ou 7 dans une liste de taille 6 si vous appellez List 1[A], une erreur survient !

Un autre avantage des listes est qu'on peut les utiliser avec les fonctions des statistiques ! Notamment, cela va permettre de fluidifier énormément la partie graphique d'un programme (une ligne tracer en F-Line sera plus lente à s'afficher qu'une ligne en DrawStat). Ainsi le DrawStat est une fonction très utilisée avec les listes pour les jeux en général puisqu'elle permet l'affichage d'une ligne, d'un petit carré, d'une petite croix, etc. Pour utiliser les listes en mode graphique il faut d'abord déterminer lequel des 3 graphes disponibles vous allez utiliser. Dans votre code, vous écrirez cela ainsi : S-Graph1 DrawOn ou S-Graph1 DrawOff. Bien sûr, après, il faut définir le type du graphe, les listes qui y seront liées... Et pour tracer une ligne à partir des listes 1 et 2, cela donne : S-Graph1 DrawOn,xyline,List1,List2,1,Dot. On résume : S-Graph1 définit le graphe utilisé, DrawOn définit l'état du graphe, xyline définit l'aspect du graphe (ici une LIGNE), List1,List2 définissent les listes utilisées par le graphe (dans l'ordre abscisse, ordonnée, bien entendu), 1 donne la fréquence et enfin Dot précise que les différents points du graphe seront des points (si vous mettez square, votre ligne aura de petits carrés à ses extrémités...).

En plus de la fonction graphique, les listes permettent certaines fonctionnalités comme Min(List1) qui vous donnera la valeur minimale de la liste 1. On peut faire des opérations arithmétiques sur les listes, List 1 x 0->List 1 remet à zero toute la liste, on peut transformer deux listes en matrice, extraire une colonne ou ligne de matrice vers une liste.

Dans les anciens modèles de casio lycee le module de liste etait absent mais on pouvait transformer n'importe quelle variable alphanumérique en liste et l'utiliser comme A[12] ou Z[J] mais il fallait d'abord étendre la mémoire de la variable avec l'instruction Defm <variable>

Variables matricielles

Les matrices font peut-être peur. Pourtant, c'est l'un des (voire le) outils les plus pratiques de la programmation en BASIC CASIO. D'ailleurs ce n'est pas si compliqué : il s'agit simplement d'un tableau de variables ! On pourrait modéliser une variable ainsi :

                1 2 3
                4 5 6
                7 8 9

Et voila, c'est tout. vous avez ici une matrice de taille 3x3. Elles sont très utiles si vous manquez de variables, elles sont très utiles pour un menu de sauvegarde (car les données d'une matrice ne sont pas supprimées avec l'extinction de la calculatrice) et elles ont plein d'autres possibilités.

Comment on s'en sert? Il faut d'abord la déclarer. La déclaration est assez similaire à la déclaration d'une liste, mais il existe une différence : une matrice est un tableau avec lignes et colonnes, une liste est simplement une ligne. On la déclare donc de 2 façons différentes :

                 {3,3}->Dim Mat A ou [[1,2,3][4,5,6][7,8,9]]->Mat A.

On notera 2 petites différences avec la liste : la liste est définie avec des accolades {} et la matrice avec des crochets [] excepter pour le dimensionnement {}. De plus, la matrice comme vous pouvez le constater a pour nom une lettre alors qu'une liste est identifiée à son numéro. On note bien sur la différence dût simplement à la différence entre tableau et ligne c'est à dire 2 valeur dans la dimension à la place d'une seule.[[1,2,3][4,5,6][7,8,9]] une suite 1,2,3 sera une ligne, lorsqu'on sépare avec ][ on passe à la ligne suivante. Dans une liste, tout est entré dans une même ligne puisqu'il n'y a pas de colonne.

Maintenant, comment on s'en sert vraiment? Cela dépend de l'utilisation que vous lui réservez. Si vous voulez vous servir de la valeur 5 dans l'exemple et la ranger dans une variable, il faut utiliser la syntaxe : Mat A[2,2]->variable. Vous sélectionnez la valeur en la localisant dans le tableau [x,y]. Attention à ne pas oublier de préciser le nom de la matrice ! c'est un oubli assez courant.

Variables système

La calculatrice propose plusieurs modules de statistiques, de graphismes, de calculs complexes, ... Les variables utilisées par ces modules sont accessibles via le menu [VARS], si vous faites des programmes liés à ces modules vous pouvez les utiliser sinon il n'est pas utile de s'y attarder...

Le menu de programmation

Mais les fonctions de programmation les plus intéressantes se trouvent ailleurs, regroupées dans un menu a priori peu accessible (c'est juste une chose qu'il faut connaître). On n'y accède pas en naviguant dans une quelconque arborescence; mais en effectuant la combinaison de touches [SHIFT][VARS] (shift puis vars) dans l'éditeur (cela fonctionne également dans le mode RUN ; en fait, il est même possible d'écrire des programmes dans le mode RUN en séparant les instructions par un retour chariot ([SHIFT][EXE]) mais cela se révèle généralement moins pratique que le mode PRGM où l'on peut nommer son programme, le protéger par un mot de passe, etc.).

Voici la liste de toutes les fonctions accessibles dans ce menu ainsi que les possibilités qu'elles fournissent au programmeur qui les utilisent:

Note: Pour mieux illustrer les exemples, des instructions gratuites (n'ayant qu'un rôle purement démonstratif) seront rajoutées. Ces instructions ressemblent à "TEXTE" ou A+B->C et ne servent qu'à vous exercer à repérer le code superflu et à vous habituer à la lecture de vrais programmes.

Menu COM

Séparer des instructions

Un des intérêts de base de la programmation est d'effectuer plusieurs opérations à la suite, là où on a l'habitude d'entrer nos calculs un par un dans la calculatrice... Comment séparer les instructions ? Il y a 3 manières : le retour chariot « ↵ » , le [DISP] qui ressemble a un triangle rectangle noir « ◢ » et le séparateur d'instructions en ligne « : ». Le premier séparateur est accessible par une simple pression sur [EXE] dans le mode [PRGM], et par [SHIFT][EXE] dans le mode [RUN], les deux instructions suivantes nécessitent une fois dans le mode [RUN] ou [PRGM] d'entrer dans le menu de programmation accessible respectivement par la succession de touches [SHIFT][VARS][F5] et [SHIFT][VARS][F6][F5]. Il est temps de voir ce que le menu [SHIFT][VARS] ([PRGM]) nous réserve...

If/Then/Else/IfEnd

Ces instructions permettent d'exécuter des parties de votre code en précisant les conditions qui permettront leur exécution:

If (condition)
Then (code exécuté si la condition est vérifiée)
Else (code exécuté si la condition n'est pas validée)
IfEnd

(à noter que les parenthèses ne sont pas indispensables)

En français:

Si (condition)
Donc (code exécuté si la condition est vérifiée)
Sinon (code exécuté si la condition n'est pas validée)
SiFin

Concrètement, cela peut donner:

Code d'exemple

Résultat

... "TEXTE" 4→D If A=2 Then A+B→C "LA CONDITION EST VÉRIFIÉE" Else 4→D "LA CONDITION N'EST PAS VÉRIFIÉE" IfEnd 2+5 5→A ...

Précédent du programme Affichage du texte "TEXTE" Affectation "4" a la variable "D" Test "A=2" Si le test est valide, affectation de la variable "C" par la somme des variables "A" et "B" Et affichage du texte "LA CONDITION EST VÉRIFIÉE" Si le test est invalide, affectation de la variable "D" par la valeur "4" Et affichage du texte "LA CONDITION N'EST PAS VÉRIFIÉE" Fin de la zone concernée par le test "A=2" Calcul de l'opération 2+5 (le résultat étant stocké dans la variable "Ans") Affectation de la valeur "5" à la variable "A" Suite du programme

Le "Else" est optionnel. Si il est absent et que la condition de test n'est pas vérifiée, alors aucune des instructions situées entre le Then et le IfEnd ne seront exécutées.

Même le IfEnd est optionnel. Si il est absent, la condition regroupera tout le programme. C'est à dire que si le test n'est pas vérifié, aucune instruction du programme ne s'exécutera. Le IfEnd sert à borner les instructions conditionnelles. C'est à dire que toutes les instructions situées avant le IfEnd seront exécutées en fonction du test d'entrée. Toutes les instructions après le IfEnd seront exécutées, indépendamment du If.

Il est à noter que le If peut être enrichi par des "logic gates" que l'on utilise en électronique comme And ou Or (les plus utilisées). ainsi on aura par exemple :

If (condition) And (condition2)
Then (code exécuté si la condition est vérifiée)
Else (code exécuté si la condition n'est pas validée)
IfEnd

While/WhileEnd

Les instructions incluses entre un While et un WhileEnd s'exécutent tant que le test effectué lors du while est validé.

While (test)
(instructions exécutées si le test est validé et autant de fois qu'il l'est)
WhileEnd

Le test est généralement une comparaison d'infériorité ou de supériorité. Par exemple on peut tester si telle variable est inférieure à telle valeur numérique. Tant que ce n'est pas le cas, on effectue une instruction lambda et on augmente la valeur de la variable jusqu'à ce que celle-ci atteigne la valeur de seuil, validant le test du while et permettant la poursuite du programme après le bloc.

Do/LpWhile

La boucle Do/LpWhile fonctionne à peu près de la même manière que While/WhileEnd à la différence que le test est effectué au niveau du WhileEnd, c'est à dire que même si il n'est pas validé, le code entre Do et LpWhile aurait été exécuté au moins une fois, alors que cela n'aurait pas été le cas avec While/WhileEnd.

Do
(instructions exécutées une première fois puis autant de fois que le test est validé)
LpWhile (test)

Utiliser cette boucle ou une boucle For/Next plutôt que While est généralement un moyen d'optimiser son code dans certaines circonstances. En pratique, le débutant peut fort bien se débrouiller uniquement avec des While voire avec des Goto, mais ces derniers ont tant été décriés que nous ne saurions vous conseiller de les utiliser par défaut.

For/To/Step/Next

Ces instructions permettent d'exécuter des instructions entre le For et le Next de manière répétitive.

For (Valeur initiale)->(variable du compteur) To (valeur finale) Step (valeur du pas)
(code exécuté tant que la variable ne franchit pas la valeur de la valeur finale)
Next

En français :

De la (Valeur initiale)->(variable) Jusqu'à la (valeur finale) Par étapes de (valeur du pas)
(code exécuté tant que la variable ne franchit pas la valeur de la valeur finale) Recommencer // tant que la variable ne franchit pas la valeur finale.

L'ensemble commencé par le For et terminé par le Next est appelé une boucle car les instructions situées dans cet ensemble s'exécuteront plusieurs fois de manière répétée. De la même manière qu'on dit « passer une musique en boucle », on exécutera ici des instructions en boucle. Ci-dessous seront expliquées les règles qui régissent cette boucle et la manière d'en sortir. À noter que la valeur du <pas> est de "1" par défaut et qu'il n'est pas nécessaire de la préciser si on veut la conserver à cette valeur.

C'est une instruction difficile à expliquer car elle en contient de nombreuses autres. Elle est destinée en pratique à effectuer des motifs linéaires avec un minimum de lignes de code. Il s'agit donc d'une fonction servant principalement à optimiser un code, et sa maîtrise est loin d'être indispensable pour monter des programmes fonctionnels mais s'avère très pratique pour les programmeurs expérimentés.

Menu CTL

Prog

Cette instruction permet de faire appel à un autre programme. On peut utiliser ça comme une fonction (pour d'autres langages informatiques) ou pour des sous-programmes complets.

Prog "Nom du programme"

Si vous êtes dans le menu RUN, vous pouvez lancer un programme avec cette instruction.

Return

Dans un programme appelé par une instruction "Prog", cette instruction permet de revenir au programme "parent" à l'endroit de l'instruction "Prog", ou de l'arrêter si il s'agit du programme principal. C'est une manière d'interrompre un programme avant d'arriver au bout des lignes de code.

Programme "MAIN"
"A"?→A
Prog "Carre"

Programme "CARRE"
AxA→A
return

le return permet de stopper l’exécution, il est facultatif si le sous-programme doit s’exécuter entièrement.

Break

Cette instruction interrompt une boucle While, Do, For.

Par exemple

0->A
'BOUCLE INFINIE
While 1=1
A+1->A
If A=10 
Then Break
IfEnd
"ON EST DANS LA BOUCLE"
WhileEnd
"ON EST SORTI DE LA BOUCLE"

Affichera « ON EST DANS LA BOUCLE » dix fois et « ON EST SORTI DE LA BOUCLE » une fois. À noter que While 1 est une boucle infinie car sa condition est toujours vraie, on peut également écrire While 1.

Break sort d'un bloc While, Do, For et continue le programme après le premier WhileEnd, LpWhile, Next qui lui correspond. On ne peut pas sortir de deux boucles imbriquées. Par exemple

For 1->A to 5
For 1->B to 6
If B=3
Then Break
IfEnd
"ON EST DANS B"
Next
"ON EST SORTI DE B"
Next
"ON EST SORTI DE A"

Le break sort de la boucle 1->B to 6 mais pas de la boucle 1->A to 5. Si vous voulez sortir des deux boucles, utilisez un Goto (il s'agit d'une des rares circonstances où le Goto est nécessaire !) ou bien rajoutez un deuxième Break à la fin de la première boucle.

Stop

Cette instruction interrompt un programme

À noter qu'il ne sert à rien de mettre un Stop à la fin du programme, celui-ci s’arrêtera tout seul.

Absence de Continue

Un des absents majeurs de l'aspect impératif du BASIC CASIO est le « Continue » qui permet de revenir au début d'une boucle, par exemple

While 1
?->A
A=1=>Continue
Break
WhileEnd

N'est pas possible. Pour émuler cette fonctionnalité vous pouvez imbriquer deux boucles et utiliser un Break

While 1
While 1
?->A
A=1=>Break
Break
WhileEnd
A≠1=>Break
WhileEnd

Ou plus simplement un GoTo (vous êtes totalement justifié d'en utiliser ici)

While 1
Lbl A
?->A
A=1=>Goto A
Break
WhileEnd

Menu JUMP

Un programme exécute automatiquement chaque instruction de manière séquentielle un jump permet de s'affranchir de cette limite et de sauter a des endroits précis du code.

Lbl

Lbl = Label. Cela permet de faire des sauts dans les programmes. S'utilise avec Goto.

Goto

Goto = Go To (Aller Vers). Cela permet de faire des sauts dans les programmes. S'utilise avec Lbl. Exemple :

Lbl 2:"A":Goto 2

Affiche A à l'infini

Cependant cet exemple est un mauvais exemple ! Ici, on utilise Goto/Lbl comme une boucle ce qui est AFFREUSEMENT MAUVAIS ! D'abord, abuser des Labels peut faire planter votre programme, mais en plus cela est bien moins rapide qu'une boucle While/WhileEnd.

Mais en pratique le Goto est nécessaire dans deux cas:

Premièrement quand on veut “Break”er de plusieurs boucles imbriquées, contrairement au Java ou au Javascript qui permettent des Break étiquettés du Style « Break label » ou au PHP qui autorise la syntaxe « Break X » ou X est le nombre de boucles qu'on veut “break”er, et a la manière du C, C++, Python... le Basic Casio ne permet pas de Breaker de plus d'une boucle.

Deuxièmement quand on veut émuler un « Continue », le Basic Casio ne propose pas de « Continue ».

Instruction =>

Forme contractée de l'instruction If-Then Exemple :

A<10=>Goto 5

Si A<10 Alors Aller vers le Label 5

On notera aussi que pour une condition de type

If A<10 And B>15 And C =2
Then Goto 5
IfEnd

On écrira ceci avec la forme contractée

A<10=>B>15=>C=2=>Goto 5

Il est aussi à noter que l'on ne peut pas utiliser cette forme contractée pour une condition qui amène à plusieurs résultats. Par exemple :

If A<10
Then 1->A
Int 5Ran# +2->B
Goto 1
IfEnd

Ce code ne peut pas s'écrire sous la forme contractée. L'erreur classique est d'essayer de faire

A<10=>1->A And int 5Ran# +2->B And Goto 1

Pas d'illusion : ceci ne fonctionne pas.

Cette instruction ne fonctionne pas avec la Graph 100, utilisez seulement des If/Then/IfEnd !

Isz

Instruction d'incrémentation. Exemple :

Isz A

Équivaut à A+1→A

Pourquoi cette instruction est dans le menu JUMP ? Lorsque la variable atteint 0, le programme saute l'instruction suivante et effectue la deuxième instruction suivante. Il faut toutefois utiliser le séparateur d'instructions multiples « : » pour que cela fonctionne.

Dsz

Instruction de décrémentation. Exemple :

Dsz A

Équivaut à A-1→A

Il n'y a pas de différence de vitesse d’exécution entre Dsz A et A-1->A, cependant cela prend moins de place et c'est tout de même plus "propre" d'utiliser Isz et Dsz.

Pourquoi cette instruction est dans le menu JUMP ? Lorsque la variable atteint 0, le programme saute l'instruction suivante et effectue la deuxième instruction suivante. Il faut toutefois utiliser le séparateur d'instructions multiples « : » pour que cela fonctionne.

Commande ?

Cette commande demande a l'utilisateur d'entrer une variable. Elle doit être un nombre valide. Exemple :

?→R
2xπxR→P

Formule du périmètre d'un cercle. On peut mettre cette commande directement après un texte à la place d'un retour a la ligne ou d'un [DISP]

"ENTREZ LE RAYON"?->R

Ce qui rend le programme plus joli et naturel.

Commande [disp]

C'est un triangle noir dans le menu de programmation. Affiche le résultat de la dernière instruction et attend que l'utilisateur appuie sur [EXE] pour continuer le programme. Manière simple de mettre le programme en pause. Utilise syntaxiquement la place du séparateur d'instruction, affiche le résultat de la dernière instruction (la valeur de Ans) et un - Disp - à l'écran.

Menu CLR

CLR est l'abréviation de "Clear" qui signifie nettoyer. Alors comme vous pouvez vous en douter, ce menu permet de nettoyer différentes choses.

ClrText

Efface tout l'écran Syntaxe :

ClrText

ClrGraph

La commande ClrGraph contient le préfixe "Clr" qui signifie "Clear" en anglais ou "Effacer" en français. Donc cela sert tout simplement à effacer le Graph. En fait, cela remet les paramètres de vos graph à 0. Par exemple si vous avez paramétré

S-Graph1 DrawOn,Scatter,List1,List2,1,Square
ClrGraph

Et bien votre graphe est complètement nettoyé et n'a plus le moindre paramètre.

ClrList

ClrList comme les autres "Clr" sert à effacer quelque chose et ici il s'agit d'une liste. On définit par exemple une liste ainsi

{12,55,2,98,55555,123,798}->List1

Et que l'on fait ensuite

ClrList 1

La liste 1 est nettoyée et n'a plus ni dimension, ni valeur.

Menu REL

Le menu REL (qui signifie RELATIF) est un menu très simple qui ne nécessite que très peu (voir aucune)d'explications. Dans ce menu on a 6 choix

=
=| qui signifie différent de
<
>
=< qui signifie inférieur ou égal à
>= qui signifie supérieur ou égal à

Ca permet de comparer deux valeurs, si la comparaison est vérifiée (2>1, 3|=4, ...) renvoie 1, sinon renvoie 0, cela permet de tester la valeur de certaines variables dans divers lieux du programme mais principalement les If, et les conditions de boucle While... Un programme simple interactif peut être

?->A
If A=42:Then "BRAVO"

Ce programme demande a l'utilisateur d'entrer un nombre et affiche « BRAVO » si l'utilisateur a entré le nombre 42. Exercice simple : modifiez ce code pour afficher « BRAVO » si l'utilisateur a entré un nombre inférieur à 10.

Menu I/O

Ces commandes permettent de gérer les entrées et les sorties du programme (In/Out), c'est à dire ce que le programme affiche a l'écran et ce que l'utilisateur fait. À noter que le guillemet « " » et la commande « ? » permettent respectivement d'afficher du texte et de quérir une valeur à l'utilisateur mais ne sont pas dans ce menu.

Locate

Affiche un texte ou une variable à un endroit précis sur l'écran. Généralement, les écrans font 21 caractères en longueur x 7 caractères en hauteur. Syntaxe :

Locate PositionLigne,PositionColonne,"Texte"
Locate PositionLigne,PositionColonne,Variable

Attention néanmoins, le programme considère que les coordonnées que vous entrez dans votre outil Locate correspondent à celle du premier caractère que vous souhaitez afficher. En d'autres termes, si vous voulez placer une variable ou un texte à plusieurs caractères, le programme affichera le texte à gauche à partir du point que vous avez indiqué.

Getkey

Retourn la valeur de la touche appuyée. Chaque touche de la calculatrice possède une valeur fixe.

Getkey est une commande qui permet de renvoyer une valeur lorsqu'une touche est appuyée. Tableau des valeurs :

79 69 59 49 39 29
78 68 58 48 38 28          
77 67 57 47 37 27          
76 66 56 46 36 26          
75 65 55 45 35 25         
74 64 54 44 34            
73 63 53 43 33           
72 62 52 42 32          
71 61 51 41 31      
    

Cela symbolise le clavier de votre calculatrice. Si vous n'arrivez pas à vous le représenter voici un petit code qui vous permettra de connaitre la valeur d'une touche :

Do
Getkey
Ans=>Locate 1,1,Ans
LpWhile 1

Explication du code : -lance directement une boucle (pas besoin de variable on utilise Ans) -Getkey détecte la touche pressée et renvoie le code associé -On vérifie que la valeur renvoyée est différente de 0 (Ans=>) -On écrit la valeur en position 1,1 de l'écran texte -On ferme la boucle avec une condition infinie

Commande :

Le ":" permet simplement de passer à une instruction suivante, comme le retour à la ligne, mais sans retour à la ligne.

Lorsqu'on navigue dans un programme volumineux (plus de 10000 octets) la navigation vers le haut se fait quasi instantanément entre deux instructions reliées avec un deux points, alors que cela peut prendre jusqu'à 10 secondes entre deux instructions séparées par des retours chariots, il deviendra donc une habitude de regrouper des instructions similaires par des deux points et des instructions distinctes par des retour chariot. Par ex:

1->A~B:3->C
?->D
If D=A:Then "D EGAL UN":Else "ESSAYE ENCORE":IfEnd
If B!=C:Then "C'EST EVIDENT":IfEnd

Ecrivez des programmes comme ça pour vous faciliter la vie une fois que vos programmes rempliront une portion non négligeable de votre machine !

À noter que le manuel dit que les instructions de saut Isz et Dsz necessitent un « : » pour fonctionner correctement, mais en pratique un retour charriot et un [disp] fonctionnent aussi.

Menu STR

Le menu STR n'est disponible qu'à partir de l'OS 2. STR est l'abréviation de "String" : les strings sont des chaînes de caractères.

Str

Cette fonction permet de créer un string. On y stockera une chaîne de caractères.

La syntaxe est :

"Ceci est un String"->Str 1

Les fonctions des strings sont très puissantes par rapport aux autres fonctions Basic Casio.

StrJoin

Cette fonction permet de fusionner 2 chaînes de caractères entre elles.

La syntaxe est :

"String 1"->Str 1
"String 2"->Str 2
StrJoin(Str 1,Str 2)->Str 3
Afficher Str 3

On verra alors s'afficher :

String 1String 2

StrLen

Cette fonction sert simplement à donner la longueur d'un String.

La syntaxe est :

"CASIO"->Str 1
StrLen(Str 1)->A

La variable A vaudra alors 5.

StrCmp

Cette fonction va comparer 2 valeurs ou 2 strings.

Pour comparer 2 nombres on utilisera la syntaxe suivante :

StrCmp("35","20")->A
StrCmp("20","20")->B
Strcmp("20","35")->C

Ici, A vaudra 1, B vaudra 0 et C vaudra -1.

Si l'on souhaite comparer 2 Strings, on écrira :

StrCmp(Str 1,Str 2)->A

Si les 2 strings sont caractère pour caractère identiques, alors A vaudra 0, sinon A vaudra 1.

StrSrc

Permet de chercher la position du string 2 dans le string 1.

On utilisera la syntaxe suivante :

"Je suis mauvais"->Str 1
StrSrc(Str 1,"a")->A

A vaudra alors 10 car le premier "a" est en 10e position dans le String1.

Si le programme ne trouve pas la string demandée, la variable prendra pour valeur 0.

StrLeft

Cette fonction permet de sélectionner un nombre donné de caractère dans un String en partant de la gauche.

"bonjour"->Str 1
StrLeft(Str 1,3)->Str 1

Le String 1 vaudra alors : "bon" car il aura pris les 3 premiers caractères en partant de la gauche.

StrRight

Ceci est l'inverse de StrLeft, on prend les caractères en partant de la droite :

"bonjour"->Str 1
StrRight(Str 1,5)->Str 1

Le String 1 vaudra "njour" car on prend les 5 premiers caractères en partant de la droite.

Strmid

Dans le même genre que StrLeft et StrRight, cette fonction sélectionne les caractères à partir du milieu :

"bonjour"->Str 1
StrMid(Str 1,3)->Str 1

Ici le String 1 vaudra "njo" puisqu'il aura pris les 3 lettres les plus centrées.

Exp>Str

On a ici une fonction assez particulière et extrêmement pratique. Elle sert à affecter un Fmem à un String.

"Ceci est un Fmem"->fn1
Exp>Str(fn1,Str 1)

Ici le String 1 contiendra tout ce qui est dans le Fmem. Vous pourrez d'ailleurs remarquer qu'il n'y a pas besoin avec cette fonction de rentrer la sortie dans le String 1, cela est fait automatiquement.

Exp

Cette fonction relativement simple permet d'exécuter le contenu d'un string.

"5+13"->Str 1
Exp(Str 1)->A

Ici A prendra la valeur 18. (5+13=18)

StrUpr

Ici on a une fonction plus esthétique qu'utile. Elle permet de mettre toutes les lettres d'un string en Majuscule.

"Je ne sais plus quoi mettre dans mes strings"->Str 1
StrUpr(Str 1)->Str 1

Le String 1 sera alors "JE NE SAIS PLUS QUOI METTRE DANS MES STRINGS".

StrLwr

C'est l'inverse de StrUpr, cette fonction sert à tout mettre en minuscule :

"MiNuScUlE"->Str 1
StrLwr(Str 1)->Str 1

Le String 1 sera donc "minuscule".

StrInv

Cette fonction permet de renverser toutes les lettres par rapport à un axe de symétrie centrale. Un exemple vaut mieux qu'un long discours :

"Je vais être inversé"->Str 1
StrInv(Str1)->Str 1

On aura donc un String 1 remplit par "ésrevni ertê siav eJ".

StrShift

Cette fonction permet simplement de supprimer le nombre de caractère que vous voulez dans le string. Malheureusement, il ne permet pas de supprimer un caractère précis ayant une position X dans le string...

"Suppression"->Str 1
StrShift(Str 1, 5)->Str 1

On aura alors : "ession".

StrRotate

On a ici une fonction très importante et très utile. En effet, cette fonction peut permettre le scrolling horizontal (on peut également utiliser StrRight/StrLeft/StrShift). Cette fonction permet de faire "rouler" le string.

"Rouler"->Str 1
StrRotate(Str 1,2)->Str 1

Le string contiendra alors : "ulerRo".

Bientôt disponible : Cours sur le Scrolling avec les Strings dans la partie "Techniques avancées".