# $chi$CAS pour Numworks N0110

# χ\chiCAS pour Numworks N0110

### Bernard.Parisse@ujf-grenoble.fr

### 2021

Avertissement Numworks va fermer ses calculatrices aux développements tiers. À partir de la version stable 16 prévue pour la rentrée 2021, il sera impossible d’installer χ\chiCAS sur votre Numworks et impossible de revenir en arrière. Il est donc essentiel de ne pas mettre à jour votre calculatrice sur le site de Numworks. Si vous achetez une calculatrice, demandez un numéro de version du logiciel ≤\leq 15. Diffusez cette information aux personnes susceptibles de faire une mise à jour. Prenez garde en particulier lorsque vous vous connectez sur le workshop de Numworks, il est fort possible que le site vous propose (voire impose) une mise à jour sans vous avertir que cela bloque χ\chiCAS . Utilisez de préférence une version à jour de Xcas. (1.7.0-23 au moins) qui permet dorénavant d’échanger des programmes entre la calculatrice et votre ordinateur.

Plus d’informations sur le site TI-Planet. Si vous trouvez cette évolution désastreuse, vous pouvez signer une pétition en ligne ou mieux contacter Numworks et leur faire part de votre opinion.

## Table des matières

## 1 Introduction

Ce document explique comment prendre en main et utiliser efficacement sur calculatrices Numworks N0110 le système de calcul formel χ\chiCAS, une version adaptée du logiciel Xcas pour cette calculatrice. χ\chiCAS permet de transformer votre calculatrice graphique en calculatrice graphique formelle (CAS) pour faire du calcul littéral (développer, factoriser, calculer une limite, une dérivée, une primitive, résoudre des équations, faire du calcul matriciel exact ou approché, ...) et ajoute aussi des fonctionnalités pour les élèves qui envisagent une poursuite d’études en sciences ou en maths : gestion des unités de mesure, table périodique des éléments, plus grande varitété de représentations graphiques (suite récurrentes, champ de tangentes et solution d’une équation différentielle, lignes de niveau...), géométrie analytique, arithmétique et cryptographie (corps finis premiers et extensions, polynômes, etc.), algèbre, algèbre linéaire, analyse numérique, calcul flottant multi-précision et certifié (arithmétique d’intervalle), etc.

χ\chiCAS propose aussi une application tableur, qui permet de combler l’absence de cette fonctionnalité dans le système Epsilon fourni par Numworks. Enfin, un interpréteur MicroPython est maintenant inclus dans χ\chiCAS pour les programmes qui nécessitent une compatibilité stricte avec Python. Ce MicroPython comprend un module d’arithmétique (test de primalité, PGCD, identité de Bézout), et deux modules pour faire du calcul vectoriel et matriciel et trouver des racines de polynome, Le tas MicroPython peut être configuré jusqu’à 64K (le double de ce qui est possible dans Epsilon).

Toutes ces fonctionnalités sont intégrées, on peut représenter sur un même graphique un histogramme et un graphe de fonction et une droite, on peut écrire un programme pour faire une simulation et représenter les résultats graphiquement, ou utiliser les fonctions mathématiques dans un programme en syntaxe Python ou utiliser un programme en syntaxe Python dans le tableur.

La philosophie de χ\chiCAS est très éloignée de celle du système Epsilon de la Numworks qui a des applications ciblées, faciles à utiliser, mais aux fonctionnalités mathématiques relativement limitées et qui communiquent peu entre elles. Ici, on passera un peu de temps à apprendre comment utiliser le shell et les outils d’édition pour ensuite les faire travailler harmonieusement ensemble, sans autres limites que la mémoire (malheureusement très limitée) et la vitesse de la Numworks (tout à fait raisonnable pour une calculatrice). Il est donc fortement recommandé de lire cette documentation pour une utilisation optimale de χ\chicas, à l’exception de la section 19 qui s’adresse uniquement aux programmeurs qui souhaitent programmer leur calculatrice en C ou C++.

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

## 2 Installation

Attention, certains 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 ces deux firmwares dans un examen ou concours. Les auteurs ne sauraient être tenus pour responsables en cas d’utilisation non autorisée.

Avant d’installer ou mettre à jour χ\chiCAS, pensez à sauvegarder vos données, car elles pourraient être effacées. Puis choisir une des méthodes :

1. Depuis Xcas (Windows et Linux)
   C’est la méthode conseillée, car elle permet ensuite d’échanger facilement des programmes avec la calculatrice sans avoir à passer par le site de Numworks1.
   Connecter la calculatrice, ouvrez Xcas, puis dans le menu Fich, sous-menu Numworks, sélectionner `Installer KhiCAS sur la calculatrice`. Lorsqu’on vous demande de faire un reset de la calculatrice, appuyez sur le bouton `RESET` à l’arrière de la calculatrice.
2. Via Internet avec un navigateur compatible avec webUSB
   Cliquez sur ce lien avec Chromium ou Google Chrome. Suivez les instructions pour installer un firmware compatible, puis installez KhiCAS.
3. Installation manuelle
   Pour installer ou mettre à jour χ\chiCAS sur votre Numworks N0110 : récupérez sur votre ordinateur le fichier delta.zip.
   - Si nécessaire, installez dfu-util
     - sur Mac, installez brew si nécessaire puis depuis un Terminal (dans Utilitaires) faire
       `brew install dfu-util`
     - sous Linux debian compatible, ouvrir un Terminal et faire
       `sudo apt-get install dfu-util`
       Vous pouvez aussi compilez et installer à partir du source.
       Récupérez ce fichier et copiez le dans `/etc/udev/rules.d`. Si vous avez installé un package debian, cela peut se faire par la commande
       `sudo cp /usr/share/giac/doc/50-numworks-calculator.rules /etc/udev/rules.d` Vous pouvez aussi créer un fichier `/etc/udev/rules.d/50-numworks-calculator.rules` de contenu :

           SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="a291", TAG+="uaccess"
           SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="df11", TAG+="uaccess"

     - sous Windows, téléchargez et installez la version 64 bits ou 32 bits (provenance). L’exécutable s’appelle `dfu-util-static.exe`. Si nécessaire éditez le fichier `updaten110.bat` (64 bits) ou `updaten110_32.bat` (32 bits) pour adapter les chemins d’installation. Le fichier actuel suppose que l’on a desarchivé `delta.zip` et `dfu-util-0.9-win64.zip` depuis le même répertoire racine (par exemple `c:\temp`) et qu’on lance `updaten110.bat` (64 bits) ou `updaten110_32.bat` (32 bits) en cliquant sur le fichier dans l’explorateur de fichiers.
   - Tapez la commande `./updaten110` (Linux/Mac) ou exécutez `updaten110.bat` (Windows 64 bits) ou `updaten110_32.bat` (Windows 32 bits). Les commandes `dfu-util` sont les suivantes

         dfu-util -i0 -a0 -D epsilon.dfu
         dfu-util -i 0 -a 0 -s 0x90200000 -D apps.tar

Après installation, redémarrez la calculatrice par appui sur le bouton RESET si nécessaire. Tapez sur la touche HOME puis Entree pour lancer χ\chiCAS.

Licence d’utilisation : la licence choisie par Numworks pour son système d’exploitation rend impossible la publication d’un firmware binaire unique contenant également un logiciel libre. Le firmware est donc décomposé en deux parties, `epsilon.dfu`, sous licence Creative Commons Attribution-NonCommercial- ShareAlike 4.0 International Public License et `apps.tar` sous licence GPL2.

## 3 Premiers pas

Depuis le menu principal de la Numworks, tapez la touche HOME ou déplacez le curseur jusqu’à l’icone (Extension) puis tapez EXE. Ceci ouvre un “shell” dans lequel vous pouvez taper la plupart des commandes de calcul formel de Xcas. Au premier lancement, vous avez le choix de l’évaluateur entre Xcas et MicroPython, on suppose ici que vous choisissez Xcas en tapant OK ou EXE. Si vous avez choisi MicroPython, lisez la section correspondante 13. Pour passer à Xcas (respectivement Python), depuis une ligne de commande vide, taper les touches `shift ) 8 OK`.

Pour revenir au menu principal de la Numworks, il faut taper HOME plusieurs fois (2 fois depuis le shell).

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. 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 `sto`→\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 `=`. Par exemple `a=2` fait la même chose que `2=>a`.

Pour vous aider à saisir les commandes Xcas les plus utiles, χ\chiCAS dispose d’un catalogue d’une centaine de commandes, avec une courte description et le plus souvent un exemple d’exécution facile à recopier. Appuyez sur la touche Toolbox, choisissez une catégorie avec le curseur, par exemple `Algebre`, tapez EXE, puis choisissez une commande avec le curseur, par exemple `factor`. Un deuxième appui sur la touche Toolbox vous affiche une courte description de la commande, en général avec un exemple. En tapant sur Ans (ou EXE), 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. Essayez avec `factor` (touche Toolbox, puis `Algebre`).

Parmi ces commandes, celles qui sont le plus utilisées sont accessibles par des menus rapides activés par la touche shift suivi d’un chiffre, de `.`, de 10^x, de `(` ou de `)`, comme le rappelle la ligne en bas de l’écran, par exemple shift suivi de 1 affiche un menu d’algèbre où on retrouve la commande `factor`.

Lorsqu’une commande est entrée sans arguments, un “tooltip” (petit rectangle sur fonds jaune) affiche une courte description de ce que fait la commande et la syntaxe, pour voir en entier l’aide sur la commande il suffit de taper sur la touche flèche vers le bas (ou sur la touche var). Taper sur Ans pour entrer les arguments du premier exemple de l’aide. Taper sur la touche EXIT (à droite de OK) pour effacer le tooltip.

Lorsque vous exécutez une commande et qu’elle 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 (à droite de OK) pour revenir au shell.

Maintenant essayez de taper la commande `plot(sin(x))`. Indication: tapez Toolboox, puis sélectionner `Courbes`, ou utilisez le menu rapide shift 3.

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

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

Pour quitter χ\chiCAS depuis le shell, appuyez sur la touche HOME 2 fois. Lorsque vous lancez une autre application, les variables et l’historique des calculs sont sauvegardés, ils seront restaurés lorsque vous reviendrez dans χ\chiCAS.

Remarques :

- Depuis le shell de calcul, les touches 1 à 9, 0, `.` et `x10` x^x, `(`, `)` précédées de shift 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 permet de voir l’aide sur la commande (si l’aide existe) et de saisir un exemple.
- Exemple : tapez shift-2, puis 3 (integrate), flèche vers le bas, puis Ans ou EXE
  Modifiez l’expression à intégrer selon vos besoin puis tapez EXE
- Lorsque la mémoire est presque saturée, les calculs sont automatiquement interrompus et un message d’avertissement apparait. Il faut alors effacer des variables avec la commande `purge` (accessible depuis la touche `var`).

## 4 Échange de données avec Xcas.

### 4.1 Depuis un navigateur comme Chromium ou Chrome, compatible webusb

- La version web de Xcas utilisée avec un navigateur compatible webusb, par exemple Chrome ou Chromium permet d’échanger des données avec la calculatrice Numworks. En cliquant sur le bouton Numworks→\rightarrow, on peut importer un script de la calculatrice vers la feuille de calcul du navigateur, le modifier, puis le renvoyer vers la calculatrice avec le bouton Export. En affichant la section Numworks de la documentation (depuis le bouton Doc) on a également accès à la certification du firmware Delta+χ\chiCAS.
- Le kit de connexion Numworks permet aussi d’échanger des données avec la calculatrice Numworks : des scripts Python ou des backups. On peut aussi installer Delta+χ\chiCAS, porter assistance à une calculatrice bloquée et certifier un firmware.

### 4.2 Depuis Xcas pour Windows, Linux

Vérifiez que Xcas. est en version 1.7.0-23 ou ultérieure, si nécessaire installez ou mettez à jour.

Sous Linux, vérifiez que dfu-util est bien installé et que le fichier 50-numworks-calculator.rules a été copié dans `/etc/udev/rules.d`. Si vous avez installé un package debian, cela peut se faire par la commande
`sudo cp /usr/share/giac/doc/50-numworks-calculator.rules /etc/udev/rules.d`

Les outils pour se connecter avec la Numworks se trouvent dans le menu `Fich`, sous-menu `Numworks`. Vous pouvez :

- ouvrir un programme de la calculatrice dans la session actuelle Xcas ou ouvrir une session χ\chiCAS Numworks de la calculatrice dans un nouvel onglet de Xcas,
- envoyer la session actuelle Xcas comme une session χ\chiCAS sur votre calculatrice,
- envoyer le programme de l’éditeur de programme courant sur votre calculatrice
- créer une nouvelle session Xcas contenant tous les programmes de votre calculatrice
- effacer les programmes de votre calculatrice et les remplacer par tous les programmes de la session Xcas actuelle
- faire une sauvegarde de votre calculatrice
- restaurer votre calculatrice à partir d’une sauvegarde
- installer Delta+χ\chiCAS sur une calculatrice (il suffit de le faire une fois pour toutes)
- débloquer une calculatrice Numworks. Ceci fonctionnera sur toute calculatrice N0110 qui n’est pas verrouillée par une mise à jour faite sur le site de Numworks après septembre 2021. Cela utilise le bootloader du fabricant du microprocesseur (ST) que l’on lance en maintenant la touche 6 de la calculatrice enfoncée en appuyant sur RESET à l’arrière de la calculatrice en même temps. Ce sous-menu envoie un bootloader “rescue mode” dans la RAM de la calculatrice et l’exécute, on peut ensuite installer Delta+χ\chiCAS (ou toute autre version dérivée d’Epsilon ≤15\leq 15).
- certifier que la version de Delta+χ\chiCAS de la calculatrice d’un élève est identique à celle fournie avec Xcas (et n’a donc pas été modifiée et recompilée en y ajoutant des données personnelles).

Sur Mac, il est recommandé d’utiliser le kit de connectivité web Numworks de la section précédente.

## 5 Commandes usuelles de calcul formel

### 5.1 Développer et factoriser

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

- `factor` : factorisation. Raccourci clavier shift-* (préfixé) ou `=>*` (infixé touche sto puis *), par exemple
  x^4-1=>*
  . Utiliser `cfactor` pour factoriser sur C\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 Numworks en a peu, le risque de reset existe.
- `ratnormal` : développer une expression, écrire une fraction sous forme irréductible.

### 5.2 Analyse

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

- `diff` : dérivation. On peut aussi utiliser la notation `'` (alpha-shift-") pour dériver par rapport à x 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 ∫1 t 4−1 dt\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 ∫ 0 π sin(x) 4 dx\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)
- `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 ∑ k=1 n k 2\sum_{k=1}^n k^2,
  sum(k^2,k,1,n)=>*
  calcule la somme et l’écrit sous forme factorisée.

### 5.3 Résoudre

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

- `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′=2 y 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,...)u_{n+1}=f(u_n,...), par exemple les suites arithmético-géométriques, par exemple u n+1=2 u n+3,u 0=1 u_{n+1}=2u_n+3, u_0=1
  rsolve(u(n+1)=2*u(n)+3,u(n),u(0)=1)

### 5.4 Arithmétique

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

#### 5.4.1 Entiers

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

- `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 n est un nombre premier. Le test est probabiliste pour de grandes valeurs de n 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 u,v,d tels que au+bv=d au+bv=d où d d est le PGCD de a a et b b, avec |u|<|b||u|&lt;|b| et |v|<|a||v|&lt;|a|.
  u,v,d:=iegcd(23,13); 23u+13v
- `ichinrem([a,m],[b,n])` lorsque cela est possible, renvoie c c tel que c=a(mod m)c=a \pmod m et c=b(mod n)c=b \pmod n (si m m et n n sont premiers entre eux, c c existe).
  c,n:=ichinrem([1,23],[2,13]); irem(c,23); irem(c,13)
- `powmod(a,n,m)` calcule a n(mod m)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.

#### 5.4.2 Polynômes

Depuis le catalogue, sélectionner le sous-menu `Polynomes` (8). La variable est par défaut x 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 x^n dans P P, `lcoeff(P)` coefficient dominant de P P, par exemple
  P:=x^3+3x; coeff(P,1); lcoeff(P)
- `degre(P)` degré du polynôme P 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 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_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 P et Q 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 e^{-x^2}dx sur R\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 dx sur [−1,1][-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),U n(cos(x))sin(x)=sin((n+1)x)T_n(\cos(x))=\cos(nx), \quad U_n(\cos(x))\sin(x)=\sin((n+1)x)

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

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

### 5.5 Algèbre linéaire, vecteurs, matrices

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

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

onload
dot(v,w)

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

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

onload
ou
[[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 j et colonne k k vaut 1 j+k+1\frac{1}{j+k+1} (attention les indices commencent à 0).

La matrice identité de taille n 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 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 `Matrices` (Toolbox sin)

- eigenvals(A)
  eigenvects(A)
  renvoient les valeurs propres et vecteurs propres d’une matrice carrée A A.
- P,D:=jordan(A)
  calcule la forme normale de Jordan d’une matrice A A (à coefficients exacts) et renvoie les matrices P P et D D telles que P −1 AP=D P^{-1}AP=D, avec D D triangulaire supérieure (diagonale si A A est diagonalisable)
- Ak:=matpow(A,k)
  calcule la puissance k k-ième d’une matrice A A avec k k une variable formelle.
- `rref` effectue la réduction sous forme échelonnée d’une matrice A A (pivot de Gauss)
- `lu` calcule la décomposition LU LU d’une matrice A A et renvoie une permutation de matrice P P et deux matrices L L triangulaire inférieure et U U triangulaire supérieure telles que PA=LU 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 Ax=b de matrice A A en résolvant deux systèmes triangulaires (calcul en O(n 2)O(n^2) au lieu de O(n 3)O(n^3)).
- `qr` calcule la décomposition QR QR d’une matrice A A et renvoie deux matrices Q Q orthogonale et R R triangulaire supérieure telles que A=QR A=QR.
- `svd(A)` calcule la factorisation en valeurs singulières d’une matrice A A, et renvoie U U orthogonale, S S vecteur des valeurs singulières, Q Q orthogonale tels que `A=U*diag(S)*tran(Q)`. Le rapport de la plus grande valeur singulière de S S sur la plus petite donne le nombre de condition de A A relativement à la norme euclidienne, plus ce nombre est grand, plus on perd en précision en résolvant un système Ax=b Ax=b lorsque b b n’est pas connu exactement.

## 6 Probabilités et statistiques

### 6.1 Tirages aléatoires

Depuis le catalogue, sélectionner le sous-menu `Probabilites` (Toolbox 9) puis sélectionnez rand()
(réel selon la loi uniforme dans [0,1][0,1]) ou n:=6:; randint(n)
(entier entre 1 et n 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 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)

### 6.2 Lois de probabilités

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

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

Exemple : calcul de l’intervalle centré I I pour la loi normale de moyenne 5000 et d’écart-type 200 tel que la probabilité d’être en-dehors de I I soit de 5% : M:=5000; S:=200; normald_icdf(M,S,0.025);normald_icdf(M,S,0.975)

### 6.3 Statistiques descriptives 1-d

Ces fonctions agissent sur des listes par exemple

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

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

- 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 `shift-3` `histogram` et `barplot`.

### 6.4 Statistiques descriptives 2-d, régressions.

Voir aussi la section 15 expliquant le tableur.

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

- `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, les commandes de suffixe `_regression_plot` tracent la courbe représentative de la régression (Ces commandes affichent de plus le coefficient R 2 R^2 qui permet de quantifier la qualité de l’ajustement (plus R 2 R^2 est proche de 1, meilleur est l’ajustement). Khicas a des commandes pour faire des régressions linéaires, exponentielles, logarithmiques, puissance, polynomiales et logistique.
- Par exemple `linear_regression(X,Y)` renvoie les coefficients m,p m,p de la droite de régression linéaire y=mx+p y=mx+p.
  `linear_regression_plot(X,Y)` trace la droite d’ajustement des données contenues dans les listes `X,Y` de même taille.
- voir aussi les commandes `scatterplot`, `polygonplot` et `polygonscatterplot` pour afficher les données sur un graphique. On peut superposer plusieurs courbes de régression sur le même graphe en les séparant par un `;` en ligne de commande.

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

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

## 7 Courbes et autres représentations graphiques

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

- `plot(f(x),x=a..b)` trace le graphe de f(x)f(x) pour x∈[a,b]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)
- `LineTan(f(x),x,x0)` trace la tangente au graphe de f(x)f(x) en x=x 0 x=x_0.
- `plotarea(f(x),x=a..b,n,methode)` trace le graphe de f(x)f(x) pour x∈[a,b]x\in [a,b], et noircit une portion du plan qui approche l’aire sous la courbe, on peut préciser une méthode d’intégration avec `n` subdivisions parmi `rectangle_droit`, `rectangle_gauche`, `trapezes`, `simpson` (aller dans Toolbox , Options puis taper le début du nom de la méthode pour la saisir plus rapidement)
- `plotseq(f(x),x=[u0,a,b])` graphe “en toile d’araignée” de la suite récurrente u n+1=f(u n)u_{n+1}=f(u_n) de premier terme u 0 u_0 donné. Par exemple si u n+1=2+u n,u 0=6 u_{n+1}=\sqrt{2+u_n}, u_0=6 avec une représentation sur [0,7][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))(x(t),y(t)) pour t∈[t m,t M]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(θ)r(\theta) pour θ∈[a,b]\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)(i,l_i) (indice i i commençant à 0).
  `plotlist([X1,Y1],[X2,Y2],...)` trace la ligne polygonale reliant les points de coordonnées (X i,Y i)(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)(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,...f(x,y)=l_0, f(x,y)=l_1, ....
- `plotdensity(f(x,y),[x=xmin..xmax,y=ymin..ymax])` représentation par niveaux de couleurs de la fonction de 2 variables `x` et `y` dans le rectangle spécifié (par défaut entre -4 et 4).
- `plotfield(f(t,y),[t=tmin..tmax,y=ymin..ymax])` trace le champ des tangentes à l’équation différentielle y′=f(t,y)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 y(t_0)=y_0. Exemple y′=sin(ty)y'=\sin(ty) sur l’intervalle [−3,3][-3,3] en temps et [−2,2][-2,2] en y 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` (Toolbox ,) 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).
- 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 x ou en y 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` (`axes=0`). La commande doit précéder une commande de tracé.

## 8 Géométrie analytique.

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

## 9 Unités et constantes physiques.

Le menu Toolbox, constantes physiques (raccourci `Toolbox pi`) et unités physiques (raccourci `Toolbox sqrt`) 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
- une liste de constantes physiques fondementales.

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

## 10 L’éditeur d’expressions

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

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

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

Taper OK pour quitter l’éditeur 2d et copier l’expression en ligne de commande, taper EXIT pour quitter sans recopier l’expression.

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

Exemple 2 : nous allons saisir ∫ 0 +∞1 x 4+1 dx\int_0^{+\infty} \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir ∫ 0 1 0 dx\int_0^1 0 \ dx avec x 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)` EXE, puis curseur vers la gauche shift-1 7 EXE. Taper sur OK pour recopier vers la ligne de commande puis OK pour effectuer le calcul, le résultat s’affiche dans l’éditeur 2d, OK 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 ∫1 x 4+1 dx\int \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir ∫ 0 1 0 dx\int_0^1 0 \ dx Déplacez le curseur sur le 0 de la borne inférieure de l’intégrale et tapez sur la touche DEL, vous devez voir ∫0 dx\int 0 \ dx avec le tout sélectionné. Utilisez le curseur vers le bas pour sélectionner 0 et tapez `1/(x^4+1)` EXE puis OK pour recopier en ligne de commande puis OK pour exécuter le calcul, le résultat s’affiche maintenant dans l’éditeur 2d.
On peut alors sélectionner avec les touches du curseur par exemple l’argument d’un des arctangentes et exécuter shift-1 EXE (simplify) pour effectuer une simplification partielle du résultat, puis recommencer avec l’autre arctangente.
On peut simplifier encore plus, en rassemblant les logarithmes. Pour cela il faut d’abord échanger deux des arguments de la somme. Sélectionnez un des logarithmes avec des déplacements du curseur, puis tapez shift-curseur droit ou gauche, cela échange l’argument sélectionné avec son frère de droite ou de gauche. Tapez ensuite 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, menu shift-1 2 EXE (factor), puis descendez la sélection sur la somme ou différence de logarithmes, allez dans le menu Toolbox puis EXE (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 EXE (eval).

## 11 Sessions de calculs

### 11.1 Edition de l’historique.

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

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

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

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

### 11.2 Variables

En appuyant sur la touche `var` vous affichez la liste des variables qui ont une valeur, ainsi que des commandes de gestion de variables. Déplacez le curseur vers une variable puis EXE pour la recopier en ligne de commande, DEL copie en ligne de commande la commande d’effacement de la variable (confirmez ensuite avec EXE). 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)` (`>` se trouve dans le menu shift-PRGM).

## 12 Programmation

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

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.

Trois programmes sont installés après un reset de la calculatrice (des polygones avec la tortue, la fractale de Mandelbrot, le calcul des racines d’un polynôme de degré 2). Vous pouvez les visualiser depuis le shell en tapant shift-4 (edit) puis HOME 4 (Inserer), les interpréter avec la touche OK et les exécuter depuis le shell (EXIT puis var pour sélectionner la fonction).

### 12.1 Prise en main (programmation)

Un premier exemple en ligne de commande :
une fonction définie par une expression algébrique. On saisit `nom_fonction(parametres):=expression` Par exemple, pour définir le périmètre d’un cercle de rayon r 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 p et un effectif n 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 Toolbox, par le raccourci Toolbox x 2 x^2. Saisir la commande avance dans ce menu puis valider, vous devez voir la tortue (symbolisée par un triangle) avancer de 10 pixels. Taper 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.
Ouvrez le menu Programmes (Toolbox cos), puis sélectionnez l’exemple de `pour` (curseur sur pour puis Ans)
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 n en utilisant la syntaxe compatible Python et l’éditeur de programmes. Tapez sur EXIT pour passer du shell à l’éditeur de programmes. Si on vous demande programme ou Tortue faites OK. Ceci ouvre l’éditeur avec une maquette de fonction `def f(x):` Vérifiez que la syntaxe Python est activée (menu HOME), sinon activez-la (8). Remplacez `x` par `n`, puis déplacez le curseur en fin de ligne et passez à la ligne (EXE). Tapez Shift-2 puis EXE (`for`), placez un `j` entre `for` et `in range(` puis un `n` entre les parenthèses de `range()`. À la ligne suivante, tapez shift-3 7 (`print`) et validez (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)
      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 OK. 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 HOME. 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
En syntaxe Xcas. 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 Toolbox Programmes pour saisir fonction, local, return et ffonction)

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

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

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

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

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

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

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

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

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

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

### 12.3 Commandes utilisables

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

## 13 Interpréteur MicroPython intégré

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

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

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

### 13.1 Les modules math, cmath, random

Ce sont les modules natifs fournis par MicroPython (`urandom` a été renommé `random`), et qui sont conforme au standard. D’autres modules MicroPython standard qui ne sont pas destinés à faire des maths sont disponibles.

### 13.2 Le module graphic

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

### 13.3 Le module matplotl

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

### 13.4 Le module arit

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

### 13.5 Le module linalg

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

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

### 13.6 Le module numpy

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

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

    import linalg
    import math
    class array:
        def __init__(self, a):
            self.a = a

        def __add__(self, other):
            return array(linalg.add(self.a , other.a))

        def __sub__(self, other):
            return array(linalg.sub(self.a , other.a))

        def __mul__(self, other):
            if type(self)==array:
                if type(other)==array:
                    return array(linalg.mul(self.a , other.a))
                return array(linalg.mul(self.a,other))
            return array(linalg.mul(self,other.a))

        def __rmul__(self, other):
            if type(self)==array:
                if type(other)==array:
                    return array(linalg.mul(self.a , other.a))
                return array(linalg.mul(self.a,other))
            return array(linalg.mul(self,other.a))

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

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

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

        def __len__(self):
            return len(self.a)

        def __str__(self):
            return 'array('+str(self.a)+')'

        def __repr__(self):
            return 'array('+str(self.a)+')'

        def __neg__(self):
            return array(-self.a)

        def __pos__(self):
            return self

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

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

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

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

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

        def T(self):
            return array(linalg.transpose(self.a))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## 14 Applications additionnelles

Les applications additionnelles sont accessibles en tapant HOME 1. Il y a actuellement un tableur, le tableau périodique des éléments (d’après Maxime Friess), et trois exemples d’addin qui peuvent servir de modèle aux programmeurs : la suite de Syracuse (très simple), la fractale de Mandelbrot et un jeu de mastermind (qui peut aussi servir de passe-temps).

## 15 Le tableur

Au lancement, vous avez un tableau de 14 lignes et 4 colonnes remplies de 0. Vous pouvez changer la dimension depuis la configuration du tableur (touche Home, configuration), mais attention, chaque cellule utilise de la mémoire, un peu moins de 100 octets pour une cellule remplie d’un nombre, plusieurs centaines d’octets si elle est remplie par une formule, et la mémoire de la Numworks est très limitée, s’il n’y a pas assez de mémoire lors d’une allocation, vous perdrez votre session de travail. Pensez à faire une sauvegarde de votre session de temps en temps!

La syntaxe pour créer une formule est identique à celle d’un tableur classique, on tape sur shift = puis on entre la formule, avec des références relatives (par exemple `=a1+1`) ou absolues (`=$a$1+1`). On peut utiliser les commandes de Xcas ainsi que des fonctions qu’on a programmées.

Il y a des assistants de saisie spécifiques au tableur dans les menus rapides shift 1, 2 et 3. Par exemple pour générer des entiers consécutifs, taper shift 3 puis OK ce qui crée une ligne de commande contenant `range(`, il suffit de mettre un entier a a ou deux entiers a a et b b en arguments pour créer la liste des entiers entre 0 et a−1 a-1 ou entre a a et b−1 b-1 et la dispatcher sur la colonne.

Autre exemple, pour avoir un tableau de valeurs de fonctions, se placer au début d’une colonne vide dont la colonne à droite est aussi vide et taper shift 3, sélectionner `tablefunc` puis passer en argument l’expression, par exemple `sin(x)` (ou `f(x)` si vous avez défini une fonction `f`). Vous pouvez ensuite régler la valeur de début et le pas dans le tableur. Pour une suite récurrente, se placer en haut d’une colonne vide et utiliser la commande `tableseq` du menu rapide shift 3.

Pour sélectionner une plage de cellules, taper simultanément sur shift et une touche de direction, vous pouvez ensuite relacher shift et déplacer le curseur en fin de sélection. Tapez OK pour valider (si vous la passez en argument d’une formule saisie dans une cellule du tableur), ou shift copy si vous voulez copier la sélection dans le presse-papier pour par exemple la recopier dans le shell avec shift paste.

Si vous utilisez un des assistants de statistiques 2d, faites la sélection des 2 colonnes avant de choisir la commande. Par exemple, en 1ère ligne, 1ère colonne, tapez shift 3 sélectionnez `range` puis complétez en `range(6)` comme valeurs de X puis en face en 2ème colonne entrez des valeurs et Y. Déplacez le curseur en 1ère ligne et en 1ère colonne, puis shift-curseur vers le base puis déplacements du curseur pour rejoindre l’autre extrémité de la sélection, puis shift 2, puis par exemple `polygonscatterplot`. Pour voir le graphique, tapez shift 6. Pour voir sur le même graphique la droite de régression linéaire correspondante, vous pouvez recommencer la procédure ou bien recopier la cellule contenant la formule de `polygonscatterplot` avec shift-copy shift-copy et la coller avec shift paste en-dessous, puis la modifier (shift 4 OK) en remplaçant `polygonscatterplot` par `linear_regression_plot`

Lorsqu’on utilise une plage de cellule en argument d’une commande, la plage de cellule est aplatie en une seule liste. Si on souhaite utiliser une matrice comme argument d’une commande, il faut reconstruire la matrice à partir de la liste en utilisant la commande `matrix(l,c,liste)` où `l,c` sont les dimensions de la matrice (c’est ce que fait l’assistant `scatterplot` du menu rapide de statistiques 2d (shift 2) si on sélectionne la plage de cellules auparavant).

Dans le menu accessible depuis la touche HOME, vous pouvez insérer ou effacer une ligne ou une colonne, vous pouvez aussi donner un nom de variable au tableur, la matrice des valeurs sera alors automatiquement sauvegardée dans cette variable, que vous pouvez utiliser ensuite depuis le shell.

Si vous entrez dans une cellule une formule donnant un résultat vecteur ou matrice, celle-ci sera dispatchée par défaut dans plusieurs cellules. On peut modifier cela dans la configuration du tableur.

## 16 Raccourcis claviers.

- La touche d’effacement en mode alphabétique a été modifiée (dans tout l’OS) pour effacer et ne pas renvoyer `%`, car cela rend la correction d’erreur de frappes très pénible. Pour saisir `%`, tapez shift `/` (ce qui est facile à retenir quand on programme un peu).
- on peut taper alpha-shift-`"` pour saisir `'`
- le caractère `\` est accessible via shift-`-`.
- shift-1 à shift-6: selon le mode (Xcas ou Python) voir les légendes
- shift-7 (M) matrice, 8 complexes, 9 arithmétique entière, `(` listes, `)` programmation, `0` probas `.` réels, `x10^` arithmétique polynomiale, Si MicroPython est activé, shift 7 linalg, 8 numpy, 9 arithmétique entière, `(` listes, `)` programmation, `0` matplotl, `.` graphic, `x10^` couleurs
- Si Xcas est actif, `=>` suivi d’une unité physique effectue une conversion d’unité, `=>` suivi d’une fonction permet d’exécuter des actions:
  `=>*` écriture sous forme de produit (pour une unité, écriture en utilisant les unités fondementales du système MKSA),
  `=>+` é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.
  `=>,` permet de chronométrer une évaluation,
  `16=>=>` écrit les entiers en base 16, `10=>=>` en base 10, `8=>=>` en base 8

Dans l’éditeur de programmes :

- touches curseur shiftées: déplacement en début/fin de ligne/fichier.
- shift copy ou shift et touche curseur simultanément: début de 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 sur shift copy pour copier la sélection sans l’effacer. Pour coller le presse-papier, taper shift paste.
- EXE: si une recherche/remplacement de mot est active (après avoir fait Home 6), recherche l’occurence suivante d’un mot. Sinon, passe à la ligne.
- DEL efface le caractère précédent ou la sélection.
- shift PASTE: copie le presse-papier
- var: 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.

## 17 Remarques

La mémoire vive (RAM) disponible sur la Numworks est vraiment très faible (espérons que ce sera modifié dans les prochains modèles!). χ\chiCAS implémente des garde-fous lorsque la mémoire est saturée, mais il existe un petit risque que la calculatrice reboote (comme si on appuyait sur Reset) s’il n’y a vraiment plus de mémoire.

Il est donc conseillé de transférer vos programmes sur un ordinateur en branchant la calculatrice et en faisant pointer sur l’ordinateur le navigateur Chromium ou compatible sur le site du constructeur Numworks avant de les tester.

Il n’y a pas pour le moment de mécanisme de sauvegarde sur la flash des données. Ce serait bienvenu, d’une part cela libérerait un peu de RAM, d’autre part cela permettrait d’être résistant à un crash et d’avoir une bibliothèque bien plus importante de programmes mais aussi de sessions compatibles Xcas, Xcas pour Firefox et χ\chicas pour Casio (qu’il serait agréable de pouvoir échanger sur le workshop Numworks ou sur un autre espace par exemple sur tiplanet).

Certains changements de Delta affectent l’application Python ou l’ensemble des applications :

- La prise en compte du clavier a été un peu modifiée, cf. la section 16.
- L’espace de travail pour les calculs hors de χ\chiCAS est divisé par 2, afin de laisser de la place pour les calculs dans χ\chiCAS. Je pense que cela suffit aux besoins des applications interactives de Epsilon, pour les calculs un peu plus gros, vous pouvez utiliser χ\chiCAS qui est générallement plus rapide ou plus précis. Quelques exemples :
  - calcul numérique ∑ n=1 1000 sin(cos(n+.5))\sum_{n=1}^{1000} \sin(\cos(n+.5)) χ\chiCAS: 0.64s, Epsilon: 1.5s environ (mesuré en prenant la somme jusque 10000 et en divisant par 10)
  - calcul matriciel exact, a a une matrice 4,4 inversible à coefficients entiers entre 0 et 10, on calcule `det(1/a^32)`, il faut environ 0.1 seconde avec χ\chiCAS et 5 secondes avec Epsilon.
  - le calcul d’une intégrale numérique généralisée telle que ∫ 0.0 1 ln(x)dx\int_{0.0}^1 \ln(x) \ dx renvoie undef avec Epsilon. Près d’une extrémité singulière ∫ 0.001 1 xcos(1 x)dx\int_{0.001}^1 x \cos\left(\frac{1}{x}\right) \ dx χ\chiCAS renvoie 0.0181170904, Epsilon 0.01793743 (erreur relative 1%)

## 18 Copyright, licences et remerciements

- OS Epsilon de la Numworks, (c) 2019 Numworks. Sous licence Creative Commons Attribution-NonCommercial- ShareAlike 4.0 International Public License
  Modifications par Damien Nicolet et Bernard Parisse, (c) 2019 (projet Delta), sous la même licence.
- Giac et χ\chiCAS, noyau de calcul (c) B. Parisse et R. De Graeve, 2019. Les calculs en entiers sont effectués avec GMP, les flottants multipécision avec MPFR, l’arithmétique d’intervalle avec MPFI
- Interface de χ\chiCAS 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 χ\chiCAS: 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 de χ\chiCAS ainsi que des librairies GMP, MPFR, MPFI et de la version modifiée de l’OS Numworks, se trouvent ici ou là
- Remerciements à Damien Nicolet pour le premier portage de giac sur Numworks N100 (au prix d’une modification matérielle), pour le portage de la newlib (librairie C/C++) sur N110 et la maintenance des sources au format git et la compatibilité avec les sources de Numworks. Sans lui, ce portage n’existerait pas. Remerciement à Jean-Baptiste Boric pour tests et conseils et à Maxime Friess pour son squelette d’application hello. Remerciement à l’équipe de tiplanet, en particulier Xavier Andréani, Lionel Debroux et Adrien Bertrand, pour le forum de discussion et tout le travail de mise en valeur de χ\chicas (stockages d’archives, articles, concours).
- le tableau périodique des éléments est un portage de l’application de Maxime Friess avec son autorisation de diffusion sous licence GPL.

## 19 Développement en C/C++.

Cette section s’adresse aux utilisateurs avancés qui souhaitent programmer leur calcultrice en exploitant toute sa puissance, donc sans être limité par la faible quantité de mémoire disponible pour des scripts Python et la lenteur relative du langage interprété. Le système non modifié de la Numworks permet de le faire, mais il est difficile de le maitriser, au-delà de modifications simples du code existant (par exemple modifier la valeur de certains paramètres), il faut bien connaitre C++, la programmation orienté objet et se limiter à une librairie standard très spartiate. Cela limite à mon avis le nombre de développeurs et la vitesse de développement sur cette plateforme, encore plus si on est habitué à un environement de développement frugal, personnellement j’utilise `emacs` comme éditeur de texte et un terminal, les arborescences à plusieurs niveaux et les espaces de noms imbriqués d’Epsilon sont un cauchemar. Le temps nécessaire à la compilation d’Epsilon est d’ailleurs un indicateur de cette complexité.

Un autre problème est que modifier Epsilon nécessite d’utiliser la même licence de logiciel, on ne peut donc pas développer du logiciel libre.

Damien Nicolet et moi-même avons développé des modifications autour de Epsilon, qui permettent de lancer un firmware d’extensions à partir de Epsilon. C’est le projet Delta, qui permet d’utiliser la `newlib`, une implémentation complète de la libc et de la libstdc++, et offre un SDK en langage C et en C– (i.e. avec un paradigme de programmation impératif très proche du C donc beaucoup plus accessible, avec les avantages que procurent la librairie standard C++). Ainsi ajouter une application toute simple comme la suite de Syracuse nécessite une dizaine de lignes de code, programmer la fractale de Mandelbrot moins de trente lignes de code un jeu de mastermind prend une bonne centaine de lignes (ces trois exemples se trouvent dans le fichier `kadd.cc` du source de `giac`) et l’interface du tableur de χ\chiCAS de l’ordre d’un millier de lignes.

Licences
L’utilisation du SDK de base de l’OS (19.4) vous impose de choisir une licence permettant d’utiliser les services de base d’un OS propriétaire, ce que toute licence de logiciel raisonnable devrait permettre, c’est le cas en particulier de la GPL. L’utilisation des autres fonctions du SDK impose une licence compatible avec la GPL.

### 19.1 Installation de l’environnement de développement.

Je décris l’installation sous Linux debian/ubuntu compatible depuis un terminal avec comme shell `bash`. On peut programmer sur d’autres OS, mais c’est plus facile sous Linux (en tout cas c’est plus facile pour moi d’expliquer comment faire!). Si vous travaillez habituellement sur Mac ou Windows, vous pouvez installer une machine virtuelle, par exemple avec Virtualbox et y mettre une distribution Linux debian-compatible, par exemple xubuntu.

On installe les packages nécessaires pour compiler giac et pour cross-compiler pour le processeur ARM :

    sudo apt-get install wget gdb gcc g++ libgmp-dev libmpfr-dev libmpfi-dev libpari-dev libgsl0-dev libxext-dev libpng-dev libjpeg-dev libreadline-dev libncurses5-dev mesa-common-dev libx11-dev libxt-dev libxft-dev libntl-dev libgl1-mesa-dev libgl-dev libao-dev hevea debhelper libfltk1.3-dev
    sudo apt-get install build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config gcc-arm-none-eabi binutils-arm-none-eabi dfu-util

#### 19.1.1 Epsilon/Delta 14.4 (calculatrice), 12.3 (simulateur)

Pour récupérar les sources, faire

    wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/delta14_device.tgz
    tar xvfz delta14_device.tgz
    wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/delta_simu.tgz
    tar xvfz delta_simu.tgz

Il y a deux arborescences distinctes, une pour la calculatrice (`final`), l’autre (`delta`) pour avoir un environnement de développement avec possibilité d’exécuter le code pas à pas.Cela pour deux raisons

- le simulateur a changé dans Epsilon 14, et la nouvelle version est inutilisable sur ma machine (affichage flou illisible), je travaille donc avec l’ancienne version du simulateur (qui par ailleurs utilise le même toolkit FLTK que Xcas ce qui me facilite le travail pour adapter le simulateur pour debugguer efficacement)
- le shell KhiCAS permet maintenant de choisir MicroPython comme évaluateur. Sur la calculatrice, KhiCAS et Epsilon sont complètement séparés donc chacun peut utiliser son propre MicroPython, mais sur le simulateur, il n’y a qu’une seule application, il faut donc utiliser le même source pour le MicroPython dans Epsilon et dans KhiCAS.

Attention à ne pas confondre le sous-rṕertoire `delta` de `final` qui contient une version modifiée de Epsilon 14.4 pour la calculatrice avec le répertoire `delta` qui contient une version modifiée de Epsilon 12.3.

Le répertoire `final` contient l’arborescence pour compiler pour la calculatrice. Les librairies nécessaires sont précompilées dans le répertoire `ext/n0110/lib`. Il faut juste compiler Delta.

    cd final/delta
    make
    cd ../nw-external-apps
    make

Si vous voyez des messages tels que `... switch -mcpu=cortex-m7 conflicts...`, c’est que le cross-compilateur ARM de votre distribution Linux est trop ancien. Allez sur le site du ARM SDK, descendez jusqu’à faire apparaitre la version 7 (vous pouvez essayer une version plus récente si votre distribution Linux est récente), téléchargez pour Linux x64 et exécutez la commande
`cd && tar xvfj Downloads/gcc-arm-none-eabi-7-2018-q2-update-linux.tar.bz2`
puis ajoutez dans votre fichier `~/.bashrc` la ligne
`export PATH=~/gcc-arm-none-eabi-7-2018-q2-update/bin:$PATH`
sauvegardez, puis tapez les commandes
`source ~/.bashrc`
`cd chemin_vers_final/delta`
`make`
`cd ../nw-external-apps`
`make apps.tar`
`cd ../..`

Le fichier firmware de la version modifiée de Epsilon, `epsilon.dfu` est dans le sous-répertoire `delta/output/release/device/n0110` de `final`, le fichier contenant les applications externes est `apps.tar` dans le répertoire `nw-external-apps`. Pour les flasher sur la calculatrice faire

    dfu-util -i0 -a0 -D final/delta/output/release/device/n0110/epsilon.dfu #-s 0x90000000
    dfu-util -i0 -a0 -D final/nw-external-apps/apps.tar -s 0x92000000

Le premier fichier est le firmware Epsilon avec les modifications du projet Delta. Ce projet Delta fournit une interface pour programmer la calculatrice en C et permet d’exécuter du code contenu dans un fichier `apps.tar` qui est stocké dans le deuxième firmware,

Pour compiler le simulateur, vous pouvez lancer le script `delta/mkstat` (attention, `delta` ne désigne pas le sous-répertoire de `final`, mais le répertoire créé quand on a désarchivé `delta_simu.tgz`) ou vous pouvez exécuter les instructions suivantes

    cd delta/ext/giac-1.5.0/src
    ln -sf config.h.numworks.gmp config.h
    make -f Makefile.numworks.simulator
    /bin/cp simu/libgiac.a ../../simulator/lib
    cd ../../..
    /bin/rm output/simulator/debug/epsilon.elf
    make V=1 DEBUG=1 PLATFORM=simulator
    ln -sf output/simulator/debug/epsilon.elf simu

Essayez mantenant de taper `./simu` puis de lancer Khicas sur le simulateur en tapant `\` (cette touche permet de simuler l’appui sur la touche HOME).

Si vous modifiez le source de giac, il faut recompiler la librairie `libgiac.a` et la copier dans `final/nw-external-apps/KhiCAS`, pour cela vous pouvez utiliser le script `mkarm` dans le répertoire `final/ext/giac-1.6.0/src`. N’oubliez pas de répercuter la modification dans le code source du simulateur, vous pouvez aussi créer un lien symbolique pour éviter d’oublier
`rm -rf delta/ext/giac-1.6.0`
`ln -s final/delta/ext/giac-1.6.0 delta/ext`

Attention, le support de MicroPython et de l’exécution en mode pas à pas n’est pas compatible, à cause du code assembleur de certaines fonctions situées dans les fichiers `delta/python/src/py/nlr*`. En conséquence si vous sélectionnez MicroPython pour évaluer dans KhiCAS, le simulateur plantera dès la première évaluation. Pour contourner ce problème, il faut compiler ces fichiers `nlr*` en mode release puis copier les fichiers objets obtenus dans le répertoire `debug` d’Epsilon/Delta. Pour faire cela, vous pouvez lancer le script `delta/mksimu`, puis le script `delta/cpnlr`. La prochaine exécution de `delta/mkstat` devrait alors donner un exécutable `simu` qui permet d’activer simultanément l’évaluation MicroPython et la mise au point.

### 19.2 Utilisation du débuggueur

Le simulateur peut se lancer avec le débuggueur en tapant `gdb ./simu` ou depuis votre éditeur de texte ou votre environnement de développement. Par exemple si vous utilisez `emacs`, tapez `Esc x gdb`, valider, mettre `simu` comme nom d’exécutable, valider. Voir par exemple ici un guide de prise en main d’utilisation du débuggueur avec emacs. Vous pouvez exécuter la commande
`cp delta/ext/giac-1.6.0/src/.gdbinit delta`
pour définir la macro `v` de `gdb` qui vous permettra de visualiser les variables de type `giac::gen` de manière plus parlante qu’avec la commande `p`.

Par exemple, si vous faites dans la console `gdb` la commande `b khicas_addins_menu` (breakpoint, i.e. point d’arrêt à cette fonction), puis `r` pour lancer le programme, il s’interrompra dans le menu d’affichage des applications tierces (Home 1), vous pouvez alors exécuter ligne après ligne avec la commande `n`, en visualisant le contenu des variables avec la commande `p` ou `v` pour des variables Xcas de type gen.

### 19.3 Intégration avec le shell Khicas

Pour ajouter une application au menu `Home 1` des applications ajoutées dans Khicas, il faut modifier la fonction `khicas_addins_menu()` dans `kadd.cc`. Incrémentez `smallmenu.numitems`, définissez `smallmenuitems[j].text` pour la première valeur de `j` disponible, puis dans la boucle `while(1) {...}`, ajoutez la définition de votre fonction ou un appel vers votre fonction avec `if (smallmenu.selection==j+1)`. Pour compiler et tester, cf. la fin de la section 19.1.1.

L’exemple de la suite de Syracuse vous montre comment faire entrer une valeur, afficher un graphique repéré, et entrer quelque chose en ligne de commande. L’exemple de la fractale de Mandelbrot montre comment afficher un graphique pixelisé pixel par pixel. L’exemple du jeu de Mastermind montre comment afficher un graphique pixelisé avec des formes plus complexes et interagir avec l’utilisateur lorsqu’il appuie sur une touche.

Conseils :

- Pour commencer à programmer votre propre firmware, vous pouvez modifier un de ces exemples. Par exemple, demander des paramètres pour la fractale. Ou changer le nombre de couleurs disponibles ou le nombre d’essais dans le Mastermind. Puis ajouter une application de votre cru, par exemple faire un écran de saisie puis afficher une courbe.
- Si vous utilisez des données constantes, n’oubliez pas de mettre le modificateur `const` pour économiser la mémoire RAM.
- Pour travailler avec des chaines de caractères sans vous soucier des allocations mémoires, vous pouvez utiliser `string`, pour des tableaux de taille dynamique `vector<>` (voir par exemple le site cplusplus.com pour la description des fonctions de la librairie standard C++)
- Il faut être économe en mémoire, la disponibilité sur le tas est faible (au plus 120 kilo-octets si aucune variable KhiCAS n’est stockée en mémoire, que le tas Micro-Python n’est pas actif et qu’il n’y a pas de tableur).

Les paragraphes qui suivent décrivent brièvement le SDK. Pour plus de détails, il faut ensuite se référer à `k_csdk.h` et `kdisplay.h/kdisplay.cc` pour l’interface et aux fichiers headers de `giac` pour toutes les fonctions de `giac`.

### 19.4 Fonctions de base de l’OS.

Les fonctions de bas niveau de Epsilon sont déclarées dans `k_csdk.h` et sont utilisables depuis un programme C et tout langage qui s’interface avec C (donc quasiment tout langage).

Si vous voulez créer une extension indépendante de KhiCAS, vous pouvez vous inspirer d’une des applications de `final/nw-external-apps`, définissez votre propre fonction `int main()` et linkez avec votre fichier objet à la place de `-lgiac`, dans ce cas vous pouvez choisir n’importe quelle licence de logiciel qui peut se lier avec une licence d’OS propriétaire.

Le clavier :

- `int getkey(int allow_suspend);`
  renvoie un code touche, `allow_suspend` est non nul si on autorise l’utilisateur à éteindre la calculatrice (attention dans ce cas à gérer l’affichage). Les touches sont définies comme suit, la 2ième ligne correspond aux touches Home (jaune) et Power (noire), avec 4 codes de touches inexistantes, les lignes à partir de la 6ième ont un code de touche inexistant sur le clavier.

      const short int translated_keys[]=
        {
         // non shifted
         KEY_CTRL_LEFT,KEY_CTRL_UP,KEY_CTRL_DOWN,KEY_CTRL_RIGHT,KEY_CTRL_OK,KEY_CTRL_EXIT,
         KEY_CTRL_MENU,KEY_PRGM_ACON,KEY_PRGM_ACON,9,10,11,
         KEY_CTRL_SHIFT,KEY_CTRL_ALPHA,KEY_CTRL_XTT,KEY_CTRL_VARS,KEY_CTRL_CATALOG,KEY_CTRL_DEL,
         KEY_CHAR_EXPN,KEY_CHAR_LN,KEY_CHAR_LOG,KEY_CHAR_IMGNRY,',',KEY_CHAR_POW,
         KEY_CHAR_SIN,KEY_CHAR_COS,KEY_CHAR_TAN,KEY_CHAR_PI,KEY_CHAR_ROOT,KEY_CHAR_SQUARE,
         '7','8','9','(',')',-1,
         '4','5','6','*','/',-1,
         '1','2','3','+','-',-1,
         '0','.',KEY_CHAR_EXPN10,KEY_CHAR_ANS,KEY_CTRL_EXE,-1,
         // shifted
         KEY_SHIFT_LEFT,KEY_CTRL_PAGEUP,KEY_CTRL_PAGEDOWN,KEY_SHIFT_RIGHT,KEY_CTRL_OK,KEY_CTRL_EXIT,
         KEY_CTRL_MENU,KEY_PRGM_ACON,KEY_PRGM_ACON,9,10,11,
         KEY_CTRL_SHIFT,KEY_CTRL_ALPHA,KEY_CTRL_CUT,KEY_CTRL_CLIP,KEY_CTRL_PASTE,KEY_CTRL_AC,
         KEY_CHAR_LBRCKT,KEY_CHAR_RBRCKT,KEY_CHAR_LBRACE,KEY_CHAR_RBRACE,'_',KEY_CHAR_STORE,
         KEY_CHAR_ASIN,KEY_CHAR_ACOS,KEY_CHAR_ATAN,'=','<','>',
         KEY_CTRL_F7,KEY_CTRL_F8,KEY_CTRL_F9,KEY_CTRL_F13,KEY_CTRL_F14,-1,
         KEY_CTRL_F4,KEY_CTRL_F5,KEY_CTRL_F6,KEY_CHAR_FACTOR,'%',-1,
         KEY_CTRL_F1,KEY_CTRL_F2,KEY_CTRL_F3,KEY_CHAR_NORMAL,'\\',-1,
         KEY_CTRL_F10,KEY_CTRL_F11,KEY_CTRL_F12,KEY_SHIFT_ANS,KEY_CTRL_EXE,-1,
         // alpha
         KEY_CTRL_LEFT,KEY_CTRL_UP,KEY_CTRL_DOWN,KEY_CTRL_RIGHT,KEY_CTRL_OK,KEY_CTRL_EXIT,
         KEY_CTRL_MENU,KEY_PRGM_ACON,KEY_PRGM_ACON,9,10,11,
         KEY_CTRL_SHIFT,KEY_CTRL_ALPHA,':',';','"',KEY_CTRL_DEL,
         'a','b','c','d','e','f',
         'g','h','i','j','k','l',
         'm','n','o','p','q',-1,
         'r','s','t','u','v',-1,
         'w','x','y','z',' ',-1,
         '?','!',KEY_CHAR_EXPN10,KEY_CHAR_ANS,KEY_CTRL_EXE,-1,
         // alpha shifted
         KEY_SHIFT_LEFT,KEY_CTRL_PAGEUP,KEY_CTRL_PAGEDOWN,KEY_SHIFT_RIGHT,KEY_CTRL_OK,KEY_CTRL_EXIT,
         KEY_CTRL_MENU,KEY_PRGM_ACON,KEY_PRGM_ACON,9,10,11,
         KEY_CTRL_SHIFT,KEY_CTRL_ALPHA,':',';','\'','%',
         'A','B','C','D','E','F',
         'G','H','I','J','K','L',
         'M','N','O','P','Q',-1,
         'R','S','T','U','V',-1,
         'W','X','Y','Z',' ',-1,
         '?','!',KEY_CHAR_EXPN10,KEY_CHAR_ANS,KEY_CTRL_EXE,-1,
        };

- `int getkey_raw(bool allow_suspend);`
  renvoie le scan code de Numworks, de 0 à 53 pour le clavier non shifté, ajouter 54 pour shifté, ajouter 108 pour alpha, 162 pour alpha shifté
- `void GetKey(int * key);`
  renvoie une touche au clavier, en utilisant le même prototype que le SDK pour calculatrices Casio.
- `bool os_set_angle_unit(int mode);` change l’unité d’angle (0 radians, 1 degrés)
- `int os_get_angle_unit();` renvoie l’unité d’angle
- `bool isalphaactive();`
  renvoie vrai si le mode alpha est actif.
- `bool alphawasactive();`
  renvoie vrai si le mode alpha était actif avant la dernière frappe de touche
- `void lock_alpha();`
  verrouille le mode alpha
- `bool back_key_pressed();`
  renvoie vrai en cas d’appui sur la touche Back. Utile pour permettre d’interrompre un programme. Ceci nécessite de tester souvent l’appui sur Back. Attention, pour éviter des problèmes lors de l’initialisation, les 400 premiers appels à cette fonction renvoient faux.
- `bool is_keydown(int key);`
- `void reset_kbd();`
  enlève les modes shift et alpha s’ils étaient actifs.

Les affichages.
Notez que y=0 y=0 correspond à la première ligne en-dessous de la ligne d’état (18 pixels de hauteur), on a donc 0≤y<222 0 \leq y&lt;222 et 0≤x<320 0\leq x &lt;320
Les couleurs utilisent un entier 16 bits au format RGB 565, on peut convertir depuis RGB888 par

    int rgb888to565(int c){
      int r=(c>>16)&0xff,g=(c>>8)&0xff,b=c&0xff;
      return (((r*32)/256)<<11) | (((g*64)/256)<<5) | (b*32/256);
    }

- `void statusline(int mode=0);`
  affiche la ligne d’état standard
- `void statuslinemsg(const char * msg);`
  affiche une chaine de caractères dans la ligne d’état
- `void os_fill_rect(int x,int y,int w,int h,int c);`
  remplit un rectangle avec une couleur de couleur `c` donné en rgb565,
- `void os_set_pixel(int x,int y,int c);`
  affiche un pixel de couleur `c` donné en rgb565
- `int os_get_pixel(int x,int y);`
  renvoie la couleur rgb565 d’un pixel.
- `int os_draw_string(int x,int y,int c,int bg,const char * s,bool fake=false);`
  `int os_draw_string_small(int x,int y,int c,int bg,const char * s,bool fake=false);`
  écrit une chaine de caractère avec la fonte de taille normale ou petite à partir du pixel x,y x,y en couleur `c` (rgb565 ), avec une couleur de fonds `bg`. Renvoie la position finale de x x. Si `fake` est `true`, il n’y a pas décriture, juste le calcul de la position finale de x x.
- `bool waitforvblank()`
  synchronisation écran, à appeler juste avant de faire des opérations de tracé pour éviter le scintillement.
- `void os_redraw();`
  signale à l’OS Numworks qu’il doit retracer l’écran en entier

Le système de fichiers.

- `bool file_exists(const char * filename);`
- `bool erase_file(const char * filename);`
- `const char * read_file(const char * filename);`
- `bool write_file(const char * filename,const char * s,size_t len=0);`
- `int os_filebrowser(const char ** filenames,int maxrecords,const char * extension);`
  Place dans `filenames` la liste des noms de fichiers d’extension `extension`

Gestion du temps

- `void os_wait_1ms(int ms);`
  attend `ms` millisecondes.
- `double millis();`
  renvoie un nombre de millisecondes depuis le dernier démarrage. Attention, l’horloge système ne tourne pas à la bonne vitesse lorsque la calculatrice est éteinte, il n’est donc pas possible de s’en servir pour afficher l’heure.

### 19.5 Commandes graphiques complémentaires

- `void xcas::draw_line(int x1, int y1, int x2, int y2, int color);`
  segment de droite
- `void xcas::draw_rectangle(int x, int y, int width, int height, int color);`
  rectangle rempli
- `void xcas::draw_polygon(std::vector< std::vector<int> > & v1,int color)`
  polygone de sommets dans la matrice de n n lignes `v`, une ligne par sommet, chaque ligne est un vecteur de 2 entiers (coordonnées en pixels).
- `void xcas::draw_filled_polygon(std::vector< std::vector<int> > &L,int xmin,int xmax,int ymin,int ymax,int color);`
  polygone de sommets dans la matrice de n n lignes `v`, une ligne par sommet, chaque ligne est un vecteur de 2 entiers (coordonnées en pixels). Le polygone rempli est tracé avec “clipping” dans le rectangle défini par `x1,y1,x2,y2`.
- `void xcas::draw_circle(int xc,int yc,int r,int color);`
  cercle de centre `(xc,yc)` et rayon `r`
- `void xcas::draw_filled_circle(int xc,int yc,int r,int color);`
  disque de centre `(xc,yc)` et rayon `r`
- `void xcas::draw_arc(int xc,int yc,int rx,int ry,int color,double theta1, double theta2);`
  arc d’ellipse.
- `void xcas::draw_filled_arc(int x,int y,int rx,int ry,int theta1_deg,int theta2_deg,int color,int xmin,int xmax,int ymin,int ymax,bool segment);`
  arc d’ellipse rempli, ou segment de cercle rempli avec clipping.

### 19.6 Interaction avec l’UI Khicas

Certaines fonctions utilisent un pointeur vers le contexte du moteur de calcul (qui contient les variables assignées, le mode radian/degré, etc.), de type `giac::context *`, et dont la valeur est en général stockée dans la variable `contextptr` dans les fonctions d’interface de Khicas de `kdisplay.cc` (on peut aussi passer un pointeur nul).

- `int inputline(const char * msg1,const char * msg2,std::string & s,bool numeric,int ypos=65,const giac::context *contextptr=0);` permet d’entrer une chaine de caractères en affichant le message `msg1` et en préremplissant la chaine à entrer avec `msg2`. Seuls les caractères utilisables pour un nombre sont acceptés si `numeric` est `true`. La position verticale de la ligne de commande est ajustable en changeant la valeur de `ypos`. Renvoie 0 si l’utilisateur a annulé en tapant sur Back.
- `bool inputdouble(const char * msg1,double & d,const giac::context *contextptr)`
  permet d’entrer un nombre flottant en affichant le message `msg1`, renvoir `false` si l’utilisateur a annulé en tapant sur Back. `int select_item(const char ** ptr,const char * title);`
  affiche un menu à choix et renvoie le choix de l’utilisateur.
- `int confirm(const char * msg1,const char * msg2,bool acexit=false,int y=40);`
  affiche une boite de dialogue de type OK/Annuler, avec 2 lignes d’affichage. Si `acexit` est `true`, l’appui sur Back renvoie -1. Sinon, l’appui sur Back renvoie l’entier `KEY_CTRL_F6`. L’appui sur `OK` ou `EXE` renvoie l’entier `KEY_CTRL_F1`.
- `int giac_filebrowser(char * filename,const char * extension,const char * title);`
  affiche un menu de sélection parmi les fichiers dont l’extension est `extension`. Si l’utilisateur sélectionne un fichier, renvoie 1 et met le nom de fichier dans `filename`, qui doit avoir une taille suffisante.
- `void displaygraph(const giac::gen & ge, const giac::context * contextptr);`
  affiche un `gen` de type graphique (si `ge.is_symb_of_sommet(at_pnt)`)
- `void displaylogo();`
  affiche la tortue logo
- `giac::gen eqw(const giac::gen & ge,bool editable,const giac::context * contextptr);`
  affiche une expression dans l’éditeur 2d.
- `void add(textArea *edptr,const std::string & s);`
  écrit la chaine C++ `s` vers le buffer texte pointé par `edptr` (dans `edptr->elements`)
- `int doTextArea(textArea* text,const giac::context * contextptr);`
  ouvre l’éditeur de texte, renvoie 0 si l’utilisateur quitte avec la touche Back, 1 si `text->allowEXE` est à `true` et si l’utilisateur appuie sur `EXE`, 2 si `text->allowF1` est à `true` et l’utilisateur appuie sur F1.
- `std::string merge_area(const std::vector<textElement> & v);`
  renvoie la chaine C++ correspondant à `v`, si `edptr` est un pointeur sur `textArea`, on prendra pour `v` `edptr->elements`.

L’internationalisation est gérée par la commande
`const char * gettext(const char *)`
Pour ajouter une chaine en plusieurs langues, par exemple Hello, mettez dans votre code `gettext("Hello")`, et ajoutez au fichier `numworks_translate.h`, dans l’ordre alphabétique une ligne du type
`{"Hello",0,0/* zt */,"Bonjour" /* fr */,"Guten Tag" /* de */,0 /* es */,0 /* nl */,0 /* pt */,0},`
Attention, l’utilisation du fichier `numworks_translate.h` ne peut se faire qu’avec du code GPL qui est linké avec KhiCAS (mais rien ne vous empêche d’utiliser `gettext` dans un programme compatible avec la GPL avec un autre fichier de traductions en repartant de zéro).

### 19.7 Interaction avec giac

Le type `giac::gen` permet de travailler avec tous les types de Xcas : entier, flottant, fraction, nom de variable, expression, fonction... On peut construire un gen avec les types de base C

    gen g(1.2),h(3);

ou avec l’interpréteur (avec une chaine de caractères), dans ce dernier cas il faut évaluer le gen avec un appel à `eval`, par exemple

    gen g("x^4-1",contextptr);
    g=eval(g,1,contextptr);

En général une fonction de Xcas a un équivalent C++ avec le même nom précédé par `_`, et deux arguments, un de type `giac::gen` et un deuxième qui est un pointeur sur le contexte d’évaluation. Lorsqu’une commande Xcas prend plusieurs arguments, il faut les grouper en un gen de type vecteur, en utilisant une commande `makesequence`. Par exemple `_randNorm(makesequence(0.0,2.0),contextptr)` équivaut à la commande `randNorm(0.0,2.0)` de Xcas. Notez que les fonctions usuelles n’ont pas de préfixe `_`.

### 19.8 Sauvegardes et restauration

Il est possible de sauvegarder l’ensemble des données de votre calculatrice en local sur votre PC, i.e. sans connexion Internet. Pour cela, il faut avoir installé `dfu-util`, cf. la section 2. Il faut ensuite récupérer les informations sur la calculatrice avec la commande
`dfu-util -i0 -a0 -s 0x080001c4:0x20 -U platform.info`
ce qui place dans le fichier binaire `platform.info` (de taille 32 octets) des informations sur la Numworks (cf. `ion/src/shared/platform_info.cpp`)

- offset 0 0xDEC00DF0
- offset 4 la version (8 caractères)
- offset 12 le numéro de patch (8 caractères)
- offset 20 (0x14) l’adresse A de l’espace de stockage de la Numworks
- offset 24 (0x18) la taille T de l’espace de stockage
- offset 28 (0x1C) 0xDEC00DF0

Ensuite en remplaçant A et T par leur valeur dans la commande
`dfu-util -i0 -a0 -s A:T:force -U numworks.storage`
vous pouvez archiver l’ensemble des données de votre calculatrice dans le fichier `numworks.storage`. Avec Delta, A devrait valoir `0x20000b60`, et T `0x8014` (dont 4 octets valant `0xEE0BDDBA` puis 32K de data puis à nouveau les 4 octets du début, et 3 pointeurs) ce qui donne la commande
`rm -f numworks.storage &&dfu-util -i0 -a0 -s 0x20000b60:0x8014:force -U numworks.storage`

Vous pourrez ensuite restaurer l’archive par la commande
`dfu-util -i0 -a0 -s A:T:force -D numworks.storage`
avec Delta
`dfu-util -i0 -a0 -s 0x20000b60:0x8014:force -D numworks.storage`

## 20 Quelques mots sur les calculatrices

La calculatrice est devenue incontournable dans les enseignements de mathématique au lycée, avec trop souvent une utilisation presse-boutons, alors qu’elle est sous-utilisée dans les études scientifiques, partiellement en réaction. De ce fait, les constructeurs mettent l’accent sur le développement de fonctionnalités pour le lycée, en faisant apprendre des séquences de touches à effectuer pour certaines taches bien précises, plutot qu’une méthode plus générale, un peu moins conviviale pour ces taches, mais plus adaptable. C’est par exemple ce qu’on retrouve dans la philosophie des applications de Numworks, si on veut effectuer une tache pour laquelle elles sont prévues, c’est facile et en général intuitif, mais il devient vite difficile de faire quelque chose qui n’est pas prévu (par exemple simuler des données avec un programme et les utiliser dans une des applis de statistiques, représenter graphiquement une fonction définie par un programme, utiliser dans Calculs ou dans Python certaines fonctions des applications probabilité ou statistiques, ...).

Je pense que ce n’est pas adapté pour les élèves qui doivent pouvoir expérimenter des choses que le constructeur n’a pas implémenté parce que cela ne correspond pas aux programmes (c’est particulièrement vrai pour les bons élèves si on ne veut pas qu’ils s’ennuient!). À court terme, c’est plus facile pour enseigner d’utiliser une application comme Fonctions, mais à long terme, c’est plus formateur pour de futurs étudiants (au moins en sciences et en maths) d’apprendre à utiliser un shell puissant en y tapant des commandes. Bien sur, les deux approches doivent se complèter. Or les élèves sont souvent tributaires du choix de modèle demandé par leur enseignant de seconde, ils n’ont pas encore de recul pour choisir un autre modèle que celui demandé par l’enseignant et comprendre toutes les conséquences du choix, en particulier si la calculatrice ne permet pas d’y utiliser un shell puissant. Il est donc important de pouvoir proposer pour le plus possible de modèles populaires une alternative à la calculatrice officielle, permettant aussi aux bons élèves d’exploiter toutes les possibilités de leur calculatrice et de favoriser leur curiosité.

Pour moi, une calculatrice qui fait aimer les maths, c’est une calculatrice qui va donner envie à un élève d’expérimenter sur sa calculatrice des questions en prolongement du programme scolaire. À coté d’applications intuitives, il faut un espace de liberté qui ne soit pas limité aux quelques fonctionnalités d’une interface d’application. C’est le sens de χ\chiCAS, pour Numworks ici, disponible également pour d’autres modèles (Casio Graph 90/35eii, TI Nspire).

1
  sous Linux, vérifiez que dfu-util est bien installé et que le fichier 50-numworks-calculator.rules a été copié dans `/etc/udev/rules.d`

Retour à la page principale de Giac/Xcas.