χ\chiCAS pour TI Nspire

Bernard.Parisse@ujf-grenoble.fr

2020

Table des matières

1  Introduction

Ce document explique comment prendre en main et utiliser efficacement sur calculatrices TI Nspire CX le système de calcul formel χ\chiCAS (une version adaptée du logiciel Xcas pour cette calculatrice) ainsi que l’environnement MicroPython le plus complet à ce jour pour faire des mathématiques sur calculatrices (section 13).

χ\chiCAS est une calculatrice graphique formelle indépendante de la calculatrice nspire avec des fonctionnalités pour les élèves qui envisagent une poursuite d’études en sciences ou en maths : grande varitété de représentations graphiques, géométrie analytique, arithmétique et cryptographie (corps finis premiers et extensions, polynômes, etc.), algèbre, algèbre linéaire, analyse numérique, calcul flottant multi-précision et certifié (arithmétique d’intervalle), etc.

Toutes ces fonctionnalités sont intégrées, on peut représenter sur un même graphique un histogramme et un graphe de fonction et une droite, on peut écrire un programme pour faire une simulation et représenter les résultats graphiquement, ou utiliser les fonctions mathématiques dans un programme en syntaxe Python. De plus les sessions de calcul sont compatibles avec Xcas, Xcas pour Firefox et avec d’autres calculatrices compatibles χ\chiCAS (Numworks, Casio Graph 90 et 35eii).

Ici, on passera un peu de temps à apprendre comment utiliser le shell et les outils d’édition pour ensuite les faire travailler harmonieusement ensemble, sans autres limites que la mémoire et la vitesse de la TI (tout à fait raisonnable pour une calculatrice). Il est donc fortement recommandé de lire cette documentation pour une utilisation optimale de χ\chicas, à l’exception de la section 18 qui s’adresse uniquement aux programmeurs qui souhaitent programmer leur calculatrice en C ou C++.

N.B. : Ce document est interactif, vous pouvez modifier les commandes et voir le résultat de l’exécution des commandes proposées en exemple en cliquant sur le bouton exe (ou en validant avec la touche Entrée).

2  Installation

Avant d’installer χ\chiCAS, vous devrez installer ndless en suivant l’un des tutoriels suivants :

Ensuite, ouvrez le logiciel de communication de la TI Nspire et transférez

Examens :

Mise en garde :
Texas Instruments ne semble pas vouloir laisser ses utilisateurs libres d’utiliser des programmes ndless, et fait tout son possible pour rendre ndless inutilisable à chaque mise à jour (en général sous prétexte de “sécurité”). Si vous faites une mise à jour à partir d’octobre 2020, vous prenez le risque de ne plus pouvoir utiliser ndless donc de ne plus pouvoir utiliser χ\chiCAS. Je vous conseille vivement de ne jamais faire de mise à jour de votre TI Nspire sans vous être bien renseigné sur le site tiplanet.

3  Interface "pretty print"

Cette interface ouvre un écran de calcul similaire à celui du Scratchpad de la TI Nspire (A Calculs du menu principal). À privilégier si vous voulez surtout faire des calculs en profitant de la saisie 2d des expressions. Si vous n’êtes pas sur l’écran d’accueil de la Nspire, tapez la touche ON/HOME. Ensuite tapez 2, puis sélectionnez khicaslua.

Les commandes les plus utilisées de Xcas sont listées depuis la touche menu. On peut accéder au shell (section 4) en tapant * sur une ligne vide, et à l’éditeur de scripts (section 12) en tapant + ou +"nom_de_fichier" (mettre le nom du script sans l’extension .py.tns).

4  Interface shell: premiers pas

Si vous n’êtes pas sur l’écran d’accueil de la Nspire, tapez la touche ON/HOME. Ensuite tapez 2, puis sélectionnez khicas et tapez sur enter (vous pouvez aussi aller dans le répertoire Xcas et sélectionner un exemple puis touche enter pour ouvrir un exemple). Ceci ouvre après une dizaine de secondes un “shell” dans lequel vous pourrez taper les commandes de calcul formel de Xcas. Lors de la première exécution vous devrez choisir entre l’interpréteur Xcas et l’interpréteur MicroPython. Taper enter pour choisir Xcas (sauf si vous êtes principalement intéressé par l’environnement Python, cf. la section 13).
Pour quitter χ\chiCAS et revenir à l’explorateur de la Nspire, il faut taper la touche doc (doc signifie documents) plusieurs fois (deux fois depuis le shell).

Par exemple, tapez 1/2+1/6 puis enter, vous devriez voir le résultat 2/3 s’afficher sur la ligne du dessous.

Vous pouvez recopier dans la ligne de commande une commande de l’historique en utilisant le curseur vers le haut ou vers le bas puis enter, puis vous pouvez modifier la commande et l’exécuter. Par exemple, taper sur la touche curseur vers le haut, enter et remplacez 1/6 par 1/3.

Vous pouvez utiliser le résultat de la dernière commande avec la touche Ctrl-Ans de la calculatrice (ans en couleur au-dessus de la touche (-)). Il vaut en général mieux définir une variable comme résultat d’une commande si on souhaite la réutiliser. Pour cela, on utilise une des deux instructions d’affectation :

Pour vous aider à saisir les commandes Xcas les plus utiles, χ\chiCAS dispose d’un catalogue d’une centaine de commandes, avec une courte description et le plus souvent un exemple d’exécution facile à recopier. Appuyez sur la touche doc, choisissez une catégorie avec le curseur, par exemple Algebre, tapez enter, puis choisissez une commande avec le curseur, par exemple factor. Un deuxième appui sur la touche doc vous affiche une courte description de la commande, en général avec un exemple. En tapant sur tab (ou enter), vous recopiez l’exemple en ligne de commande. Vous pouvez alors valider (enter) ou modifier la commande et valider (enter) pour factoriser un autre polynôme que celui donné en exemple.

Lorsqu’une commande renvoie une expression, celle-ci est affichée en écriture naturelle (affichage 2-d). Vous pouvez faire défiler l’affichage avec les touches du curseur lorsque l’expression est grande. Tapez sur esc pour revenir au shell.

Maintenant essayez de taper la commande plot(sin(x)). Indication: taper doc, puis sélectionner Courbes, ou shift-3.

Lorsqu’une commande renvoie un graphe, celui-ci est affiché. Vous pouvez modifier la fenêtre graphique d’affichage avec les touches + ou - (zoom in ou out), les touches du curseur, orthonormaliser le repère (touche /) ou faire une recherche automatique de l’échelle (autoscale touche *). Pour enlever ou remettre les axes et graduations, tapez sur var. Tapez sur esc pour revenir au shell.

Vous pouvez effacer l’historique des calculs et les variables pour commencer un nouvel exercice : depuis le menu doc sélectionnez 9 Effacer historique. Vous avez ensuite le choix entre effacer l’écran en conservant les variables (touche de validation à droite de la touche U) ou en les effaçant (esc). Vous pouvez visualiser la place occupée par les variables en tapant sur la touche var. Pour effacer une variable pour faire de la place en mémoire, sélectionnez la commande purge dans ce menu, puis taper le nom de variable à effacer (ou sélectionnez la variable depuis le menu var).

Pour quitter χ\chiCAS, appuyez sur la touche doc 2 fois. Lorsque vous lancez une autre application, les variables et l’historique des calculs sont sauvegardés (dans le fichier session.xw.tns du répertoire Xcas de la Nspire), ils seront restaurés lorsque vous reviendrez dans χ\chiCAS.

Remarques :

5  Commandes usuelles de calcul formel

5.1  Développer et factoriser

Depuis le catalogue, sélectionner le sous-menu Algebre (2) ou le menu rapide shift-1

5.2  Analyse

Depuis le catalogue (doc), sélectionner le sous-menu Analyse (4) ou le menu rapide shift-2

5.3  Résoudre

Depuis le catalogue, sélectionner le sous-menu Resoudre (doc puis touche ln)

5.4  Arithmétique

Lorsque cela est nécessaire, on distingue l’arithmétique des entiers de celle des polynômes par l’existence du préfixe i (comme integer) dans un nom de commande, par exemple ifactor factorise un entier (pas trop grand) alors que factor factorise un polynôme (et cfactor factorise un polynôme sur les complexes). Certaines commandes fonctionnent à la fois pour les entiers et les polynômes, par exemple gcd et lcm.

5.4.1  Entiers

Depuis le catalogue, sélectionner le sous-menu Arithmetic, Crypto (doc 5)

Les commandes asc et char permettent de convertir une chaine de caractères en liste d’entiers (entre 0 et 255) et réciproquement, ce qui permet de faire facilement de la cryptographie avec des messages sous forme de chaines de caractères.

5.4.2  Polynômes

Depuis le catalogue, sélectionner le sous-menu Polynomes (8). La variable est par défaut xx, sinon il faut la spécifier en général en dernier argument, par exemple degree(x^2*y) ou degree(x^2*y,x) renvoient 2, alors que degree(x^2*y,y) renvoie 1

5.4.3  /n\mathbb{Z}/n\mathbb{Z} et corps finis

Pour travailler avec des classes modulo nn, utiliser la notation a mod n, par exemple sqrt(2 mod 7). Ceci s’applique aussi pour travailler sur des corps finis premiers /p\mathbb{Z}/p\mathbb{Z}. Pour travailler sur des corps finis non premiers, il faut d’abord définir le corps avec GF, puis on utilise un polynôme en le générateur du corps.

5.5  Algèbre linéaire, vecteurs, matrices

Xcas ne fait pas de différence entre vecteur et liste. Par exemple pour faire le produit scalaire de deux vecteurs, on peut saisir :

v:=[1,2]; w:=[3,4]

onload

Pour saisir une matrice élément par élément, taper sur shift-7 (touche M comme matrice) puis matrix( ou doc i (editer matrice). Vous pouvez ensuite créer une nouvelle matrice ou éditer une matrice existante parmi la liste de variables proposées. Pour de petites matrices, vous pouvez aussi entrer en ligne de commandes une liste de listes de même taille. Par exemple pour définir la matrice A=(1 2 3 4)A=\left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \end{array}\right) on tape

A:=[[1,2],[3,4]]

onload
ou

Il est fortement conseillé de stocker les matrices dans des variables pour éviter de les saisir plusieurs fois.

Pour entrer une matrice dont les coefficients sont donnés par une formule, on peut utiliser la commande matrix, par exemple

renvoie la matrice dont le coefficient ligne jj et colonne kk vaut 1j+k+1\frac{1}{j+k+1} (attention les indices commencent à 0).

La matrice identité de taille nn est renvoyée par la commande idn(n), alors que ranm(n,m,loi,[parametres]) renvoie une matrice à coefficients aléatoires de taille n,mn,m. Par exemple



Pour exécuter une commande sur des matrices, s’il s’agit d’arithmétique de base (+,-,* inverse), on utilise les opérations au clavier. Pour les autres commandes. depuis le catalogue, sélectionner le sous-menu Matrices (menu sin)

6  Probabilités et statistiques

6.1  Tirages aléatoires

Depuis le catalogue, sélectionner le sous-menu Probabilites (menu 9) puis sélectionnez
(réel selon la loi uniforme dans [0,1][0,1]) ou
(entier entre 1 et nn). De nombreuses autres fonctions aléatoires existent, avec comme préfixe rand, suivi par le nom de la loi, par exemple randbinomial(n,p) renvoie un entier aléatoire selon la loi binomiale de paramètres n,pn,p. Pour créer un vecteur ou une matrice aléatoire, utiliser la commande ranv ou ranm (doc Alglin, Matrice), par exemple pour un vecteur de 10 composantes selon la loi normale centrée réduite

6.2  Lois de probabilités

Depuis le catalogue, sélectionner le sous-menu Probabilites (9). Les lois proposées dans le catalogue sont la loi binomiale, la loi normale, la loi exponentielle et la loi uniforme. D’autres lois sont disponibles depuis Tout : chisquared, geometric, multinomial studentd, fisherd, poisson.

Pour obtenir la distribution cumulée d’une loi, on saisit le nom de la loi et le suffixe _cdf (sélectionner cdf dans le catalogue sous-menu Probabilités et taper F1). Pour obtenir la distribution cumulée inverse, on saisit le nom de la loi et le suffixe _icdf (sélectionner cdf dans le catalogue sous-menu Probabilités et taper F2).

Exemple : calcul de l’intervalle centré II pour la loi normale de moyenne 5000 et d’écart-type 200 tel que la probabilité d’être en-dehors de II soit de 5% :

6.3  Statistiques descriptives 1-d

Ces fonctions agissent sur des listes par exemple

l:=[9,11,6,13,17,10]

onload
Depuis le catalogue, sélectionner le sous-menu Statistiques (menu log)

Pour les statistiques 1-d de listes avec effectifs, on remplace l par deux listes de même longueur, la 1ère liste est la liste des valeurs de la série statistique, la 2ème liste est la liste des effectifs. Voir aussi les commandes du menu shift-3 histogram et barplot.

6.4  Statistiques descriptives 2-d, régressions.

Entrez les deux listes de données dans deux variables, par exemple X:=[1,2,3,4,5] et Y:=[3,5,6,8,11], ou dans une variable matrice ayant 2 colonnes, depuis le shell avec le menu shift-6 8 matrix(.
Depuis le catalogue, sélectionner le sous-menu Statistiques (touches doc log), pour les régressions, depuis le shell, tapez shift-6.

Ainsi pour afficher la droite de régression linéaire correspondant aux données X=[1,2,3,4,5] et Y=[3,5,6,8,11], tapez les deux commandes ci-dessus ou éditez une matrice ayant 2 colonnes avec le raccourci shift-6 8. Puis shift-6 enter (ou doc log puis sélectionnez la commande linear_regression_plot() complétez la commande par X,Y) ou par le nom de variable de la matrice puis enter.

Remarque : si vos données sont dans une matrice m ayant 2 lignes au lieu de 2 colonnes, vous pouvez utiliser m^* pour transposer (en fait cela transconjugue, ce qui est identique pour des données réelles).

7  Courbes et autres représentations graphiques

Depuis le catalogue, sélectionner le sous-menu Courbes (accès rapide par doc 7, ou shift-3 depuis le shell).

On peut tracer simultanément plusieurs graphiques, il suffit de séparer les commandes de tracé par ;

Le menu Options (menu ,) vous permet de spécifier certaines options graphiques :

8  Géométrie analytique.

Pour le moment, aucune application de géométrie interactive n’a été portée, l’utilisation de commandes de géométrie analytique de Xcas est donc possible en ligne de commandes, avec des noms de commande en anglais pour le moment, par exemple point, segment, circle, circumcircle, incircle line, triangle, polygon, parallel, perpendicular, bisector, perpen_bisector, center, radius, distance, ...

9  Unités et constantes physiques.

Le menu menu, constantes physiques (raccourci menu pi) et unités physiques (raccourci doc sqrt) affiche

Exemples :
60_(km/h) => _(m/s)
mksa(_hbar_)
usimplify(1_W*1_s)
ufactor(1_W,1_J)

10  L’éditeur d’expressions

Lorsqu’un calcul renvoie une expression, elle est affichée en plein écran dans l’éditeur d’expression 2d. Depuis l’historique des calculs, si le niveau sélectionné est une expression, l’appui sur shift-5 (2d) affiche l’expression dans l’éditeur 2d. En ligne de commande, l’appui sur shift-5 ouvre aussi l’éditeur 2d, soit avec 0 si la ligne de commande était vide, ou avec le contenu de la ligne de commande si celle-ci est syntaxiquement correcte.

Lorsque l’éditeur 2d est ouvert, l’expression est affichée en plein écran et une partie de l’expression est sélectionnée. On peut alors agir sur la sélection en exécutant des commandes saisies via les menus ou le clavier, on peut aussi éditer la sélection (en mode de saisie 1d). Ceci permet de retravailler des sous-expressions ou d’éditer une expression en écriture naturelle.

Vous pouvez annuler la dernière modification effectuée en tapant sur shift-3 (undo).

Taper sur la touche enter pour quitter l’éditeur 2d et copier l’expression en ligne de commande, taper esc pour quitter sans recopier l’expression.

Exemple 1 : nous allons saisir lim x0sin(x)x\lim_{x \rightarrow 0} \frac{\sin(x)}{x} Depuis une ligne de commande vide, taper shift-5 (2d), vous devez voir 0 sélectionné. Tapez sur la touche x et enter, maintenant c’est x qui est en surbrillance. Tapez sur la touche trig (trig renvoie sin, shift trig cos et ctrl trig tan), c’est sin(x)\sin(x) qui est en surbrillance. Tapez sur la touche de division (au-dessus de -), vous devez voir sin(x)0\frac{\sin(x)}{0} avec 0 en surbrillance, tapez x puis enter, vous devez voir sin(x)x\frac{\sin(x)}{x} avec x au dénominateur en surbrillance. Tapez sur le curseur flèche vers le haut pour mettre sin(x)x\frac{\sin(x)}{x} en surbrillance, puis shift-2 4 (pour limit). L’expression est correcte, vous pouvez taper enter pour la recopier en ligne de commande et enter à nouveau pour exécuter le calcul. Si on avait voulu une limite en ++\infty, il aurait fallu déplacer la sélection avec curseur vers la droite, puis faire shift-1 7 (oo) enter.

Exemple 2 : nous allons saisir 0 +1x 4+1dx\int_0^{+\infty} \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir 0 10dx\int_0^1 0 \ dx avec xx sélectionné. Il faut donc changer le 1 de la borne supérieure et le 0 à intégrer. Pour modifier le 0, curseur vers la gauche pour le sélectionner puis 1/(x^4+1) enter, puis curseur vers la gauche shift-1 7 enter. Taper sur enter pour recopier vers la ligne de commande puis enter pour effectuer le calcul, le résultat s’affiche dans l’éditeur 2d, enter quitte l’éditeur avec dans l’historique l’intégrale et sa valeur (en syntaxe algébrique 1d).

Exemple 3 : nous allons calculer et simplifier 1x 4+1dx\int \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir 0 10dx\int_0^1 0 \ dx Déplacez le curseur sur le 0 de la borne inférieure de l’intégrale et tapez sur la touche DEL, vous devez voir 0dx\int 0 \ dx avec le tout sélectionné. Utilisez le curseur vers le bas pour sélectionner 0 et tapez 1/(x^4+1) enter puis enter pour recopier en ligne de commande puis enter pour exécuter le calcul, le résultat s’affiche maintenant dans l’éditeur 2d.
On peut alors sélectionner avec les touches du curseur par exemple l’argument d’un des arctangentes et exécuter shift-1 enter (simplify) pour effectuer une simplification partielle du résultat, puis recommencer avec l’autre arctangente.
On peut simplifier encore plus, en rassemblant les logarithmes. Pour cela il faut d’abord échanger deux des arguments de la somme. Sélectionnez un des logarithmes avec des déplacements du curseur, puis tapez shift-curseur droit ou gauche, cela échange l’argument sélectionné avec son frère de droite ou de gauche. Tapez ensuite ctrl curseur vers la droite ou vers la gauche, ceci augmente la sélection en ajoutant le frère de droite ou de gauche. Une fois les deux logarithmes sélectionnés, taper shift-1 2 enter (factor), puis descendez la sélection sur la somme ou différence de logarithmes, allez dans le menu menu puis enter (Tout), tapez les lettres l, n, c ce qui déplace à la première commande commençant par lnc, sélectionnez lncollect, validez et tapez enfin sur enter (eval).

11  Sessions de calculs

11.1  Edition de l’historique.

En utilisant la touche curseur vers le haut/bas, on se déplace dans l’historique des calculs, le niveau courant est en surbrillance.

Pour modifier l’ordre des niveaux dans l’historique des calculs, tapez ctrl curseur vers le haut ou vers le bas. Pour effacer un niveau, appuyez sur la touche DEL (le niveau est recopié dans le presse-papiers).

Pour modifier un niveau existant, on tape sur shift-5 ou sur shift-4. Dans le premier cas, c’est l’éditeur 2d qui est appelé si le niveau est une expression, dans le deuxième cas, c’est l’éditeur texte qui est appelé. Taper esc pour annuler les modifications ou enter pour valider. Si les modifications sont validées, les lignes de commande situées en-dessous de la ligne modifiée seront automatiquement calculées, tenant compte des modifications, par exemple si vous modifiez un niveau comme A:=1, les lignes situées en-dessous dépendant de A seront actualisées.

Ce processus peut être automatisé en utilisant un curseur, que l’on peut créer avec un assistant, depuis le menu doc, Parameter. Une fois créé, vous pouvez modifier un curseur en tapant sur les touches + ou - lorsque le niveau contenant la commande assume ou parameter est sélectionné (tapez * ou / pour une modification plus rapide).

11.2  Variables

En appuyant sur la touche var vous affichez la liste des variables qui ont une valeur, ainsi que des commandes de gestion de variables. Déplacez le curseur vers une variable puis enter pour la recopier en ligne de commande, DEL copie en ligne de commande la commande d’effacement de la variable (confirmez ensuite avec enter). La commande restart permet d’effacer toutes les variables. La commande assume permet de faire une hypothèse sur une variable, par exemple assume(x>5) (pour saisir >, taper ctrl +)

11.3  Sauvegarde et compatibilité

Vous pouvez sauvegarder une session en tapant sur ctrl save ou doc 2. Vous pouvez ouvrir une session en tapant sur shift save ou doc 4. Les sessions sont sauvegardées avec un nom de fichier terminant par .xw.tns. Vous pouvez les ouvrir sur votre ordinateur avec Xcas ou Xcas pour Firefox. Réciproquement, doc Fich, Exporter comme permet de sauvegarder une session dans ce format, ou dans un autre format pour utiliser votre session sur une calculatrice χ\chiCAS-compatible. Dans Xcas pour Firefox, il faut sélectionner dans les paramètres Nspire CX comme calculatrice puis exporter.

N.B.: vous pouvez sauvegarder le contenu de l’éditeur de script indépendamment de la session, les scripts ont un nom de fichier terminant par .py.tns. Il suffit de renommer le script en enlevant le .tns pour utiliser ce script avec n’importe quel interpréteur compatible Python, par exemple une calculatrice d’un autre constructeur proposant un interpréteur MicroPython. Réciproquement, vous pouvez importer un script Python en faisant une copie du fichier en ajoutant .tns au nom de fichier et en le transférant sur le TI Nspire CX. Vous pouvez alors l’ouvrir dans l’éditeur de script.

12  Programmation

L’environnement de programmation de χ\chicas est assez complet: un éditeur, l’interpréteur de Xcas avec toutes ses commandes (compatibilité partielle avec les modules Python math, cmath, random, turtle, numpy, scipy, giacpy, matplotlib et un sur-ensemble du module kandinsky), avec un outil de mise au point permttant l’exécution en pas à pas. Ce même environnement peut utiliser l’interpréteur MicroPython au lieu de Xcas (cf. section 13).

Vous pouvez programmer en utilisant les structures de commande en français de Xcas ou en utilisant la compatibilité de syntaxe Python. Les programmes très courts (en une ligne) peuvent être saisis directement en ligne de commande. Les programmes plus longs ou que l’on souhaite sauvegarder seront saisis dans l’éditeur de programmes sur la calculatrice, ou bien transférés depuis un PC ou une autre calculatrice.

Des programmes sont installés dans le répertoire Xcas. Vous pouvez les visualiser depuis le shell en tapant doc 4 (Charger), et les exécuter depuis le shell en tapant ctrl r.

12.1  Prise en main (programmation)

Un premier exemple en ligne de commande :
une fonction définie par une expression algébrique. On saisit nom_fonction(parametres):=expression Par exemple, pour définir le périmètre d’un cercle de rayon rr, on peut taper
(pour taper :, faire ctrl puis ,) puis on peut calculer
.

Autre exemple, pour calculer l’intervalle de confiance de seconde connaissant une fréquence pp et un effectif nn, on tape


puis on teste

Autre exemple : avec la tortue de Xcas
La tortue de Xcas est un petit robot qui se déplace selon des ordres qui lui sont donnés en laissant une trace de son passage. Les commandes de la tortue sont accessibles depuis le dernier item du menu menu, par le raccourci doc x 2x^2. Saisir la commande avance dans ce menu puis valider, vous devez voir la tortue (symbolisée par un triangle) avancer de 10 pixels. Taper esc pour revenir en ligne de commande. Saisir la commande tourne_gauche et valider, la tortue a tourné de 90 degrés. Répéter 3 fois ces deux commandes pour afficher un carré.
Pour effacer le dessin et ramener la tortue à l’origine, saisir la commande efface. Pour faire des dessins tortue, il est conseillé d’utiliser l’éditeur de programmes (cf. ci-dessous).

Autre exemple : une boucle “oneliner” en syntaxe Xcas.
Ouvrez le menu Programmes (menu cos), puis sélectionnez l’exemple de pour (curseur sur pour puis Ans)

tapez sur enter, vous devez voir les carrés des entiers de 1 à 10.

Exercice : faire faire un carré à la tortue en utilisant une boucle.

Utilisation de l’éditeur
Modifions cet exemple pour faire afficher les carrés de 1 à nn en utilisant la syntaxe compatible Python et l’éditeur de programmes. Tapez sur esc pour passer du shell à l’éditeur de programmes. Si on vous demande programme ou Tortue faites enter. Ceci ouvre l’éditeur avec une maquette de fonction def f(x): Vérifiez que la syntaxe Python est activée (menu doc), sinon activez-la (8). Remplacez x par n, puis déplacez le curseur en fin de ligne et passez à la ligne (touche à la droite de la touche U). Tapez Shift-2 puis enter (for), placez un j entre for et in range( puis un n entre les parenthèses de range(). À la ligne suivante, tapez shift-3 7 (print) et validez (enter), puis tapez j,j^2). Vous devriez avoir le texte source suivant :

def f(n):
  for j in range(1,n+1):
    print(j,j^2)
  return x


Remplacez x par n dans return (ou effacez la ligne). N.B.: pour la puissance, on peut utiliser ^ ou ** dans KhiCAS (il faut utiliser ** en Python).

Maintenant, tapez enter. Si tout va bien, vous devez voir Success dans la ligne d’état. Sinon, le numéro de ligne de la première erreur est indiqué ainsi que le mot qui a provoqué l’erreur. Le curseur est positionné sur la ligne où l’erreur a été détectée (il peut arriver que l’erreur soit située avant mais détectée un peu plus loin seulement). Si vous utilisez la syntaxe en Python, notez que les structures de programmation sont traduites en langage Xcas, les erreurs affichées le sont par rapport à cette traduction (donc des mots-clefs de fin de structure comme end peuvent avoir été ajoutées).

Si le programme est syntaxiquement correct, vous pouvez le sauvegarder depuis le menu doc. Pour l’exécuter, revenez à la ligne de commande en tapant la touche esc, tapez par exemple f(10), vous devriez voir s’afficher les carrés de 1 à 10.

Attention dans l’éditeur de programmes, l’appui sur la touche enter interprète le contenu de l’éditeur. Pour passer à la ligne suivante, il faut taper sur la touche de validation (à droite de la touche u).

3ième exemple : Calcul de l’intervalle de confiance de terminale
En syntaxe Xcas. On peut le saisir en ligne de commande
On peut éviter les calculs redondants en utilisant une variable locale (utiliser doc Programmes pour saisir fonction, local, return et ffonction)

fonction F(P,N) 
  local D; 
  D:=1.96*sqrt(P*(1-P)/N); 
  return [P-D,P+D]; 
ffonction;


Exercice  Créez un fichier carre.py contenant un script pour afficher un carré avec la tortue. Créez un fichier carren.py pour afficher un carré de nn pixels, en utilisant une fonction d’argument nn et l’instruction repete.

Solution  Depuis l’éditeur de script, faire doc 5 (Effacer). Puis shift-4 efface. Ajouter 4 fois avance; tourne_gauche;. Appuyer sur enter pour tester. Sauvegardez (doc 3 Sauvegarder comme).

Effacer à nouveau (doc 5 effacer) Puis shift-4 efface. Ajouter avant la ligne efface

def f(n):
  for j in range(4):
    avance(n)
    tourne_gauche

puis après la ligne efface; tapez par exemple f(40) puis enter. Ensuite faire doc 3 (Sauvegardez comme).

Un exemple de fonction non algébrique : le calcul du PGCD de 2 entiers.
Utiliser enter pour passer à la ligne. En syntaxe Xcas

fonction pgcd(a,b)
  tantque b!=0 faire
    a,b:=b,irem(a,b);
  ftantque;
  return a;
ffonction


On vérifie
. Le même en syntaxe Python

def pgcd(a,b):
  while b!=0:
    a,b=b,a % b
  return a


Mise au point
La commande debug permet d’exécuter une fonction en mode pas-à-pas, i.e. visualiser l’évolution des variables instruction par instruction, par exemple
debug(pgcd(12345,3425))

12.2  Quelques exemples

Le répertoire Xcas de l’archive contient quelques exemples de programmes (avec fréquemment une représentation graphique) dont :

12.3  Commandes utilisables

Contrairement aux adaptations de MicroPython proposées par les constructeurs (dont celui de la TI Nspire), la programmation en (simili-)Python dans KhiCAS n’est pas une application indépendante. Vous pouvez donc utiliser tous les types de Xcas (par exemple les rationnels) et appliquer toutes les commandes de Xcas dans vos programmes. Ceci correspond plus ou moins à un environnement Python avec les modules math, cmath, random (plus complet que le module urandom fourni par les constructeurs), scipy, numpy, un petit module de graphiques pixelisé (set_pixel(x,y,c), set_pixel() pour synchroniser l’affichage, clear(), draw_line(x1,y1,x2,y2,c), draw_polygon([[x1,y1],[x2,y2],...],c), draw_rectangle(x,y,w,h,c), draw_circle(x,y,r,c), la couleur+epaisseur+remplissage c est un paramètre optionnel, draw_arc(x,y,rx,ry,t1,t2,c) permet de tracer un arc d’ellipse). et pour remplacer matplotlib on peut utiliser les commande graphiques dans un repère de χ\chiCAS (point, line, segment, circle, barplot, histogram et les commandes plot...). De plus, vous pouvez travailler avec des expressions et faire du calcul formel dessus. Pour la liste complète des commandes et une présentation détaillée, on renvoie à la documentation de Xcas.

13  Interpréteur MicroPython intégré

χ\chiCAS est maintenant fourni avec son propre interpréteur MicroPython (qui n’est pas identique à celui fourni par Numworks). Pour passer dans χ\chiCAS de l’interpréteur Xcas à MicroPython et réciproquement vous pouvez taper la commande python ou xcas dans le shell sur une ligne vide. Ces commandes sont accessibles dans le menu rapide shift ).

Attention, si vous lancez MicroPython après avoir travaillé avec Xcas ou/et avec le tableur, il peut ne pas y avoir assez de mémoire pour le tas MicroPython, dans ce cas vous risquez de perdre votre session de travail, pensez à la sauvegarder. Par défaut, 40K sont réservés pour MicroPython. Vous pouvez modifier cette valeur jusqu’à 64K dans la configuration (touche Home puis touche ln). Si vous choisissez une valeur haute, il peut être nécessaire de quitter χ\chiCAS et de le réouvrir pour que le tas puisse être alloué dans une zone mémoire contiguë (problème de fragmentation du tas sinon).

Remarque : lorsque l’interpréteur Xcas est actif, si vous passez en argument à la commande xcas ou python le nom de variable d’une fonction que vous avez programmée, cela affiche son texte source sous forme d’une chaine de caractères en syntaxe Xcas ou Python. Vous pouvez donc programmer en syntaxe Xcas et traduire ensuite en Python si vous devez vous conformer à des règles qui imposent ce langage.

13.1  Les modules standard : math, cmath, random

Ce sont les modules natifs fournis par MicroPython (urandom a été renommé random), et qui sont conforme au standard. D’autres modules MicroPython standard qui ne sont pas destinés à faire des maths sont disponibles. On peut taper halp('modules') pour voir la liste des modules disponibles. Cf l’aide en ligne de MicroPython.

13.2  Le module cas

Il donne accès depuis MicroPython aux commandes natives de Xcas. Il contient une seule commande caseval, qui prend en argument soit une chaine de caractères qui sera évaluée par l’interpréteur de Xcas, soit une chaine de caractères (contenant le nom de commande à exécuter) puis des arguments de type quelconque (représentant les arguments). Le résultat est une chaine de caractères. On peut bien sur appeler eval pour transformer la valeur de retour en objet Python. Exemples :

caseval("sin",0)
caseval("sin(0)")
caseval("integrate","1/x","x")
caseval("integrate","1/x","x",2,3)
a=[1,2,3]
caseval("a:=",a)
caseval("a")

Note: caseval possède deux synonymes xcas et eval_expr.

13.3  Le module graphic

Il s’agit d’un module natif MicroPython qui exporte de Xcas des fonctions de tracé pixelisés. Une partie des commandes est accessible depuis le menu rapide shift . Ce module a des synonymes, kandinsky et casioplot afin de faciliter l’utilisation de scripts Python pour calculatrices Numworks (Epsilon) et Casio.

13.4  Le module matplotl

Il s’agit d’un module natif MicroPython qui exporte de Xcas des fonctions de tracé repéré et vise à une certaine compatibilité avec le module matplotlib (ou un de ses sous-modules) sur PC. Une partie des commandes est accessible depuis le menu rapide shift 0.

13.5  Le module arit

C’est un module natif qui exporte de Xcas des fonctions d’arithmétique entière : test de primalité et prochain nombre premier (par Miller-Rabin), factorisation d’entiers pas trop gros (détection par Pollard-rho du plus petit facteur premier, donc jusqu’à environ 9 chiffres), pgcd et identité de Bèzout, indicatrice d’Euler (si on sait factoriser). J’y ai aussi inclus deux fonctions de conversion liste vers chaine de caractères pour faciliter l’enseignement d’un peu de cryptographie.

13.6  Le module linalg

Il permet de manipuler les listes comme des vecteurs et les listes de listes comme des matrices. Contrairement à Xcas, Python n’est pas un langage spécifiquement adapté aux maths, il faut utiliser des commandes préfixées add, sub, mul pour effectuer les opérations arithmétiques de base + - * sur les vecteurs et matrices représentés par des listes.

Le module linalg est un module natif, qui utilise Xcas pour effectuer la quasi-totalité des calculs.

13.7  Le module numpy

C’est une surcouche du module linalg qui définit une classe array pour représenter les vecteurs et les matrices. On peut alors utiliser + - * pour faire les opérations de base sur vecteurs et matrices.

Le module numpy n’est pas un module natif, c’est un texte source écrit en Python. Son importation consomme donc de la mémoire RAM. Vous pouvez écrire votre propre version de numpy.py et la stocker dans le scriptstore, elle prendra alors la précédence sur la version utilisée par défaut. Cette dernière vise à assurer un minimum de compatibilité avec le module du même nom sur PC. Bien que non natif, ce module est disponible en mode examen (le texte source par défaut est intégré au code source de l’interpréteur MicroPython).

import linalg
import math
class array: 
    def __init__(self, a): 
        self.a = a 
  
    def __add__(self, other): 
        return array(linalg.add(self.a , other.a))
  
    def __sub__(self, other): 
        return array(linalg.sub(self.a , other.a))
  
    def __mul__(self, other):
        if type(self)==array:
            if type(other)==array:
                return array(linalg.mul(self.a , other.a))
            return array(linalg.mul(self.a,other))
        return array(linalg.mul(self,other.a))
    
    def __rmul__(self, other): 
        if type(self)==array:
            if type(other)==array:
                return array(linalg.mul(self.a , other.a))
            return array(linalg.mul(self.a,other))
        return array(linalg.mul(self,other.a))

    def __matmul__(self, other):
        return __mul(self,other)

    def __getitem__(self,key):
        r=(self.a)[key]
        if type(r)==list or type(r)==tuple:
            return array(r)
        return r

    def __setitem__(self, key, value):
        if (type(value)==array):
            (self.a)[key]=value.a
        else:
            (self.a)[key]=value
        return None

    def __len__(self):
        return len(self.a)
    
    def __str__(self): 
        return 'array('+str(self.a)+')'
  
    def __repr__(self): 
        return 'array('+str(self.a)+')'
  
    def __neg__(self):
        return array(-self.a)

    def __pos__(self):
        return self
    
    def __abs__(self):
        return array(linalg.abs(self.a))

    def __round__(self):
        return array(linalg.apply(round,self.a,linalg.matrix))

    def __trunc__(self):
        return array(linalg.apply(trunc,self.a,linalg.matrix))

    def __floor__(self):
        return array(linalg.apply(floor,self.a,linalg.matrix))

    def __ceil__(self):
        return array(linalg.apply(ceil,self.a,linalg.matrix))

    def T(self):
        return array(linalg.transpose(self.a))
            
def real(x):
    if type(x)==array:
        return array(linalg.re(x.a))
    return x.real

def imag(x):
    if type(x)==array:
        return array(linalg.im(x.a))
    return x.imag

def conj(x):
    if type(x)==array:
        return array(linalg.conj(x.a))
    return linalg.conj(x)

def sin(x):
    if type(x)==array:
        return array(linalg.apply(math.sin,x.a,linalg.matrix))
    return math.sin(x)

def cos(x):
    if type(x)==array:
        return array(linalg.apply(math.cos,x.a,linalg.matrix))
    return math.cos(x)

def tan(x):
    if type(x)==array:
        return array(linalg.apply(math.tan,x.a,linalg.matrix))
    return math.tan(x)

def asin(x):
    if type(x)==array:
        return array(linalg.apply(math.asin,x.a,linalg.matrix))
    return math.asin(x)

def acos(x):
    if type(x)==array:
        return array(linalg.apply(math.acos,x.a,linalg.matrix))
    return math.acos(x)

def atan(x):
    if type(x)==array:
        return array(linalg.apply(math.atan,x.a,linalg.matrix))
    return math.atan(x)

def sinh(x):
    if type(x)==array:
        return array(linalg.apply(math.sinh,x.a,linalg.matrix))
    return math.sinh(x)

def cosh(x):
    if type(x)==array:
        return array(linalg.apply(math.cosh,x.a,linalg.matrix))
    return math.cosh(x)

def tanh(x):
    if type(x)==array:
        return array(linalg.apply(math.tanh,x.a,linalg.matrix))
    return math.tanh(x)

def exp(x):
    if type(x)==array:
        return array(linalg.apply(math.exp,x.a,linalg.matrix))
    return math.exp(x)

def log(x):
    if type(x)==array:
        return array(linalg.apply(math.log,x.a,linalg.matrix))
    return math.log(x)

def size(x):
    if type(x)==array:
        return linalg.size(x.a)
    return linalg.size(x)

def shape(x):
    if type(x)==array:
        return linalg.shape(x.a)

def dot(a,b):
    return a*b

def transpose(a):
    if type(x)==array:
        return array(linalg.transpose(x.a))

def trn(a):
    if type(x)==array:
        return array(linalg.conj(linalg.transpose(x.a)))
    return linalg.conj(linalg.transpose(x.a))

def zeros(n,m=0):
    return array(linalg.zeros(n,m))

def ones(n,m=0):
    return array(linalg.ones(n,m))

def eye(n):
    return array(linalg.eye(n))

def det(x):
    if type(x)==array:
        return linalg.det(x.a)
    return linalg.det(x)

def inv(x):
    if type(x)==array:
        return array(linalg.inv(x.a))
    return linalg.inv(x)

def solve(a,b):
    if type(a)==array:
        if type(b)==array:
            return array(linalg.solve(a.a,b.a))
        return array(linalg.solve(a.a,b))
    if type(b)==array:
        return array(linalg.solve(a,b.a))
    return linalg.solve(a,b)

def eig(a):
    if type(a)==array:
        r=linalg.eig(a.a)
        return array(r[0]),array(r[1])
    return linalg.eig(a)

def linspace(a,b,c):
    return array(linalg.linspace(a,b,c))

def arange(a,b,c=1):
    return array(linalg.arange(a,b,c))

def reshape(a,n,m=0):
    if type(n)==tuple:
        m=n[1]
        n=n[0]
    if type(a)==array:
        return array(linalg.matrix(n,m,a.a))
    return linalg.matrix(n,m,a)

14  Applications additionnelles.

Accessibles par le menu doc 1 ou le raccourci clavier shift-ANS. Il y a actuellement le tableau périodique des éléments (d’après Maxime Friess), et quatre exemples d’addin (dont le code source peut servir de modèle aux programmeurs expérimentés souhaitant programmer des addins pour χ\chiCAS) : un tableur formel, la suite de Syracuse (très simple), la fractale de Mandelbrot, un jeu de mastermind (qui peut aussi servir de jeu),

15  Raccourcis claviers.

Dans l’éditeur de programmes :

16  Extinction, reset, horloge.

Comme tout logiciel, χ\chiCAS n’est pas exempt de bugs. Si un calcul bloque, commencez par essayer de l’interrompre en appuyant sur la touche ON. Si cela ne suffit pas, il faut se résoudre à appuyer sur le bouton RESET à l’arrière de la calculatrice. Pour pouvoir relancer χ\chiCAS, il faut au préalable réactiver ndless (depuis 2. Mes documents puis dans le répertoire ndless).

Pour remettre à l’heure l’horloge interne de la calculatrice qui est affichée dans le shell, connectez votre calculatrice avec votre ordinateur ou tapez une commande du type hh,mm=>, par exemple 16,05=>, pour 16h05.

Sur les modèles CX uniquement, le rétro-éclairage de la calculatrice s’éteint automatiquement au bout de quelques dizaines de secondes si on ne fait rien, il suffit de taper sur ON pour rallumer. On peut aussi faire ctrl ON pour forcer l’extinction du rétro-éclairage. Attention, il ne s’agit pas d’une vraie extinction de la calculatrice (il n’y a pas assez d’informations disponibles sur le matériel de Texas Instruments pour le faire). Si vous voulez vraiment éteindre la calculatrice, il faut quitter χ\chiCAS en tapant autant de fois que nécessaire la touche doc (entre 2 et 4 fois). Pour éviter une décharge trop rapide de la batterie, sur les nspire CX, χ\chiCAS se quitte de lui-même au bout de 2 heures d’inactivité (en sauvegardant la session courante sous le nom habituel session.xw.tns). La calculatrice se rallume alors brièvement avant de s’éteindre réellement.

En cas d’inactivité prolongée de plusieurs jours, la calculatrice reboote quand on la rallume, il faut alors reactiver ndless avant de pouvoir utiliser χ\chiCAS.

17  Copyright, licences et remerciements

18  Développement en C++ avec χ\chiCAS et Ndless

Il faut tout d’abord installer le SDK de ndless, sous linux par la commande
git clone --recursive https://github.com/ndless-nspire/Ndless.git
Puis il faut le compiler, ce qui prend une à plusieurs heures selon la puissance de l’ordinateur :

cd Ndless/ndless-sdk/toolchain/
./build_toolchain.sh

Ensuite il faut installer le code source de Giac/Xcas.

wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac/giac_stable.tgz
tar xvfa giac_stable.tgz
cd giac-1.6.0/micropython-1.12/nspire

ouvrir le fichier mklib et ajuster le chemin pour recopier la librairie libmicropy.a, puis

sh mklib
cd ../../src
cp config.h.nspire config.h
cp Makefile.nspire Makefile

ajustez les chemins dans le fichier Makefile puis tapez make.

À compléter.

  

Retour à la page principale de Giac/Xcas.