χ\chiCAS pour Numworks N0110

Bernard.Parisse@ujf-grenoble.fr

2019, 2020

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, avec pour seules limites la mémoire disponible (malheureusement très faible) 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 18 qui s’adresse uniquement aux programmeurs qui souhaitent programmer leur calculatrice en C ou C++.

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

2  Installation

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.

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.

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

  1. Méthode très simple, mais nécessite une connexion Internet et 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.
  2. Méthode ne nécessitant pas de connexion Internet une fois les téléchargements effectués
    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
        Récupérez ce fichier et copiez le dans /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.

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 12. Pour passer à Xcas (respectivement Python), tapez xcas (respectivement python) dans une ligne de commande vide.

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 :

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 :

4  Commandes usuelles de calcul formel

4.1  Développer et factoriser

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

4.2  Analyse

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

4.3  Résoudre

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

4.4  Arithmétique

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

4.4.1  Entiers

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

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

4.4.2  Polynômes

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

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

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

4.5  Algèbre linéaire, vecteurs, matrices

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

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

onload

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

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

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

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

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



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

5  Probabilités et statistiques

5.1  Tirages aléatoires

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

5.2  Lois de probabilités

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

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

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

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

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.

5.4  Statistiques descriptives 2-d, régressions.

Voir aussi la section 14 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.

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

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

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 :

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

8  Unités et constantes physiques.

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

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

9  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 x0sin(x)x\lim_{x \rightarrow 0} \frac{\sin(x)}{x} Depuis une ligne de commande vide, taper shift-5 (2d), vous devez voir 0 sélectionné. Tapez sur la touche x et 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 +1x 4+1dx\int_0^{+\infty} \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir 0 10dx\int_0^1 0 \ dx avec xx sélectionné. Il faut donc changer le 1 de la borne supérieure et le 0 à intégrer. Pour modifier le 0, curseur vers la gauche pour le sélectionner puis 1/(x^4+1) 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 1x 4+1dx\int \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir 0 10dx\int_0^1 0 \ dx Déplacez le curseur sur le 0 de la borne inférieure de l’intégrale et tapez sur la touche DEL, vous devez voir 0dx\int 0 \ dx avec le tout sélectionné. Utilisez le curseur vers le bas pour sélectionner 0 et tapez 1/(x^4+1) 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).

10  Sessions de calculs

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

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

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

11.1  Prise en main (programmation)

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

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


puis on teste

Autre exemple : avec la tortue de Xcas
La tortue de Xcas est un petit robot qui se déplace selon des ordres qui lui sont donnés en laissant une trace de son passage. Les commandes de la tortue sont accessibles depuis le dernier item du menu Toolbox, par le raccourci Toolbox x 2x^2. Saisir la commande avance dans ce menu puis valider, vous devez voir la tortue (symbolisée par un triangle) avancer de 10 pixels. Taper 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)

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 à nn 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
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 nn pixels, en utilisant une fonction d’argument nn 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

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

11.2  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 :

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

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

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

12.1  Les modules standard : math, cmath, random

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

12.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 . Ce module a des synonymes, kandinsky et casioplot afin de faciliter l’utilisation de scripts Python pour calculatrices Numworks (Epsilon) et Casio.

12.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 0.

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

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

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

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

14  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 aa ou deux entiers aa et bb en arguments pour créer la liste des entiers entre 0 et a1a-1 ou entre aa et b1b-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)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.

15  Raccourcis claviers.

Dans l’éditeur de programmes :

16  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 :

17  Copyright, licences et remerciements

18  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 (18.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.

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

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

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.

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

18.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 18.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 :

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.

18.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 :

Les affichages.
Notez que y=0y=0 correspond à la première ligne en-dessous de la ligne d’état (18 pixels de hauteur), on a donc 0y<2220 \leq y&lt;222 et 0x<3200\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);
}

Le système de fichiers.

Gestion du temps

18.5  Commandes graphiques complémentaires

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

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

18.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 _.

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

Ensuite en remplaçant A et T par leur valeur dans la commande
dfu-util -i0 -a0 -s A:T -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).

Vous pourrez ensuite restaurer l’archive par la commande
dfu-util -i0 -a0 -s A:T -D numworks.storage

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

  

Retour à la page principale de Giac/Xcas.