$\chi$ CAS pour TI83CE et 83CE Python edition

Bernard.Parisse@univ-grenoble-alpes.fr

2024

Table des matières

1 Introduction
2 Installation
3 Interface shell: premiers pas
4 Commandes usuelles de calcul formel
5 Tableur, statistiques
6 Courbes et autres représentations graphiques
- 6.1 Principales commandes graphiques
- 6.2 Interface de l’environnement graphique
7 Unités et constantes physiques.
8 L’éditeur d’expressions
9 Sessions de calculs
10 Interaction avec le système TI.
11 Programmation
- 11.1 Prise en main (programmation)
- 11.2 Commandes utilisables
12 Raccourcis claviers.
13 Extinction, reset, horloge.
14 Copyright, licences et remerciements
15 Compiler sa propre version de KhiCAS
16 Le mot de la fin

1 Introduction

Ce document explique comment prendre en main et utiliser efficacement sur calculatrices TI83 couleur l’application $\chi$ CAS, une version allégée du système de calcul formel Xcas. L’application n’est pas seulement un shell de calcul formel c’est une calculatrice CAS bis, avec

un shell de calcul formel bien sur
une ligne d’état simple, qui affiche l’heure (bien utile en examen lorsque les smartphones sont interdits), le mode insertion par défaut comme sur tous les environnements informatiques contemporains, la touche suppr qui efface vers la gauche, et le mode alphabétique qui est par défaut en minuscules
son propre tableur (pouvant effectuer du calcul exact),
un éditeur d’expressions interactif (on peut sélectionner une partie d’expression et lui appliquer une opération, par exemple développer, factoriser, ... la sélection),
un éditeur de programmes et un interpréteur avec syntaxe Python-compatible permettant l’exécution pas à pas,
une application de représentation graphique “HD”, avec 60% de pixels en plus par rapport à l’application de TI pour mieux visualiser,
quelques outils scientifiques (calcul avec des unités physiques, et pour la version lycée, tableau périodique des éléments).

J’espère qu’une fois que vous l’aurez essayée vous ne pourrez plus vous en passer!

Il y a quelques années circulait sur tiplanet un poisson d’avril sur le portage de Xcas sur TI83 : le challenge paraissait tellement difficile, avec les ressources de cette calculatrice qui nous vient de loin : son processeur est une évolution du microprocesseur 8 bits z80 créé en 1976 (qui équipait les premiers micro-ordinateurs personnels des jeux de ma jeunesse), et la mémoire disponible pour un programme se compte en kilo-octets. Mais la communauté des utilisateurs experts de la TI83 en France et de la TI84 à l’international a réussi en utilisant et créant des outils de développement libres et à force d’un gigantesque travail de rétro-ingéniérie à rendre la chose envisageable.

Aujourd’hui à l’automne 2024, après plusieurs mois de travail, KhiCAS pour ti83 (et 84) est une réalité, et s’ajoute aux innombrabres programmes développés pour cette calculatrice très populaire dans le monde (en particulier aux Etats-Unis). Il y a quand même un tribut à payer : la 83 est significativement plus lente que d’autres calculatrices sur lesquelles j’ai porté Xcas, il faut souvent attendre plusieurs secondes pour avoir le résultat d’un calcul, et j’ai du enlever certaines fonctionnalités pour tenir dans l’espace disponible en flash pour me concentrer sur l’essentiel. Cela devrait toutefois largement suffire pour un lycéen, et fournir un environnement d’exécution plus stable pour $\chi$ CAS que chez les constructeurs concurrents.

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).

Quelques captures d’écran pour illustrer : le shell, saisie d’une expression en 2d, résultat de $\int\frac{dx}{x^4-1}$ affiché en 2d

graphe d’une fonction et affichage de la vitesse, d’un vecteur normal pointant vers le centre du cercle osculateur, une courbe en paramétriques,

de l’aide sur une commande et le résultat de l’exécution des exemples de la commande

2 Installation

L’installation de KhiCAS est différente de celle d’une app habituelle car ce n’est pas une application de TI. Elle nécessite actuellement de vider entièrement la mémoire d’archive de la calculatrice, y compris la localisation en français. Après installation, il est possible de remettre la langue en français.

[Avertissement légal] Attention, la procédure d’installation a été testée de nombreuse fois mais l’auteur ne peut garantir un fonctionnement sans erreurs et décline toute responsabilité en cas de problèmes. [Fin de l’avertissement légal].
Il est essentiel de bien respecter la procédure qui suit, sinon la calculatrice peut se retrouver bloquée. Si votre calculatrice se bloque, pas de panique, vous pourrez toujours réinstaller le système d’exploitation de la calculatrice : pour cela maintenir les touches 2nd et suppr enfoncées, appuyer sur le bouton reset à l’arrière de la calculatrice, relachez tout, puis appuyez sur la touche annul et renvoyez l’OS en vous assurant qu’il s’agit bien de la version de votre calculatrice (cf. le premier item ci-dessous). En effet si vous installez une version supérieure de l’OS, vous ne pourrez plus revenir en arrière et cela augmente en général les contraintes, par exemple le passage en OS version 5.5 ou ultérieure rend l’utilisation de programmes assembleur plus complexe, voire pourrait rendre impossible l’installation ou l’exécution en mode examen de KhiCAS. Ne faites surtout pas de mise à jour depuis le site de TI!
En cas de problèmes persistants, vous pouvez demander de l’aide sur le site tiplanet ou sur le forum de Xcas.

Procédure d’installation de KhiCAS :

Avant de commencer, notez la version de votre OS qui apparait sous la ligne TI-83 en tapant 2nd mem 1 (sur la capture ci-dessous, c’est 5.3.1.0058)

Téléchargez cette version de l’OS pour l’avoir sous la main en cas de problème.
Télécharger $\chi$ CAS pour TI83, version lycée (avec tableau périodique) ou supérieur maths/physique (sans tableau périodique, avec commandes formes quadratiques)
Il faut commencer par effacer la mémoire d’archive. Sauvegardez d’abord vos données et applications, ainsi que la localisation en Français avec le logiciel TI Connect CE. Puis 2nd mem 7 flèche droite 3 2

Vous pouvez aussi effacer complètement la flash avec reset+2nd+suppr puis annul et renvoi de l’OS comme expliqué ci-dessus.
Envoyez INST, artifice et tous les fichiers du répertoire app (dans l’ordre) vers la calculatrice.
Alternative pour les utilisateurs de Windows uniquement : Envoyez le fichier khicas83.b83 (version lycée) ou khicasl2.b83 (version supérieur) à la calculatrice.
Alternative avec TILP sous Unix : lancez le script transfert_tilp.sh
Notez que le processus d’installation va effacer la localisation en Français, vous pourrez le réinstaller ensuite.
Si votre version d’OS est inférieure à 5.5, vous pouvez lancer INST depuis la touche prgm et passer à l’item suivant.
Sur les OS supérieurs à 5.5 (donc sur toutes les calculatrices récentes), vous ne pourrez pas lancer INST avant d’avoir restauré l’accès à l’assembleur. Cela se fait en envoyant l’application CabriJr (voilà une utilisation imprévue mais fort utile pour cette application!). On ouvre Cabri depuis 2nd app, on tape entrée, puis on descend dans le menu à Open pour ouvrir le fichier artifice (de YvanTT) qui va effectuer le “jailbreak” (i.e. restaurer l’accès assembleur), puis on tape la touche entree pour lancer INST
Important : la calculatrice reboote une fois INST terminé, mais cela ne suffit pas, il faut impérativement effacer la RAM avec 2nd mem 7 1 2 avant de pouvoir lancer KhiCAS depuis 2nd app
Vous pouvez maintenant effacer les AppVars restantes AppIns?? (2nd mem 2 alpha B) et restaurer le package de langue Francais si vous avez l’habitude des menus en français de la calculatrice. Il devrait rester 128K (TI83 Python CE avec français) ou 192K ou 256K (TI83 CE OS 5.3 sans le français) d’archive disponible pour installer une petite application et sauvegarder vos données.

Examens :

KhiCAS est conforme à la réglementation du bac en France, circulaire 2015- 178 du 1er octobre 2015, au même titre que les calculatrices CAS des constructeurs (HP Prime, TI Nspire CX/CX2, Casio Classpad). Mais attention, certains autres concours ou examens interdisent l’utilisation de calculatrices formelles. Il est de la responsabilité de l’utilisateur de vérifier que les calculatrices formelles sont autorisées avant d’utiliser $\chi$ CAS dans un autre examen ou concours. Les auteurs ne sauraient être tenus pour responsables en cas d’utilisation non autorisée.
Cette version de $\chi$ CAS n’est pas compatible avec le lancement du mode examen par la procédure officielle de TI sur les OS récents. Une procédure de lancement du mode examen compatible avec KhiCAS et acceptée par TI est à l’étude. Attention, cette procédure ne sera pas compatible avec la toute dernière version de l’OS de TI, ne faites surtout pas de mise à jour depuis le site de TI. J’invite toutes les personnes qui souhaitent que KhiCAS soit utilisable en mode examen à tester cette procédure dès qu’elle sera rendue publique, et à faire remonter les difficultés rencontrées sur le site tiplanet ou sur le forum de Xcas ou en me contactant par email. S’il y a trop de problèmes remontés, en particulier par des enseignants, cela peut inciter le constructeur à améliorer la visibilité de son approbation de l’utiisation KhiCAS en mode examen.

Mise en garde :
Les mises à jour de Texas Instruments peuvent devenir incompatibles avec l’installation de KhiCAS ou son utilisation en mode examen. Je vous conseille vivement de ne jamais faire de mise à jour de votre TI83 sans vous être bien renseigné auparavant sur la compatibilité.

3 Interface shell: premiers pas

Tapez 2nd app, puis sélectionnez KhiCAS. Ceci ouvre un “shell” dans lequel vous pourrez taper les commandes de calcul formel de Xcas. Pour quitter $\chi$ CAS, depuis le shell tapez 2nd quit. Depuis l’éditeur de programmes ou le tableur, il faut faire deux fois 2nd quit.

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.

Essayez maintenant x+1 entrée. Le résultat de la commande est une expression, elle est alors affichée en 2d, taper sur annul pour quitter l’affichage 2d. Si vous voulez saisir une expression en mode 2d, tapez sur 2nd $\int$ . Par example pour saisir $\sin(\frac{x}{2})$ , tapez 2nd $\int$ , vous devez voir 0 en sélection. Tapez x puis entree, vous devez maintenant voir le 0 en sélection remplacé par un $x$ sélectionné. Tapez la touche de division, vous devez voir une fraction avec $x$ au numérateur et 0 sélectionné au dénominateur, tapez 2 entree, cela remplace le 0 sélectionné au dénominateur par un 2 sélectionné, tapez la touche curseur vers le haut, cela sélectionne toute la fraction, tapez la touche trig puis 1 qui va exécuter sin sur la sélection, cela affiche maintenant $\sin(\frac{x}{2})$ sélectionné, tapez entrée pour recopier en ligne de commande.

On peut 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 :

l’affectation vers la droite => s’obtient avec la touche sto $\rightarrow$ de la calculatrice (Ctrl puis var), par exemple 2=>a met 2 dans la variable a. Vous pouvez ensuite utiliser a dans un calcul, sa valeur sera remplacée par 2.
l’affectation vers la gauche =. Par exemple a=2 fait la même chose que 2=>a. Le menu rapide fenetre 9 permet de saisir =, on peut aussi utiliser le menu F3 et sélectionner = dans la table de caractères.

Pour vous aider à saisir les commandes Xcas les plus utiles, $\chi$ CAS dispose de menus rapides (par exemple touche f(x) pour des commandes d’algèbre), d’un catalogue d’une centaine de commandes avec une courte description et le plus souvent un exemple d’exécution facile à recopier (touche math) et d’un catalogue de toutes les commandes (2nd catalog).

Par exemple, pour faire une représentation graphique, appuyez sur la touche zoom (menu graphes), tapez entree (commande plot), puis touche trig 1 (saisie de sin) puis touche x,t,..., ceci donne la ligne de commande plot(sin(x, fermez les parenthèses et tapez entree, vous obtenez le graphe de la fonction sinus. Tapez sur les touches curseur droit pour faire afficher la position du curseur sur la courbe, puis sur annul pour quitter l’application graphique.

Pour avoir une liste plus complète de commandes par catégories, appuyez sur la touche math, choisissez une catégorie avec le curseur, par exemple Algebre, tapez enter, puis choisissez une commande avec le curseur, par exemple factor. Un appui sur la touche F5 (aide cmd) vous affiche une courte description de la commande, en général avec un exemple. En tapant sur F2 (ou F3), vous recopiez l’exemple en ligne de commande. Vous pouvez alors valider (enter) ou modifier la commande et valider (enter), par exemple pour factoriser un autre polynôme que celui donné en exemple.

Enfin, le catalogue (2nd catalog) affiche la liste de toutes les commandes par ordre alphabétique, en tapant les lettres du début du nom de commande on se positionne dans la liste à cet endroit.

Vous pouvez effacer l’historique des calculs et les variables pour commencer un nouvel exercice : depuis le menu var sélectionnez restart. Vous pouvez effacer l’historique en tapant annul une ou deux fois de suite, mais cela n’efface pas les variables.

Pour quitter $\chi$ CAS, appuyez sur les touches 2nd quit. Lorsque vous lancez une autre application, les variables et l’historique des calculs sont sauvegardés dans l’AppVar session, ils seront restaurés lorsque vous reviendrez dans $\chi$ CAS. Il est conseillé de quitter $\chi$ CAS pour éteindre la machine pendant une longue période. C’est aussi conseillé lorsque la mémoire non fragmentée restant disponible affichée en tapant sur la touche var s’approche de 0.

Remarques :

Depuis le shell de calcul, les touches F1 à F5 précédées ou non de 2nd et alpha font apparaitre un petit menu pour saisir rapidement certaines commandes.
Lorsque le curseur est sur la ligne de commande juste après un nom de commande, l’appui sur la touche curseur vers le bas ou sur la touche située une ligne au-dessus de la touche $x^2$ permet de voir l’aide sur la commande (si l’aide existe) et de saisir un exemple.
Exemple : tapez F4, puis 3 (integrate), puis flèche vers le bas
Modifiez l’expression à intégrer selon vos besoin puis tapez enter
Lorsqu’un calcul est en cours, le message “annul: stoppe calcul” apparait, vous pouvez appuyer sur la touche annul pour interrompre le calcul.

4 Commandes usuelles de calcul formel

4.1 Développer et factoriser

Depuis la touche math, sélectionner le sous-menu Algebre (2) ou le menu rapide F2

factor : factorisation. Raccourci clavier shift-* (préfixé) ou =>* (infixé touche sto puis *), par exemple
x^4-1=>*
. Utiliser cfactor pour factoriser sur $\C$ .
partfrac : développement d’un polynôme ou décomposition en éléments simples pour une fraction. Raccourci clavier =>+ (touche sto puis +), par exemple
(x+1)^4=>+
ou
1/(x^4-1)=>+
.
simplify : essai de simplifier une expression. Raccourci clavier =>/ (touche $\rightarrow$ puis /), par exemple
sin(3x)/sin(x)=>/
Attention, cette commande est gourmande en mémoire, et la TI en a peu, le risque de reset existe.
ratnormal : développer une expression, écrire une fraction sous forme irréductible.

4.2 Analyse

Depuis la touche math (doc), sélectionner le sous-menu Analyse (4) ou le menu rapide F4

diff : dérivation. On peut aussi utiliser la notation ' (shift-*) pour dériver par rapport à $x$ , ainsi
diff(sin(x),x)
et
sin(x)'
sont équivalents. Pour dériver plusieurs fois, ajouter le nombre de dérivations par exemple
diff(sin(x^2),x,3)
.
integrate : primitive si 1 ou 2 arguments, par exemple
integrate(sin(x))
ou
integrate(1/(t^4-1),t)
pour $\int \frac{1}{t^4-1} \ dt$
Calcul d’intégrale définie si 4 arguments, par exemple
integrate(sin(x)^4,x,0,pi)
pour $\int_0^\pi \sin(x)^4 \ dx$ . Mettre une des bornes d’intégration sous forme approchée si on souhaite un calcul approché d’intégrale définie, par exemple
integrate(sin(x)^4,x,0.0,pi)

Le calcul approché d’une intégrale est en général nettement plus rapide qu’un calcul exact.
limit : limite d’une expression. Exemple
limit((cos(x)-1)/x^2,x=0)
taylor ou series : développement de Taylor (ou développement limité ou asymptotique). Par exemple taylor(sin(x),x=0,5)
sum : somme discrète. Par exemple
sum(k^2,k,1,n)
calcule $\sum_{k=1}^n k^2$ ,
sum(k^2,k,1,n)=>*
calcule la somme et l’écrit sous forme factorisée.

4.3 Résoudre

Depuis la touche math, sélectionner le sous-menu Resoudre (touche resol après math)

solve permet de résoudre de manière exacte une équation (se ramenant à une équation polynomiale). Il faut préciser la variable si ce n’est pas x par exemple
solve(t^2-1=0,t)
.
Si la recheche exacte échoue, la commande fsolve permet de faire une résolution approchée, soit par une méthode itérative en partant d’une valeur initiale
fsolve(cos(x)=x,x=0.0)
, soit par dichotomie
fsolve(cos(x)=x,x=0..1)
.
Pour avoir des solutions complexes, utiliser csolve.
On peut faire des hypothèses sur la variable que l’on cherche, par exemple
assume(m>1)
puis
solve(m^2-4=0,m)
.
linsolve permet de résoudre des systèmes linéaires. On lui passe la liste des équations et la liste des variables (par convention une expression équivaut à l’équation expression=0). Par exemple
linsolve([x+2y=3,x-y=7],[x,y])
linsolve renvoie la solution générale du système (y compris si la solution n’est pas unique).
Sur les version avec desolve, desolve permet de résoudre de manière exacte certaines équations différentielles, par exemple pour résoudre $y'=2y$ , on tape desolve(y'=2y).
Un exemple où on indique une condition initiale, la variable indépendante et la fonction inconnue :
desolve([y'=2y,y(0)=1],x,y)

4.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.

4.4.1 Entiers

Depuis la touche math, sélectionner le sous-menu Arithmetic, Crypto (5). Menu rapide shift F1.

iquo(a,b), irem(a,b) quotient et reste de la division euclidienne de deux entiers.

iquo(23,13),irem(23,13)
isprime(n) teste si $n$ est un nombre premier. Le test est probabiliste pour de grandes valeurs de $n$ .
isprime(2^64+1)
ifactor(n) factorise un entier pas trop grand (jusque 128 bits environ). Par exemple
ifactor(2^64+1)

Raccourci clavier touches $\rightarrow$ puis * (=>*)
gcd(a,b), lcm(a,b) PGCD et PPCM de deux entiers ou de deux polnômes

gcd(25,15),lcm(25,15)

gcd(x^3-1,x^2-1),lcm(x^3-1,x^2-1)
iegcd(a,b) renvoie 3 entiers $u,v,d$ tels que $au+bv=d$ où $d$ est le PGCD de $a$ et $b$ , avec $|u|<|b|$ et $|v|<|a|$ .

u,v,d:=iegcd(23,13); 23u+13v
ichinrem([a,m],[b,n]) lorsque cela est possible, renvoie $c$ tel que $c=a \pmod m$ et $c=b \pmod n$ (si $m$ et $n$ sont premiers entre eux, $c$ existe).
c,n:=ichinrem([1,23],[2,13]); irem(c,23); irem(c,13)
powmod(a,n,m) calcule $a^n \pmod m$ par l’algorithme de la puissance rapide modulaire.
powmod(7,22,23)

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.

4.4.2 Polynômes

Depuis la touche math, sélectionner le sous-menu Polynomes (7). La variable est par défaut $x$ , 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

coeff(P,n) coefficient de $x^n$ dans $P$ , lcoeff(P) coefficient dominant de $P$ , par exemple
P:=x^3+3x; coeff(P,1); lcoeff(P)
degre(P) degré du polynôme $P$ . degree(x^3)
quo(P,Q), rem(P,Q) quotient et reste de la division euclidienne de P par Q
P:=x^3+7x-5; Q:=x^2+x; quo(P,Q); rem(P,Q)
proot(P) : racines approchées de $P$ (réelles et complexes)
proot(x^5+x+1)
interp(X,Y) : pour deux listes de même taille, polynôme d’interpolation passant par les points $(X_i,Y_i)$ .

X,Y:=[0,1,2,3],[1,-3,-2,0]; P:=interp(X,Y)=>+
resultant(P,Q) : résultant des polynômes $P$ et $Q$ P:=x^3+7x-5; Q:=x^2+x; resultant(P,Q)
tchebyshev1(n) et tchebyshev2(n) polynômes de Tchebyshev de 1ère et 2ème espèce définis par : $T_n(\cos(x))=\cos(nx), \quad U_n(\cos(x))\sin(x)=\sin((n+1)x)$

4.4.3 $\mathbb{Z}/n\mathbb{Z}$ et corps finis

Pour travailler avec des classes modulo $n$ , utiliser la notation a mod n, par exemple sqrt(2 mod 7). Ceci s’applique aussi pour travailler sur des corps finis premiers $\mathbb{Z}/p\mathbb{Z}$ .

4.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
dot(v,w)

Pour saisir une matrice élément par élément, vous pouvez entrer en ligne de commandes une liste de listes de même taille. Par exemple pour définir la matrice $A=\left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \end{array}\right)$ on tape

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

onload
ou
[[1,2],[3,4]]=>A

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
matrix(2,2,(j,k)->1/(j+k+1))
renvoie la matrice dont le coefficient ligne $j$ et colonne $k$ vaut $\frac{1}{j+k+1}$ (attention les indices commencent à 0).

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

U:=ranm(4,4)

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 (math matr) ou le menu rapide matr

egvl(A)

egv(A)
renvoient les valeurs propres et vecteurs propres d’une matrice carrée $A$ .
P,D:=jordan(A)
calcule la forme normale de Jordan d’une matrice $A$ (à coefficients exacts) et renvoie les matrices $P$ et $D$ telles que $P^{-1}AP=D$ , avec $D$ triangulaire supérieure (diagonale si $A$ est diagonalisable)
Ak:=matpow(A,k)
calcule la puissance $k$ -ième d’une matrice $A$ avec $k$ une variable formelle.
rref effectue la réduction sous forme échelonnée d’une matrice $A$ (pivot de Gauss)
lu calcule la décomposition $LU$ d’une matrice $A$ et renvoie une permutation de matrice $P$ et deux matrices $L$ triangulaire inférieure et $U$ triangulaire supérieure telles que $PA=LU$ . Le résultat de la commande P,L,U:=lu(A)
peut être passé en argument à la commande linsolve(P,L,U,v)
pour résoudre un système $Ax=b$ de matrice $A$ en résolvant deux systèmes triangulaires (calcul en $O(n^2)$ au lieu de $O(n^3)$ ).

5 Tableur, statistiques

En tapant depuis le shell sur la touche stats, on ouvre le tableur, qui permet également d’afficher facilement certains représentations graphiques en particulier statistiques.

Les notations usuelles du tableur sont en vigueur, avec une particularité, les lignes commencent à 0 (comme en programmation).

Pour éditer une cellule, taper un caractère (ceci efface le contenu précédent) ou [trace] 4 (item edit_cell du menu edit), ceci n’efface pas le contenu précédent.

Pour saisir le signe = ou $ vous pouvez utiliser le menu edit (touche trace) ou les mêmes raccourcis que sur le tableur de TI (touche sto et 2nd sto).

Pour faire référence à une cellule lors d’une saisie, vous pouvez l’écrire au clavier (les minuscules sont acceptées comme référence de ligne), ou vous pouvez appuyez sur une des deux touches de déplacement de curseur vers le haut ou le bas, puis déplacez le curseur à la cellule choisie et tapez entrée. Pour faire référence à une plage de cellule, tapez alpha : puis curseur vers le haut ou le bas et déplacement jusqu’au coin opposé de la plage. Il est également possible lorsqu’on a déplacé le curseur vers le premier coin de la plage, de taper stats (ou les touches trace 2, correspondant à select dans le menu edit) et de se déplacer à la cellule marquant le coin opposé de la plage puis de taper entree.

Pour obtenir des statistiques sur une série de données entrée au tableur, se déplacer vers la première cellule des données, taper la touche stats, aller vers la dernière cellule des données sur la même colonne ou sur une colonne adjacente, taper à nouveau sur la touche stats. Ceci affiche soit des stats 1d (si les données sont sur une seule colomne), soit covariance et corrélation (si les données sont sur deux colonnes). Les données sont enregistrées dans le presse-papier, et peuvent être insérées en quittant le tableur (2nd quit) et en tapant 2nd inserer.
On peut aussi afficher dans le tableur une valeur statistique qui est mise à jour si les données sont modifiées, se déplacer vers une cellule inutilisée du tableur, taper la touche sto (ce qui insère un =) puis une commande de statistiques (via le menu rapide F1 stat1d ou via le catalogue), puis saisir une plage de cellules.

Pour copier le contenu d’une plage de cellule, se déplacer vers un coin de la plage, taper la touche stats ou les touche trace 2 (select du menu edit), aller au coin opposé de la plage, taper les touches trace 2. Pour sélectionner une cellule seule, taper stats trace 2. Pour copier la sélection à une autre position du tableur ou dans le shell, utiliser 2nd insérer. Dans le shell, ceci recopie la matrice des valeurs.

Pour réaliser une représentation graphique, se rendre vers une cellule non utilisée du tableur, taper = (touche sto), puis taper une commande graphique d’une des menus, puis réaliser une sélection de plage comme indiqué ci-dessus et fermez la parenthèse de la commande. Ensuite taper 2nd graph stats.

Exemple : nuage de points. Rentrer dans les deux premières colonnes les deux coordonnées de la série statistique. Puis passez dans la troisième colonne, Tapez sur la touche sto, puis la touche fenetre (pour stats2d) puis entree pour scatterplot(, puis curseur vers le bas, vers la gauche deux fois, vers le haut pour atteindre un des coins de la zone où sont entrées les valeurs, puis touche trace (menu edit), 2 (pour select), déplacez ensuite avec le curseur pour sélectionner la plage et tapez entree, fermez la parenthèse et validez. Pour voir le graphe, tapez les touches 2nd f(x) (pour graph stats). Si vous changez une des valeurs de la série statistique et refaites 2nd f(x) le graphe est mis à jour.

Un autre exemple de nuage de points en captures d’écran
on entre les données sur les deux premières colonnes, on se déplace sur une cellule vide, on tape sto puis fenetre (stats2d) puis entree

taper stat et aller à la dernière cellule de la plage, taper entree

2nd graph stat montre les points, taper - pour faire un zoom out pour voir tous les points,

se déplacer vers une autre cellule non utilisée, tapez fenetre (stats2d), sélectionner le 4ième item, entrer la plage (ici au clavier), entree puis 2nd graph stats

Lorsqu’on quitte le tableur, l’équation de la droite de régression et son coefficient $r^2$ sont affichés dans le shell.

N.B. : Pour les distributions de probabilité, il n’y avait pas assez de place dans KhiCAS, se reporter aux commandes de l’OS de TI utilisable dans le shell de l’OS.

6 Courbes et autres représentations graphiques

Pour tracer une courbe représentative de fonction, une courbe en paramétrique, une courbe en polaire, etc. on tape dans le shell une commande comme expliqué à la section 6.1 on valide et on se retrouve dans l’environnement graphique décrit dans la section 6.2.

6.1 Principales commandes graphiques

Depuis la touche math, sélectionner le sous-menu Courbes ou à partir du menu rapide, touche zoom depuis le shell

plot(f(x),x=a..b) trace le graphe de $f(x)$ pour $x\in [a,b]$ . On peut spécifier un pas de discrétisation avec xstep=, par exemple plot(x^2,x=-4..4,xstep=1)
plotseq(f(x),x=[u0,a,b]) graphe “en toile d’araignée” de la suite récurrente $u_{n+1}=f(u_n)$ de premier terme $u_0$ donné. Par exemple si $u_{n+1}=\sqrt{2+u_n}, u_0=6$ avec une représentation sur $[0,7]$ plotseq(sqrt(2+x),x=[6,0,7])
plotparam([x(t),y(t)],t=tm..tM) courbe en paramétriques $(x(t),y(t))$ pour $t\in [t_m,t_M]$ . On peut spécifier un pas de discrétisation avec tstep= par exemple plotparam([sin(2t),cos(3t)],t,0,2*pi)
plotpolar(r(theta),theta=a..b) courbe en polaires $r(\theta)$ pour $\theta \in [a,b]$ , par exemple plotpolar(sin(3*theta),theta,0,2*pi)
plotlist(l) pour une liste l, trace la ligne polygonale reliant les points de coordonnées $(i,l_i)$ (indice $i$ commençant à 0).
plotlist([X1,Y1],[X2,Y2],...) trace la ligne polygonale reliant les points de coordonnées $(X_i,Y_i)$
scatterplot(X,Y), polygonscatterplot(X,Y) pour 2 listes X,Y de même taille, trace un nuage de points ou une ligne polygonale reliant les points de coordonnées $(X_i,Y_i)$
histogram(l,class_min,class_size) trace l’histogramme des données de la liste l avec comme largeur de classe class_size en commençant à class_min. Par exemple, on peut tester la qualité du générateur aléatoire avec l:=ranv(500,normald,0,1); histogram(l,-4,0.25); plot(normald(x),x,-4,4)
plotfield(f(t,y),[t=tmin..tmax,y=ymin..ymax]) trace le champ des tangentes à l’équation différentielle $y'=f(t,y)$ . On peut ajouter en dernier paramètre optionnel ,plotode=[t0,y0] pour tracer simultanément la solution passant par la condition initiale $y(t_0)=y_0$ . Exemple $y'=\sin(ty)$ sur l’intervalle $[-3,3]$ en temps et $[-2,2]$ en $y$
plotfield(sin(t*y),[t=-3..3,y=-3..3],plotode=[0,1])
On peut aussi utiliser la commande plotode en-dehors d’une commande plotfield.

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 :

pour les couleurs, on utilise display=couleur, par exemple plot(sin(x),display=red)
Pour changer l’épaisseur des segments (y compris les lignes polygonales utilisées pour tracer une courbe), utiliser display=line_width_2 à display=line_width_8. Pour changer à la fois la couleur et l’épaisseur, additionnez les attributs, par exemple : display=red+line_width_2
Les cercles ainsi que les rectangles dont les bords sont parallèles aux axes peuvent être remplis avec l’attribut display=filled (qui peut s’additionner à d’autres attributs).

6.2 Interface de l’environnement graphique

Lorsqu’on lance une commande graphique depuis le shell, l’application graphique de KhiCAS s’ouvre. Les graphiques s’affichent sur l’écran entier sauf la ligne d’état, donc sur 320 $\times$ 222 pixels, contre 265 $\times$ 165 pixels pour l’application graphique de TI, soit 62% de pixels en plus. Pour les courbes on dispose d’un outil de trace qui est activé par défaut avec visualisation des coordonnées du curseur.

Tapez sur 2nd table pour avoir un tableau de valeurs. Les touches + et - permettent de zommer dans le tableau de valeurs (en divisant ou multipliant le pas par 2). La touche curseur vers la gauche permet de saisir la valeur de début du tableau, la touche curseur vers la droite la valeur du pas. La touche curseur vers le haut ou vers le bas permet de changer la valeur de début du tableau. Attention, si vous maintenez une touche curseur enfoncée trop longtemps, cela peut provoquer un reset de la calculatrice.
En tapant sur la touche trace, vous pouvez faire apparaitre la pente de la tangente ( $m$ ), ainsi qu’un vecteur directeur de la tangente (la vitesse instantannée pour une courbe en paramétrique, de première coordonnée 1 pour une courbe $y=f(x)$ ), un vecteur normal ou le cercle osculateur et le rayon de courbure
En tapant sur la touche zoom, vous pouvez agrandir ou réduire la courbe. Notez que les calculs sont effectués une fois pour toutes, c’est uniquement la fenêtre de visualisation qui change.
Les raccourcis + et - permettent de faire un zoom in ou out, la touche / orthonormalise le repère, la touche * exécute un autoscale (effectué automatiquement au lancement).
Utilisez le curseur vers la droite ou la gauche pour vous déplacer sur la courbe. Lorsque la courbe possède plusieurs composantes (par exemple $y=1/x$ ), on passe de l’une à l’autre avec le curseur vers le haut ou vers le bas.
La touche fenetre permet de modifier la fenêtre graphique en donnant les valeurs de xmin/xmax et ymin/ymax.
La touche f(x) affiche des infos sur la courbe
La touche $x,t,\theta,n$ permet de rechercher des zéros, extremas, aire sous la courbe, longueur d’arc. Pour ces deux dernières commandes, il sera sans doute nécessaire de marquer une position avec l’option 9 ou 10 du menu, puis déplacer le curseur jusqu’à une deuxième position avant d’activer l’option 11 (Aire) ou 12 (Longueur d’arc).

Lorsque la commande plot ou plotparam vient d’être utilisée, les variables x0, x1, x2, y0, y1, y2 contiennent les expressions paramétrique de la position, vitesse et accélération, et peuvent servir à étudier analytiquement dans le shell inflexions, points singuliers, etc. Notez que la commande plotpolar efface ces variables, et stocke uniquement l’affixe du point dans la variable z0.

7 Unités et constantes physiques.

KhiCAS permet de convertir des unités, mais aussi d’effectuer des calculs avec des unités et dispose d’une petite bibliothèque de constantes physiques.

Le menu de constantes physiques (raccourci math puis touche fraction) et unités physiques (raccourci math ^) affiche

des commandes de gestion d’unité
mksa pour convertir vers les unités fondementales du système international
usimplify pour simplifier en utilisant une seule unité lorsque c’est possible, ou un produit de deux.
ufactor pour forcer l’écriture d’une unité en fonction d’une autre
=> (raccourci touche sto) pour convertir entre deux unités compatibles
une liste non exhaustive d’unités physiques. Vous pouvez ajouter un préfixe de multiplication par une puissance de 10.
une liste de constantes physiques fondementales.

Exemples :
60_(km/h) => _(m/s)
mksa(_hbar_)
usimplify(1_W*1_s)
ufactor(1_W,1_J)
Attention, les flottants sont codés en base 2 avec 24 bits de mantisse (avec le compilateur C/C++ pour TI83), soit environ 7 chiffres significatifs, ce qui peut entrainer des erreurs d’arrondi parfois un peu déconcertantes.

8 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 les touches 2nd $\int_.^.$ affiche l’expression dans l’éditeur 2d. En ligne de commande, l’appui sur 2nd $\int_.^.$ 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 2nd echanger (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_{x \rightarrow 0} \frac{\sin(x)}{x}$ Depuis une ligne de commande vide, taper 2nd $\int$ , 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 1, c’est $\sin(x)$ qui est en surbrillance. Tapez sur la touche de division (/, au-dessus de *), vous devez voir $\frac{\sin(x)}{0}$ avec 0 en surbrillance, tapez x puis enter, vous devez voir $\frac{\sin(x)}{x}$ avec x au dénominateur en surbrillance. Tapez sur le curseur flèche vers le haut pour mettre $\frac{\sin(x)}{x}$ en surbrillance, puis fenetre 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 taper sur les touches f(x) 7 (oo) enter.

Exemple 2 : nous allons saisir $\int_0^{+\infty} \frac{1}{x^4+1} \ dx$ Depuis une ligne de commande vide, taper 2nd $\int$ , puis fenetre 3 (integrate), vous devez voir $\int_0^1 0 \ dx$ avec $x$ 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 $\int \frac{1}{x^4+1} \ dx$ Depuis une ligne de commande vide, taper 2nd $\int$ , puis fenetre 3 (integrate), vous devez voir $\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 suppr, vous devez voir $\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 f(x) 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 2nd-curseur droit ou gauche, cela échange l’argument sélectionné avec son frère de droite ou de gauche. Tapez ensuite alpha 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 f(x) 2 enter (factor), puis descendez la sélection sur la somme ou différence de logarithmes, allez dans le menu math 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).

9 Sessions de calculs

9.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 alpha curseur vers le haut ou vers le bas. Pour effacer un niveau, appuyez sur la touche suppr (le niveau est recopié dans le presse-papiers).

Pour modifier un niveau existant, on tape sur la touche curseur vers la droite ou vers la gauche. Taper annul pour annuler les modifications ou enter pour valider.

9.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, 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 >, utiliser F3 pour afficher la table de caractères).

Notez la valeur numérique affichée en titre, il s’agit de la quantité de RAM non fragmentée disponible pour les calculs. Si cette quantité s’approche de 0, il est conseillé de quitter KhiCAS puis de le relancer pour défragmenter cet espace mémoire.

9.3 Sauvegarde et compatibilité

Vous pouvez sauvegarder une session depuis le menu F5. Vous pouvez ouvrir une session depuis ce même menu. Les sessions sont sauvegardées dans des AppVar. Vous pouvez archiver une session en-dehors de KhiCAS depuis 2nd mem. Attention, une session archivée est en lecture seule.

N.B.: vous pouvez sauvegarder le contenu de l’éditeur de script indépendamment de la session, les scripts ont un nom d’AppVar terminant par _ et sont reconnus comme des AppVar Python.

10 Interaction avec le système TI.

Vous pouvez saisir des expressions en mode 2d en-dehors de KhiCAS depuis la touche f(x) de la 83 et les importer ensuite dans KhiCAS en utilisant le nom de variable correspondant en majuscule ou en minuscule (raccourci clavier 2nd puis une touche entre 1 et 9). KhiCAS utilise la variable Y2 pour sauvegarder le résultat des opérations de calcul, vous pouvez quitter KhiCAS à tout moment (2nd quit depuis le shell de KhiCAS) et afficher un résultat en tapant sur la touche f(x). Vous pouvez aussi exporter une expression vers une variable Y1 à Y9 en tapant la commande suivie de la touche sto puis 2nd et une touche entre 1 et 9. Vous pouvez alors en obtenir une représentation graphique avec l’application de TI si vous la préférez à l’application graphique de KhiCAS.

Pour les matrices, vous pouvez entrer une matrice en-dehors de KhiCAS avec l’éditeur de matrice (touche matr de la calculatrice, choisir une matrice et taper 2 fois sur le curseur vers la droite pour editer la matrice). Pour l’importer dans KhiCAS, saisir son nom sous la forme [A] à [I]. Il n’y a pas de commande d’export de matrice, car la TI83 ne gère ni les matrices complexes, ni les matrices symboliques, ni certaines formes exactes.

11 Programmation

L’environnement de programmation de $\chi$ cas est assez complet: un éditeur, l’interpréteur de Xcas avec toutes ses commandes (compatibilité partielle avec les modules Python math, cmath, et un sur-ensemble du module kandinsky/casioplot).

La mise au point du source est facilitée par la possibilité d’interpréter le programme sans quitter l’éditeur en cas d’erreur, et une fois le programme syntaxiquement correct, on peut le mettre au point (corriger les erreurs de “runtime”) en l’exécutant en mode pas à pas. Cet outil d’exécution pas à pas peut également servir à des fins pédagogiques pour illustrer le déroulement du programme et l’évolution du contenu des variables.

Vous pouvez programmer en utilisant la compatibilité de syntaxe Python de Xcas. 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.

11.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 $r$ , on peut taper peri(r):=2*pi*r
(pour taper :, taper F3 puis sélectionner : dans la liste) puis on peut calculer peri(1)
.

Autre exemple, pour calculer l’intervalle de confiance de seconde connaissant une fréquence $p$ et un effectif $n$ , on tape
F(P,N):=[P-1/sqrt(N),P+1/sqrt(N)]

puis on teste F(0.4,30)

Utilisation de l’éditeur
En tapant sur la touche prgm depuis le shell, on entre dans l’éditeur de programme (tapez sur annul pour revenir au shell). Ceci ouvre l’éditeur avec une maquette de fonction def f(x): Remplacez x par n, puis déplacez le curseur en fin de ligne et passez à la ligne (entree). Tapez F2 puis enter (for), placez un j entre for et in range( puis un n entre les parenthèses de range(). À la ligne suivante, tapez F3 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 2nd enter. Si tout va bien, le message Syntaxe OK apparait brièvement 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 F5. Pour l’exécuter, revenez au shell en tapant la touche annul, tapez par exemple f(10), vous devriez voir s’afficher les carrés de 1 à 10.

N.B. : dans l’éditeur de programmes, l’appui sur la touche enter passe à la ligne, tapez 2nd enter pour interpréter le contenu de l’éditeur.

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

def pgcd(a,b):
  while b!=0:
    a,b=b,irem(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))

11.2 Commandes utilisables

Contrairement aux adaptations de MicroPython proposées par certains constructeurs, 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, un petit module de graphiques pixelisé (draw_pixel(x,y,c), 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). 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.

12 Raccourcis claviers.

la touche trig suivi de 1 à 6 doone accès aux fonctions sin, cos, tan, asin, acos, atan
=> suivi d’une fonction permet d’exécuter des actions:
=>* écriture sous forme de produit,
=>+ écriture sous forme de somme (pour une unité, écriture sous forme le plus simple possible),
=>/ écriture sous forme de quotient,
=>sin, =>cos, =>tan conversion vers des sinus, cosinus ou tangentes.
16=>=> écrit les entiers qui suivent en base 16, 10=>=> en base 10, 8=>=> en base 8
la touche 2nd insérer permet de coller le presse-papier
la touch 2nd echanger permet d’annuler la dernière opération d’édition dans l’éditeur de programmes.
la touche au-dessus de la touche $x^2$ permet d’indenter dans l’éditeur de programmes ou d’ouvrir le catalogue à une position dépendant de la ligne de commande dans le shell.
la touche située en-dessous de la touche math renvoie le caractère de tabulation, qui sert à afficher l’index des commandes pour avoir de l’aide (depuis le shell) ou indente dans l’éditeur de programmes.
entree permet de passer à la ligne dans l’éditeur de programmes, 2nd entree interprète le programme.

13 Extinction, reset, horloge.

Comme tout logiciel, $\chi$ CAS n’est pas exempt de bugs. Si un calcul bloque (mais il faut souvent être patient sur la 83 qui est lente), commencez par essayer de l’interrompre en appuyant sur la touche annul. Si cela ne suffit pas, appuyez sur le bouton RESET à l’arrière de la calculatrice.

Lorsque KhiCAS n’arrive plus à allouer de la mémoire, l’application quitte brutalement et revient au shell de l’OS. Vous pouvez rouvrir KhiCAS et réessayer, dans certains cas le calcul fautif pourra se dérouler normalement à partir d’un état réinitialisé de la mémoire (tas mémoire non fragmenté).

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

Si vous voulez éteindre la calculatrice pour une courte durée, vous pouvez utiliser 2nd ON, mais cela ne fait que diminer la consommation électrique (absence de rétroéclairage). Pour une longue période, il vaut mieux quitter $\chi$ CAS en tapant 2nd quit depuis le shell.

Si la mémoire non fragmentée disponible, affiché en tapant sur la touche var, s’approche de 0, vous pouvez quitter $\chi$ CAS (2nd quit) et le relancer (2nd apps 2). Il y a un peu moins de 100K de mémoire non fragmentée disponible lorsqu’on lance $\chi$ CAS.

14 Copyright, licences et remerciements

Giac et $\chi$ CAS, noyau de calcul (c) B. Parisse et R. De Graeve, 2024. Les calculs en entiers sont effectués avec la librairie tommath.
L’interface de $\chi$ CAS a été adaptée par B. Parisse à partir de l’interface utilisateur du code source d’Eigenmath créée par Gabriel Maia et de l’interface utilisateur de Xcas.
License d’utilisation de $\chi$ CAS: GPL2. (voir le détail des conditions dans le fichier LICENSE.GPL2 ou sur la page GPL2 du site de la Free Software Foundation). Le code source est disponible ici sous licence GPL2 (sauf la modification de l’allocateur standard sous licence GPL3 qui est la licence de la toolchain de compilation).

Le programme d’installation INST est (c) B. Parisse, à source non public, il peut être utilisé et diffusé sans restrictions pour toute utilisation non commerciale. Ce programme contient du code sous licence MIT de Matt Waltz.

; Copyright 2015-2021 Matt "MateoConLechuga" Waltz
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
;
; 1. Redistributions of source code must retain the above copyright notice,
;    this list of conditions and the following disclaimer.
;
; 2. Redistributions in binary form must reproduce the above copyright notice,
;    this list of conditions and the following disclaimer in the documentation
;    and/or other materials provided with the distribution.
;
; 3. Neither the name of the copyright holder nor the names of its contributors
;    may be used to endorse or promote products derived from this software
;    without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
; POSSIBILITY OF SUCH DAMAGE.

Le document Cabri artifice est (c) YvanTT, site web.
Remerciements à la communauté ti83/84 et aux outils mis à disposition: compilateur C/C++, émulateur, en particulier à Adrien Bertrand (qui a répondu avec patience aux nombreuses questions que je lui ai posées pendant le développement sur la toolchain et l’émulateur), Jacob Young, commandblockguy, Matt Waltz, YvanTT.
Remerciement à l’équipe de tiplanet, en particulier à Xavier Andréani pour le forum de discussion et tout le travail de mise en valeur de $\chi$ cas (stockages d’archives, articles, concours), ainsi que sa disponibilité pour m’aider à débloquer ma calculatrice.

15 Compiler sa propre version de KhiCAS

Pour pouvoir compiler du code natif sur TI83, il faut installer la toolchain de compilation CE, dont voici la documentation. Installez aussi le code source de KhiCAS.

Pour pouvoir bénéficier de plus de mémoire, j’ai modifié la toolchain, de sorte que malloc puisse utiliser la partie supérieure de la RAM LCD et que malloc arrête l’exécution du programme s’il ne peut allouer de mémoire (car Giac ne gère pas le retour d’un pointeur nul).

Cette archive contient l’ensemble des modifications que j’ai faites, à désarchiver dans le source de la toolchain, dans toolchain/src/libc/. Il faut au préalable installer le source de la toolchain. Et il faut ensuite recompiler la toolchain et réinstaller pour que la modification soit effective. Cf. la documentation.

Ensuite, vous pouvez utiliser, après adaptation, l’un des shell scripts mkapp* pour générer l’application en français pour le lycée (mkappfr) ou le supérieur (mkappl2) ou en anglais (mkappen).

Ces shell scripts s’occupent de supprimer les relocations de l’application pour gagner entre 25 et 30% de place en utilisant le programme dont le source est reloc.cc. Cela suppose que l’application est installée en premier (en général, c’est la seule application installée vu la place disponible).

Vous pouvez modifier les composants installés dans KhiCAS en jouant sur les flags de compilation -DWITH_ dans makefile.fr ou makefile.en ou makefile.l2. Par exemple le support des unités physique est inclus par -DWITH_UNITS et occupe environ 40K. Notez que la taille de l’application varie par pages de 64K (une page partiellement occupée est considérée comme utilisée en entier).

Si vous voulez adapter l’interface (shell et éditeur de programmation), comme le temps de compilation de KhiCAS est assez long (6 minutes environ), il vaut mieux travailler avec un clone du shell sans KhiCAS et tester avec l’émulateur. Ce clone se compile avec mkapp en 15 secondes environ, au lieu de 6 minutes.

16 Le mot de la fin

Au printemps 2020, le buzz déclenché par une vidéo malheureuse sur une faille du mode examen sur les 83 a failli tuer le développement de programmes par des tiers sur la plateforme ti83/84, le lecteur intéressé pourra consulter cet article de tiplanet pour en savoir un peu plus. À la même époque, Numworks fermait le développment de son système d’exploitation et rendait l’utilisation d’applications externes très dissuasive. En 2023, Casio décidait de ne pas laisser s’exécuter des applications externes sur son modèle de calculatrices Graph Math+, successeur de la 90. C’est d’ailleurs la raison principale qui m’a poussé à porter KhiCAS sur les ti83 malgré la difficulté technique, puisque KhiCAS pour Casio Graph 90 ne peut pas être porté sur les Math+, la ti83 est mon dernier espoir de démocratiser le calcul formel en France.

La raison invoquée pour empêcher les programmes tiers est toujours la même, la sécurité, et les constructeurs s’assoient sur le travail de la communauté au motif qu’il s’agirait de développements qui risquent de détourner l’attention des élèves de l’apprentissage. Mais qu’en est-il en réalité ? Le mode examen a été introduit parce que certains examens veulent interdire les documents et certaines fonctionnalités, alors qu’on pourrait très bien interdire ou autoriser les calculatrices graphiques selon les épreuves. Les constructeurs ne sont pas à l’origine de la mesure, mais ils en ont tiré parti, cela permet à ceux qui ont plusieurs modèles de calculatrices de segmenter le marché, et de faire payer au prix fort certaines fonctionnalités qui auparavant pouvaient être rajoutées sur les modèles moins onéreux par des programmes développés par des tiers. Il est étonnant qu’en France dont la devise contient pourtant le mot égalité, qui est un principe cité à l’article premier de la constitution, si peu de gens remettent en cause le principe du mode examen qui est très inégalitaire.

Il va être très intéressant de suivre ce que sera l’avenir de ce portage de Xcas sur les TI83. Le constructeur va-t-il accepter une application de calcul formel sur ce modèle milieu de gamme alors que son propre modèle CAS coute environ deux fois plus et signer KhiCAS ce qui permettrait de l’installer comme une application de TI et de l’utiliser en mode examen ? Si la réponse est positive, les autres constructeurs seront certainement amenés à reconsidérer leur position actuelle et le calcul formel pourrait devenir accessible à la majorité des lycéens et non réservé à un très petit pourcentage d’élèves pouvant se payer une TI Nspire CX2 CAS ou une HP Prime en en comprenant l’intérêt.

Si la réponse est négative, le calcul formel risque de rester définitivement réservé aux élèves issus de milieux socio-économiques favorisés. C’est un problème qui a pourtant été signalé il y a longtemps. Voici un court extrait de ce qu’on pouvait lire dans le numéro 15 (avril-mai 1999) de la revue Hypothèses, éditée par TI (scan publié avec l’aimable autorisation de TI France), je cite (page 7)
La question de l’équité
Le problème d’une aggravation des inégalités sociales provoquées par l’arrivée de ces nouvelles calculatrices est soulevé par de nombreux enseignants ... Une calculatrice symbolique performante permet à un élève ne disposant d’aucune aide particulière (parents, cours particuliers...) de vérifier sans difficulté la validité de tous les calculs techniques. Il est même parfaitement envisageable de pouvoir faire tourner sur cette calculatrice des logiciels permettant d’aider un élève en difficulté à trouver une méthode correcte, par exemple lors de la résolution d’une équation ou d’un calcul de primitives. À terme, l’introduction des outils de calcul symboliques pourrait donc permettre d’atténuer certaines inégalités... Cela dit, il reste vrai qu’il faut trouver des solutions permettant de rendre possible l’accès de ces calculatrices à un plus grand nombre d’élèves. C’est un problème d’égalité des chances, et c’est comme nous l’avons vu un impératif pédagogique si l’on souhaite pouvoir utiliser largement une calculatrice dans le cadre de l’enseignement des mathématiques.

Ce document est 25 ans après toujours d’actualité. En fait, j’ai le sentiment que l’aspect utilisation intelligente de la calculatrice pour faire des maths, dont l’utilisation du calcul formel, a beaucoup reculé en France en 20-25 ans. Anedocte allant en ce sens : j’ai demandé en 2023/24 à une partie des étudiants inscrits en master 1ère année de maths dans mon université combien parmi eux avait déjà utilisé un logiciel de calcul formel, la réponse fut : 0 (!). Cette année 2024/25, sur l’ensemble de la promotion, moins de 1 sur 5.

Au début des années 2000, pour utilisation à l’oral du CAPES de mathématiques, une calculatrice graphique devait avoir un module CAS, un module de géométrie et un tableur, et les constructeurs prêtaient aux candidats leur calculatrice la plus évoluée (TI Voyage 200, Casio Classpad, HP49G). Aujourd’hui, les calculatrices ont disparu de l’oral du capes, sauf les Numworks, qui ne propose d’origine aucune de ces trois fonctionnalités (l’absence des autres constructeurs est d’ailleurs en complète contradiction avec la neutralité que devrait appliquer le service public).
Sur les 5 logiciels proposés à l’oral 2024, on a un seul logiciel de mathématiques (Geogebra), 2 logiciels de programmation (Python et Scratch), une seule calculatrice (l’émulateur de Numworks), et un logiciel de bureautique (LibreOffice).
On peut légitimement s’inquiéter de la place relative des maths à l’oral du capes de maths dans l’utilisation de la technologie.
Il y a 20-25 ans, les construteurs travaillaient à améliorer les capacités mathématiques de leurs calculatrices et les revues qu’ils éditaient mettaient l’accent sur les mathématiques (Hypothèses chez TI, Poincaré chez HP...).
Aujourd’hui, on a plutot l’impression que le temps de développement est consacré à consolider les restrictions d’utilisation en examen ou à rendre l’utilisation uniquement presse-bouton et les constructeurs mettent plus en avant la programmation en Python (qui semble pourtant fort peu utilisée, en tout cas sur calculatrices, à part par quelques enseignants) que les fonctionnalités mathématiques.
Bien sur, une interface intuitive et ergonomique c’est un plus, mais à condition de ne pas empêcher le développement de l’autonomie des élèves dans l’utilisation de la technologie et de ne pas freiner la curiosité des bons élèves en restreignant les fonctionnalités.

Enfin, si le constructeur décide d’appliquer des restrictions pour empêcher KhiCAS de fonctionner sur les ti83/84, il risque d’empêcher la programmation native sur cette plateforme, il ne resterait alors plus aucun espace pour les très bon jeunes développeurs sur calculatrices, alors que certains découvrent leur talent en développant sur calculatrices. L’age d’or commencé avec les HP48 dans les années 90, puis sur la plateforme TI83/84 ou Nspire (ndless) et les Casio graphique couleur serait alors définitivement révolu.

Situation au 15 novembre 2024 : on va vers une certaine neutralité du constructeur, officieusement bienveillante. TI ne signerait pas officiellement l’application KhiCAS, raison invoquée cela prendrait trop de ressources pour le tester. Mais TI ne s’y opposerait pas, sous réserve que le développement d’une solution de mise en examen compatible avec KhiCAS ne fonctionne pas avec la dernière version de l’OS. Donc ne faites surtout pas de mise à jour vers la version 5.8.2 sortie ce 15 novembre.

χ\chiCAS pour TI83CE et 83CE Python edition