$\chi$ CAS(io)

Bernard.Parisse@ujf-grenoble.fr

2018

Table des matières

Résumé: Ce document explique comment prendre en main et utiliser efficacement sur calculatrices Casio Graph 90+e le système de calcul formel $\chi$ CAS, une version adaptée du logiciel Xcas pour cette calculatrice.
Ce document est interactif, vous pouvez modifier les commande et voir le résultat de l’exécution des commandes proposées en exemple en cliquant sur le bouton ok (ou en validant avec la touche Entrée).

1 Installation

Pour installer ou mettre à jour $\chi$ CAS, récupérez sur votre ordinateur le fichier khicas.g3a

Branchez le cable USB de la calculatrice, tapez F1 pour que la calculatrice soit considérée comme une clef USB et copiez le fichier khicas.g3a sur la “clef”-calculatrice puis suivre la manipulation de votre ordinateur qui permet de débrancher une clef USB en toute sécurité. Le transfert s’effectue en quelques secondes.

Si vous testez sur l’émulateur (PC, Mac), depuis le menu principal de la calculatrice (MENU), allez à Mémoire, puis F3 (Import/Export), puis F1 (Import files), puis sélectionnez le fichier à transférez depuis le disque dur de votre ordinateur, tapez F1 pour sauvegarder sur la racine de la calculatrice, confirmez par F1 si vous effectuez une mise à jour. Le transfert est relativement long (plusieurs minutes) sur l’émulateur.

Une fois le transfert terminé, une nouvelle icone (avec le flocon de Xcas) apparait dans le menu principal.

2 Premiers pas

Depuis le menu principal, déplacez le curseur jusqu’à l’icone de Xcas, puis tapez EXE. Ceci ouvre un “shell” dans lequel vous pouvez taper la plupart des commandes de calcul formel de Xcas.

Par exemple, tapez 1/2+1/6 puis EXE, 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 EXE, puis vous pouvez modifier la commande et l’exécuter. Par exemple, taper sur la touche curseur vers le haut, EXE et remplacez 1/6 par 1/3.

Vous pouvez utiliser le résultat de la dernière commande avec la touche Ans de la calculatrice (taper sur shift puis (-)). 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 :

l’affectation vers la droite => s’obtient avec la touche $\rightarrow$ de la calculatrice, 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 := s’obtient en tapant sur F1 lorsque la syntaxe Xcas est active (en syntaxe Python, l’affectation se fait avec =, pour passer d’un mode à l’autre il faut taper F6 puis 7. Python). Par exemple A:=2 fait la même chose que 2=>A.

Si vous commencez une ligne de commande en tapant la touche $\rightarrow$ , le système insére automatiquement Ans=> ce qui permet facilement de donner un nom au résultat d’une commande.

Pour vous aider à saisir les commandes Xcas les plus utiles, $\chi$ CAS 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 F4 (CATALOG), choisissez une catégorie avec le curseur, par exemple Algebre, tapez EXE, puis choisissez une commande avec le curseur, par exemple factor. La touche F6 vous affiche une courte description de la commande, en général avec un exemple. En tapant sur F2, vous recopiez l’exemple en ligne de commande. Vous pouvez alors valider (EXE) ou modifier la commande et valider (EXE) 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 EXIT pour revenir au shell.

Maintenant essayez de taper la commande plot(sin(x)). Indication: taper F4 (CATALOG), puis sélectionner Graphiques.

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, utiliser la touche (-) pour faire un zoom out partiel selon l’axe $Oy$ ), 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 ou OPTN. Tapez sur EXIT pour revenir au shell.

Vous pouvez effacer l’historique des calculs et les variables pour commencer un nouvel exercice : depuis le menu Fich,Cfg (F6) sélectionnez 5 Clear. L’écran est effacé et le message /* DEL EXE to */ restart? apparait. Tapez ON pour effacer l’écran en conservant les variables, tapez DEL puis EXE pour effacer les variables.

Pour quitter $\chi$ CAS, appuyez sur la touche MENU. Lorsque vous lancez une autre application, les variables et l’historique des calculs sont sauvegardés, ils seront restaurés lorsque vous reviendrez dans $\chi$ CAS (sauf si vous désactivez la sauvegarde depuis le menu Fich,Cfg (F6 9)). La première sauvegarde peut prendre du temps sur l’émulateur (une dizaine de secondes), ensuite les sauvegardes sont plus rapides. De manière plus générale, la calculatrice exécute les calculs plus rapidement que l’émulateur (parfois 3 ou 4 fois plus vite).

Il est conseillé d’appuyer sur MENU avant d’éteindre la calculatrice, sinon lorsqu’on rallume la calculatrice, il arrive qu’une commande saisie précédamment s’ajoute, dans ce cas taper sur AC/ON pour vider la ligne de commande.

3 Commandes usuelles de calcul formel

3.1 Développer et factoriser

Depuis le catalogue, sélectionner le sous-menu Algebre

factor : factorisation. Raccourci clavier =>* (touche $\rightarrow$ 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 $\rightarrow$ 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)=>/
ratnormal : développer une expression, écrire une fraction sous forme irréductible.

3.2 Analyse

Depuis le catalogue, sélectionner le sous-menu Analyse

diff : dérivation. On peut aussi utiliser la notation ' (raccourci clavier F3) 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)

Raccourci clavier shift F3.
limit : limite d’une expression. Exemple
limit((cos(x)-1)/x^2,x=0)
tabvar : tableau de variations d’une expression. Par exemple
tabvar(x^3-7x+5)
on peut vérifier avec le graphe plot(x^3-7x+5,x,-4,4)
taylor et 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.
Raccourci clavier ALPHA F3.

3.3 Résoudre

Depuis le catalogue, sélectionner le sous-menu Resoudre.

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)
.
solve permet aussi de résoudre des systèmes polynomiaux simples, on donne en 1er argument la liste des équations, en 2ème argument la liste des variables. Par exemple intersection d’un cercle et d’une droite
solve([x^2+y^2+2y=3,x+y=1],[x,y])
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).
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) Utiliser odesolve pour une résolution approchée et plotode pour une représentation graphique de solution calculée de manière approchée.
rsolve permet de résoudre de manière exacte certaines relations de récurrences $u_{n+1}=f(u_n,...)$ , par exemple les suites arithmético-géométriques, par exemple $u_{n+1}=2u_n+3, u_0=1$
rsolve(u(n+1)=2*u(n)+3,u(n),u(0)=1)

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

3.4.1 Entiers

Depuis le catalogue, sélectionner le sous-menu Arithmetic, Crypto

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 (les algorithmes utilisés se limitent à la division et Pollard- $\rho$ , il n’y avait pas de place pour le crible quadratique). 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.

3.4.2 Polynômes

Depuis le catalogue, sélectionner le sous-menu Polynomes. 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)
Représentation graphique :
point(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)=>+
Représentation graphique
scatterplot(X,Y); plot(P,x,-1,4)
resultant(P,Q) : résultant des polynômes $P$ et $Q$ P:=x^3+7x-5; Q:=x^2+x; resultant(P,Q)
hermite(x,n) : n-ième polynôme de Hermite, orthogonal pour la densité $e^{-x^2}dx$ sur $\R$
laguerre(x,n,a) : n-ième polynôme de Laguerre,
legendre(x,n) : n-ième polynôme de Legendre, orthogonal pour la densité $dx$ sur $[-1,1]$
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)$

3.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, taper sur shift-MATR ou F6 4 (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=\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,loi,[parametres]) renvoie une matrice à coefficients aléatoires de taille $n,m$ . Par exemple
U:=ranm(4,4,uniformd,0,1)

N:=ranm(4,4,normald,0,1)

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 Alglin, Matrices

eigenvals(A)

eigenvects(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)$ ).
qr calcule la décomposition $QR$ d’une matrice $A$ et renvoie deux matrices $Q$ orthogonale et $R$ triangulaire supérieure telles que $A=QR$ .
svd(A) calcule la factorisation en valeurs singulières d’une matrice $A$ , et renvoie $U$ orthogonale, $S$ vecteur des valeurs singulières, $Q$ orthogonale tels que A=U*diag(S)*tran(Q). Le rapport de la plus grande valeur singulière de $S$ sur la plus petite donne le nombre de condition de $A$ relativement à la norme euclidienne, plus ce nombre est grand, plus on perd en précision en résolvant un système $Ax=b$ lorsque $b$ n’est pas connu exactement.

4 Probabilités et statistiques

4.1 Tirages aléatoires

Depuis le catalogue, sélectionner le sous-menu Probabilites puis sélectionnez rand()
(réel selon la loi uniforme dans $[0,1]$ ) ou n:=6:; randint(n)
(entier entre 1 et $n$ ). 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,p$ . Pour créer un vecteur ou une matrice aléatoire, utiliser la commande ranv ou ranm (menu Alglin, Matrice), par exemple pour un vecteur de 10 composantes selon la loi normale centrée réduite
ranv(10,normald,0,1)

4.2 Lois de probabilités

Depuis le catalogue, sélectionner le sous-menu Probabilites (8). 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 hors catalogue : 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é $I$ pour la loi normale de moyenne 5000 et d’écart-type 200 tel que la probabilité d’être en-dehors de $I$ soit de 5% : M:=5000; S:=200; normald_icdf(M,S,0.025);normald_icdf(M,S,0.975)

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

mean(l)
: moyenne arithmétique d’une liste
stddev(l)
: écart-type d’une liste
Utiliser stddevp(l)
pour avoir un estimateur non biaisé de l’écart-type d’une population dont l est un échantillon
median(l)
, quartile1(l)
, quartile3(l)
renvoient respectivement la médiane, le 1er et 3ème quartiles d’une liste

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 Graphique histogram et barplot.

4.4 Statistiques descriptives 2-d

Depuis le catalogue, sélectionner le sous-menu Statistiques.

correlation(X,Y) calcule la corrélation entre 2 listes de même taille.
covariance(X,Y) calcule la covariance entre 2 listes de même taille.
les commandes de suffixe _regression(X,Y) calculent des ajustements par régression au sens des moindres carrés, par exemple linear_regression(X,Y) renvoie les coefficients $m,p$ de la droite de régression linéaire $y=mx+p$ .
linear_regression_plot(X,Y) (respectivement toutes les commandes de suffixe _regression_plot) trace une droite (respectivement une courbe) d’ajustement des données contenues dans les listes X,Y de même taille. Ces commandes affichent de plus le coefficient $R^2$ qui permet de quantifier la qualité de l’ajustement (plus $R^2$ est proche de 1, meilleur est l’ajustement).

5 Graphes

Depuis le catalogue, sélectionner le sous-menu Graphiques (accès rapide par la touche 7).

plot(f(x),x=a..b) 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)
plotcontour(f(x,y),[x=xmin..xmax,y=ymin..ymax],[l0,l1,...]) trace les courbes de niveaux $f(x,y)=l_0, f(x,y)=l_1, ...$ .
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 ;

La touche OPTN vous permet de spécifier certaines options graphiques :

Pour modifier les couleurs des graphes, utiliser la touche OPTN et sélectionnez une couleur puis tapez F2 pour insérer 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).
Pour remplacer la fenêtre graphique calculée automatiquement par des valeurs prédéfinies, utiliser la touche OPTN, sélectionner gl_x ou/et gl_y et indiquer l’intervalle en $x$ ou en $y$ souhaité, la commande doit précder une commande de tracé. Par exemple gl_x=-2..2;gl_y=-1..4;plot(exp(x))
Pour enlever les axes, sélectionner axes puis taper F2 (axes=0). La commande doit précéder une commande de tracé.

6 Programmation

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.

6.1 Utilisation en exemples

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

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 F6, ou par le raccourci shift-QUIT. Saisir la commande avance dans ce menu puis valider, vous devez voir la tortue (symbolisée par un triangle) avancer de 10 pixels. Taper EXIT 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.
Tapez shift-PRGM, puis sélectionnez l’exemple de pour
pour j de 1 jusque 10 faire print(j,j^2); fpour;
tapez sur EXE, 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 à $n$ en utilisant la syntaxe compatible Python et l’éditeur de programmes. Vérifiez que la syntaxe Python est cochée (F6), sinon cochez-la (7). Tapez F6 (Fich,Cfg) puis nouveau programme, puis tapez F5 pour bloquer en mode alphabétique minuscules, puis par exemple test puis EXE. Ceci crée un fichier test.py et 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 (EXE). Tapez Shift-PRGM puis 3 for, puis F5 J espace alpha, puis Shift-PRGM puis 6 in range(a,b) puis tapez 1,n+1) puis F1 pour :, puis EXE pour passer à la ligne, puis Alpha SPACE, F4 (CATALOG), EXE (1 Tout), P, déplacez la surbrillance avec le curseur vers le bas sur print et validez (EXE), puis tapez j,j^2). Vous devriez avoir le programme suivant :

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

N.B.: pour la puissance, on peut utiliser ^ ou ** dans KhiCAS (il faut utiliser ** en Python).

Maintenant, tapez F6 (Fich,Cfg) et sélectionnez 1. Tester syntaxe. 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 F6 (Fich,Cfg). Pour l’exécuter, revenez à la ligne de commande en tapant la touche EXIT, tapez par exemple f(10), vous devriez voir s’afficher les carrés de 1 à 10.

3ième exemple : Calcul de l’intervalle de confiance de terminale S
On peut le saisir en ligne de commande F(P,N):=[P-1.96*sqrt(P*(1-P)/N),P+1.96*sqrt(P*(1-P)/N)]
On peut éviter les calculs redondants en utilisant une variable locale (utiliser shift-PRGM 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 $n$ pixels, en utilisant une fonction d’argument $n$ et l’instruction repete.

Solution Faire F6, Nouveau programme, choisir Tortue ce qui crée un script contenant l’instruction efface. Ajouter 4 fois avance; tourne_gauche;. Appuyer sur F6 puis EXE (ou directement sur la touche ON) pour tester. Quitter avec EXIT (et sauvegardez avec F1).

Refaire F6, nouveau programme, Tortue. 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 F6 1 Tester syntaxe.

Un exemple de fonction non algébrique : le calcul du PGCD de 2 entiers.
Utiliser shift-EXE pour passer à la ligne. Le caractère ! est accessible depuis le menu Programmation_cmds (11, raccourci $X,\theta,t$ ). En syntaxe Xcas

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

Le même en syntaxe Python

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

On vérifie pgcd(12345,3425)

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

6.2 Quelques exemples

Le répertoire prog de l’archive khicasio.zip contient quelques exemples de TP pour classes de seconde de l’IREM de Grenoble :

utilisation de la tortue pour introduire la programmation textuelle et la notion de fonction (PDF+corrections fichiers py)
longueur approchée d’un arc de courbe (PDF+correction fichier py)
tableau de valeurs, recherche de minimum (enonce et morceaux de programmes, fichier tabval.py)

ainsi que quelques autres programmes (avec fréquemment une représentation graphique) :

fréquence dans un échantillon, intervalle de fluctuations (freq.py)
le paradoxe du duc de Toscane (toscane.py)
résolution d’équation du second degré (deg2.py)
dichotomie (dicho.py)
méthode des rectangles (integr.py),
fractale de Mandelbrot (mandel.py)
un benchmark utilisé par tiplanet pour mesurer la vitesse de l’interpréteur (qcc.py)

6.3 Commandes utilisables

Contrairement aux adaptations de MicroPython proposées par les constructeurs (dont celui de la Casio Graph 90+e), 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 $\chi$ CAS (point, line, segment, circle, barplot, histogram et les commandes plot...). De plus, vous pouvez travailler avec des expressions et faire du calcul formel dessus. La liste complète des commandes portées se trouve en annexe, pour une présentation détaillée, on renvoie à la documentation de Xcas.

7 Raccourcis claviers.

F1 à F3 : selon le mode (Xcas ou Python) et les modes shift/alpha, voir les légendes
F4: catalogue.
F5: passage majuscules minusucules. Si le mode alphabétique n’est pas actif, bloque le clavier en mode alpha minuscule.
F6: menu Fichier et configuration.
(-): renvoie le caractère _.
shift PRGM: commandes de programmation
OPTN: toutes les options
shift-QUIT: commandes tortues
shift-List: commandes et édition de listes
shift-Mat: commandes et édition de matrices
touche angle: polar_complex
touche fraction: solve (mode Xcas) ou \ (mode Python)
touche fraction shiftée (jaune): limit
touche r rouge: abs
touche $\theta$ rouge: arg
touche S $\leftrightarrow$ D: approx
touche S $\leftrightarrow$ D shiftée (jaune): exact
Shift-INS (touche DEL): inf ( $+\infty$ )

Dans l’éditeur de programmes :

touches curseur shiftées: déplacement en début/fin de ligne/fichier.
shift CLIP: sélection. Déplacer le curseur à l’autre extrémité puis taper sur DEL pour effacer la sélection et la copier dans le presse-papier ou à nouveau sur shift CLIP pour copier la sélection sans l’effacer. Taper sur AC/ON pour annuler.
EXE: si une recherche/remplacement de mot est active (après avoir fait F6 6), recherche l’occurence suivante d’un mot. Sinon, passe à la ligne.
shift EXE: passe à la ligne
DEL efface le caractère précédent ou la sélection.
shift PASTE: copie le presse-papier
AC/ON: annule la sélection ou annule la recherche, sinon efface la ligne courante et la copie dans le presse-papier
VARS: bascule entre l’éditeur et la figure tortue
EXIT: quitte l’éditeur et revient en ligne de commandes. On peut revenir ensuite à l’éditeur en tapant à nouveau EXIT.

8 Remarques

Cette adaptation n’est pas une version complète de Xcas, la taille maximale d’un add-in Casio (actuellement de 2 Mo) ne permet malheureusement pas de tout proposer ni de donner une documentation complète. Il existe des adaptations de Xcas plus complètes sur des calculatrices d’autres constructeurs, mais uniquement sur des modèles de haut de gamme pour le moment. On renvoie à la page home de Giac/Xcas pour plus de détails.

9 Copyright et Remerciements

Giac et $\chi$ CAS, noyau de calcul (c) B. Parisse et R. De Graeve, 2018.
Interface de $\chi$ CAS 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 de l’archive khicasio.zip ou sur la page GPL2 du site de la Free Software Foundation. Le code source de $\chi$ CAS ainsi que des librairies libtommath et USTL, se trouvent sur la section Casio de ma page web (cf. la section 10)
Remerciements à tous les membres actifs de tiplanet et de Planète Casio pour l’aide qu’ils m’ont apportés en répondant à mes questions ou/et en testant $\chi$ CAS. Remerciements à tous les contributeurs du Prizm programming portal. Remerciements à Pavel Demin pour les astuces de compilation ayant permis d’économiser 135K environ.
Remerciement à Casio France pour le prêt d’une calculatrice et une licence d’utilisation de l’émulateur.

10 À propos du développement.

Pour développer cet add-in, j’ai installé le cross-compiler gcc pour processeur sh3eb, en m’inspirant de ce tutoriel. On télécharge gcc puis (remplacer la version de gcc par la version téléchargée)
../gcc-5.3.0/configure --target=sh3eb-elf --prefix="$HOME/opt/sh3eb-elf" --disable-nls --disable-shared --disable-multilib --enable-languages=c,c++ --without-headers
Malheureusement, il n’y a pas de support pour sh3eb dans la newlib (librairie C) fournie avec gcc, encore moins pour la libstdc++.

J’ai donc installé libfxcg.tar.gz, quelque peu modifiée par mes soins (corrections de plusieurs petits bugs dans la librairie C, ajout de fonctions manquantes comme qsort, ...), à récupérer dans ce répertoire (désarchiver et compiler avec make). Toujours dans ce répertoire, on trouve tommath.tgz (gestion des entiers multi-précision) et ustl.tar.gz (implémentation de la standard template library) que j’ai du pas mal modifier pour le faire fonctionner avec sh3eb-elf-g++, avec un résultat partiel qui est suffisant pour porter Giac (support de vector/string/map mais pas des flux E/S fichiers, j’ai créé à part un fichier iostream pour avoir un ersatz de cin/cout). Tout ceci se désarchive et compile avec make.

Une version compilée pour GNU/Linux debian 9 de gcc pour sh3eb ainsi que des librairies additionnelles se trouvent dans mon répertoire Casio (fichier sh3eb-elf.tar.gz).

Enfin, le port de Giac se trouve dans le fichier khicas.tgz. Le script servant à compiler est mkxcas. Comme il n’y a pas de support du compilateur pour la newlib et la libstdc++, ce portage de Giac se caractérise par l’absence de variables statiques classes, il n’y a que des variables statiques C. La très grande majorité des variables globales (tous les noms de commandes Xcas par exemple) sont déclarées via des alias sur des structures C en constantes pour ne pas occuper de place en mémoire vive. Il a fallu tenir compte de l’endianness du CPU par rapport à d’autres portages de Giac (plus précisément le CPU peut se comporter des deux manières little ou big endian mais on est obligé de choisir le même ordre que celui de l’OS Casio, et c’est l’inverse de celui qu’on rencontre sur les architectures Intel).

A Liste des commandes

Vous pouvez tester une commande dans la ligne de commande située en bas de ce document. Pour avoir de l’aide sur une commande, cliquez sur le bouton + pour augmenter la taille de la console du document, puis tapez ? suivi par le nom de commande.

a2q
abcuv
about
abs
acos
acos2asin
acos2atan
acosh
acot
acsc
add
add_autosimplify
additionally
adjoint_matrix
alg
algsubs
algvar
alog10
and
ans
append
apply
approx
arclen
arg
array_sto
asc
asec
asin
asin2acos
asin2atan
asinh
assert
assume
atan
atan2
atan2acos
atan2asin
atanh
atrig2ln
augment
autosimplify
barplot
basis
bernoulli
betad
betad_cdf
betad_icdf
bin
binomial
binomial_cdf
binomial_icdf
blockmatrix
border
bounded_function
break
breakpoint
canonical_form
cas_setup
cat
cauchyd
cauchyd_cdf
cauchyd_icdf
ceil
ceiling
cfactor
cfsolve
changebase
char
charpoly
chinrem
chisquared
chisquared_cdf
chisquared_icdf
choice
cholesky
chr
chrem
circle
clear
clearscreen
click
coeff
coeffs
col
coldim
collect
colnorm
color
comDenom
comb
combine
comment
companion
compare
complex
concat
{
conj
cont
contains
content
convert
coordinates
copy
correlation
cos
cos2sintan
cosh
count
count_eq
count_inf
count_sup
covariance
cpartfrac
cross
crossproduct
csolve
curl
curve
cyclotomic
cylinder
czeros
debug
debug_infolevel
decrement
degree
del
delcols
delrows
denom
deriver
desolve
det
dfc
dfc2f
diag
diff
dim
display
div
divcrement
divergence
divis
divisors
divmod
divpc
domain
dot
draw_circle
draw_line
draw_rectangle
draw_string
dtype
e2r
egcd
egv
egvl
eigenvals
eigenvalues
eigenvectors
eigenvects
eliminate
epsilon2zero
equal2diff
equal2list
equation
erf
erfc
erfs
euler
euler_mac_laurin
eval
eval_level
evalb
evalc
evalf
evalm
even
exact
execute
exp
exp2pow
exp2trig
expexpand
expln2trig
exponential_regression
exponential_regression_plot
exponentiald
exponentiald_cdf
exponentiald_icdf
expr
extend
f2nd
fMax
fMin
factor
factor_xn
factorial
factors
fclose
fcoeff
fft
fft_mult_size
filter
find
findhelp
fisher
fisher_cdf
fisher_icdf
fisherd
fisherd_cdf
fisherd_icdf
flatten
flatten1
float
float2rational
floor
fopen
format
fourier_an
fourier_bn
fourier_cn
fprint
frac
fracmod
frobenius_norm
froot
fsolve
function_diff
fxnd
galoisconj
gammad
gammad_cdf
gammad_icdf
gauss
gaussquad
gbasis
gcd
genpoly
geometric
geometric_cdf
geometric_icdf
getDenom
getKey
getNum
goto
grad
gramschmidt
greduce
hadamard
halftan
halftan_hyp2exp
halt
has
heapify
heappop
heappush
help
hermite
hessenberg
hessian
hex
hilbert
histogram
hold
horner
hyp2exp
iabcuv
ibasis
ibpdv
ibpu
ichinrem
ichrem
icontent
id
idivis
idn
iegcd
ifactor
ifactors
ifft
igamma_exp
igcd
ilaplace
im
imag
image
in_ideal
increment
indets
index
inferieur_strict_sort
input
insert
int
integer_format
integrate
interp
inv
inverse
invlaplace
iquo
iquorem
iquosto
iratrecon
irem
iremsto
is_prime
is_pseudoprime
isfinite
isinf
isnan
isprime
ithprime
jacobi_symbol
join
jordan
ker
kernel
kill
l1norm
l2norm
label
lagrange
laguerre
laplace
laplacian
lcm
lcoeff
ldegree
left
legend
legendre
legendre_symbol
len
length
lgcd
lhs
limit
limite
lin
line
linear_regression
linear_regression_plot
linetan
linfnorm
linsolve
linspace
list2mat
lll
ln
lname
lncollect
lnexpand
log10
logarithmic_regression
logarithmic_regression_plot
logb
lower
lu
lvar
makelist
makemat
makemod
makesuite
makevector
map
mat2list
matpow
matrix
matrix_norm
max
max_algext
maxnorm
mean
member
mid
min
mods
moyal
mult_c_conjugate
mult_conjugate
multcrement
multinomial
multiply
ncols
negbinomial
negbinomial_cdf
negbinomial_icdf
newton
nextprime
nop
nops
norm
normal
normald
normald_cdf
normald_icdf
normalize
nprimes
nrows
numer
oct
odd
odesolve
op
or
ord
order_size
ou
part
partfrac
pcar
pcoeff
periodic
peval
piecewise
plot
plotfield
plotfunc
plotlist
plotode
plotparam
plotpolar
plotseq
pmin
point
poisson
poisson_cdf
poisson_icdf
polar2rectangular
poly2symb
polygamma
polygon
polygonplot
polygonscatterplot
polynomial_regression
polynomial_regression_plot
pop
potential
pow2exp
power_regression
power_regression_plot
powermod
powexpand
powmod
prepend
preval
prevprime
primpart
print
printf
printpow
product
prog_eval_level
proot
propfrac
ptayl
python
python_compat
python_list
q2a
qr
quo
quorem
quote
r2e
rand
randbinomial
randchisquare
randchisquared
randexp
randfisherd
randgeometric
randint
randmatrix
randmultinomial
randnormald
random
randpoisson
randpoly
randrange
randstudentd
randvector
range
rank
ranm
ranv
rassembler_trigo
rat_jordan
ratnormal
re
read
real
realproot
rectangular2polar
rectangular2spherical
regroup
rem
remove
reorder
resultant
reverse
reverse_rsolve
reverse
revlist
rhs
right
rm_a_z
rm_all_vars
rmbreakpoint
rmwatch
rootof
roots
rotate
round
row
rowdim
rownorm
rpn
rref
rsolve
sample
scatterplot
sec
segment
select
semi_augment
seq
series
set_pixel
shift
shift_phase
shuffle
sign
simp2
simplify
sin
sin2costan
sincos
sinh
size
sizes
smod
snedecord
snedecord_cdf
snedecord_icdf
solve
solve_zero_extremum
sommet
sort
sorta
sortd
sorted
sphere
spherical2rectangular
split
sq
sqrfree
sqrt
srand
sst
sst_in
stddev
sto
str
string
strip
studentd
studentd_cdf
studentd_icdf
sturm
sturmab
sturmseq
subst
substituer
subtype
sum
suppress
surd
svd
sylvester
symb2poly
table
tabvar
tan
tan2cossin2
tan2sincos
tan2sincos2
tanh
taux_accroissement
taylor
tchebyshev1
tchebyshev2
tcoeff
tcollect
tcollectsin
texpand
throw
time
tlin
total_degree
trace
tran
trig2exp
trigcos
trigexpand
trigsimplify
trigsin
trigtan
trn
trunc
truncate
tsimplify
type
unapply
uniform
uniform_cdf
uniform_icdf
uniformd
uniformd_cdf
uniformd_icdf
unquote
upper
valuation
vandermonde
variance
vector
version
vpotential
warn_equal_in_prog
watch
weibulld
weibulld_cdf
weibulld_icdf
when
with_sqrt
write
wz_certificate
xcas
xcas_mode
zeros
zip

χ\chiCAS(io)