% Merci a Yannick Chevallier pour la version mathjax-enabled
\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{amsmath,amsfonts,amssymb}
\usepackage{listings}
\usepackage[francais]{babel}
\usepackage{times}
\usepackage{xspace}
\usepackage{makeidx}
\usepackage{ifpdf}
\ifpdf
 \usepackage[colorlinks,pdftex]{hyperref}
\else
 \usepackage[ps2pdf,breaklinks=true,colorlinks=true,linkcolor=red,citecolor=green]{hyperref}
\fi
\newcommand{\bs}{\symbol{92}}
\newtheorem{thm}{Th\'eor\`eme}
\newtheorem{prop}[thm]{Proposition}
\newtheorem{defn}[thm]{D\'efinition}
\makeindex

% \renewcommand{\cuttingunit}{subsection} (add HEVEA after % for hacha)
\input{giacfr.tex}
\ifhevea
\(
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\newcommand{\Q}{{\mathbb{Q}}}
\newcommand{\tr}{\mbox{tr\,}}
\)
\else
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\newcommand{\Q}{{\mathbb{Q}}}
\newcommand{\tr}{\mbox{tr\,}}
\fi
%HEVEA\htmlfoot{Retour \`a la page principale de \ahref{http://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/giac_fr.html}{Giac/Xcas}.}
\giacmathjax
%HEVEA\renewcommand{\footertext}{}

\begin{document}
\title{$\chi$CAS pour Numworks N0110, N0115, N0120}
\author{Bernard.Parisse@univ-grenoble-alpes.fr}
\date{Novembre 2022, avril 2024}

\begin{giacjshere}

\maketitle

{\bf Du calcul formel pour tous!}\\
Le calcul formel est autorisé aux examens en France.
Un élève équipé d'une calculatrice haut de gamme (TI Nspire CX2 CAS,
HP Prime, Casio Classpad) peut s'en servir par exemple au bac.
KhiCAS donne accès au calcul formel sur les calculatrices graphiques
milieu de gamme Numworks et Casio Graph (90e et 35eii), mais pas
en mode examen. Les constructeurs de calculatrices empêchent cela 
pour diverses raisons~: soit parce que cela fait concurrence à leur
modèle haut de gamme qui rapporte plus, soit parce qu'ils craignent ou
prétextent craindre être interdits aux examens dans certains pays. 
Ceci engendre une inégalité entre les élèves modestes et ceux plus fortunés
qui peuvent se payer une calculatrice haut de gamme.
Numworks ou Casio pourrait
très bien authentifier KhiCAS et le laisser accessible 
en mode examen en France. J'ai contacté à plusieurs reprises Casio et Numworks
à ce sujet mais sans rien obtenir. Chers lecteurs, vous êtes nombreux
à consulter ce document (environ 10 000 consultations par an), alors si vous 
vous mobilisez pour que cela change, nous pouvons être entendus. Contactez
Numworks et demandez-leur de rendre KhiCAS utilisable en mode examen
en France!
Faites-le maintenant!

\tableofcontents


%% Pour \'echanger des fichiers, vous pouvez utiliser
%% \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{ce
%% kit de connexion Numworks} ou
%%  une version \`a jour de 
%% \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/install_fr.html}{Xcas}
%% (1.7.0-31 au moins) qui permet dor\'enavant d'\'echanger des programmes
%% entre la calculatrice et votre ordinateur.

%% Si vous trouvez cette \'evolution d\'esastreuse,
%% je vous invite \`a contacter Numworks et leur faire part de votre opinion.
%% Diffusez l'information aux personnes susceptibles de faire une
%% mise \`a jour, par exemple \`a vos camarades de lyc\'ee ou \`a vos
%% \'el\`eves si vous \^etes profs.
%% Prenez garde si vous vous connectez sur le workshop
%% de Numworks, le site vous propose cette mise \`a jour 
%% sans vous avertir que cela bloque $\chi$CAS .

%\printindex

\section{Introduction}
Ce document explique comment prendre en main et utiliser efficacement
sur calculatrices Numworks N0110, N0115 et N0120
le syst\`eme de calcul formel $\chi$CAS, une version adapt\'ee
du \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/giac_fr.html}{logiciel Xcas} pour cette calculatrice.
$\chi$CAS permet de transformer votre calculatrice graphique
en calculatrice graphique formelle (CAS) pour faire du
calcul litt\'eral (d\'evelopper, factoriser, calculer
une limite, une d\'eriv\'ee, une primitive, r\'esoudre
des \'equations, faire du calcul
matriciel exact ou approch\'e, ...) et ajoute
aussi des fonctionnalit\'es
pour les \'el\`eves qui envisagent une poursuite d'\'etudes
en sciences ou en maths~: 
grande varit\'et\'e de
repr\'esentations graphiques (champ de tangentes et solution
d'une \'equation diff\'erentielle, lignes de niveau, graphes 3d
cf. l'appendice \ref{sec:geo3d}),
g\'eom\'etrie analytique (2d et 3d), arithm\'etique et cryptographie
(corps finis premiers et extensions, polyn\^omes, etc.), alg\`ebre,
alg\`ebre lin\'eaire, analyse num\'erique, calcul flottant
multi-pr\'ecision et certifi\'e (arithm\'etique d'intervalle), etc.

$\chi$CAS propose aussi une application tableur et une 
application de g\'eom\'etrie interactive (2d/3d), qui permet
de combler l'absence de ces fonctionnalit\'es dans le syst\`eme
Epsilon fourni par Numworks. Enfin, un interpr\'eteur MicroPython
est maintenant inclus dans $\chi$CAS pour les programmes qui n\'ecessitent
une compatibilit\'e stricte avec Python que le mode de compatibilit\'e
de Xcas n'apporte pas. Ce MicroPython est plus
complet que celui de Numworks, il comprend 
un module permettant de faire du calcul formel,
un module d'arithm\'etique (test de primalit\'e, PGCD, identit\'e de
B\'ezout),
deux modules pour faire du calcul vectoriel et matriciel
et trouver des racines de polynome et un module graphique
plus complet (polygones, cercles, formes remplies).

Toutes les fonctionnalit\'es de $\chi$CAS sont
int\'egr\'ees, on peut repr\'esenter sur un m\^eme graphique
un histogramme et un graphe de fonction et une droite, on peut \'ecrire
un programme pour faire une simulation et repr\'esenter
les r\'esultats graphiquement, ou utiliser les fonctions
math\'ematiques dans un programme en syntaxe Python ou utiliser
un programme en syntaxe Python dans le tableur.

La philosophie de $\chi$CAS est tr\`es \'eloign\'ee de celle
du syst\`eme Epsilon de la Numworks qui a des applications
cibl\'ees, faciles \`a utiliser,
mais aux fonctionnalit\'es math\'ematiques plus limit\'ees
et qui communiquent peu entre elles.
Ici, on passera un peu de temps \`a apprendre
comment utiliser le shell et les outils d'\'edition pour
ensuite les faire travailler harmonieusement ensemble, sans autres
limites que la m\'emoire (malheureusement vite remplie) et la vitesse
de la Numworks (tout \`a fait raisonnable pour une calculatrice).
Il est donc fortement recommand\'e de lire cette documentation pour une
utilisation optimale de $\chi$cas, \`a l'exception
de la section \ref{sec:dev} 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\'esultat de l'ex\'ecution des commandes
propos\'ees en exemple en cliquant sur le bouton \framebox{exe} (ou en
validant avec la touche Entr\'ee).


\section{Installation} \label{sec:install}
Il existe deux versions de KhiCAS, une pour les Numworks
N0110 d'avant 2021 et qui n'ont pas été mises à jour (Epsilon 15.5 au plus),
ce sont les N0110 non verrouillées (ou déverrouillées), et
une version de KhiCAS pour les autres modèles.
Le numéro de votre modèle est inscrit à l'arrière
de votre calculatrice et le numéro de version d'Epsilon
se lit dans l'applications Paramètre, A propos.

En effet, afin de satisfaire certaines réglementations d'examens
à l'étranger, depuis 2021, Numworks verrouille ses calculatrices, ce qui rend
les applications développées par des auteurs indépendants de Numworks
nettement moins intéressantes~:
elles sont plus difficiles à installer, doivent être
réinstallées après un crash/RESET et
elles ne sont pas utilisables en mode examen.
{\bf Donc si vous possédez une Numworks N0110
  avec une version d'Epsilon
inférieure à 16, pour conserver votre liberté,
ne mettez pas \`a jour votre calculatrice sur le site de
Numworks.}.
Si vous avez mis \`a jour vers Epsilon en
version 16 ou plus ou si votre calculatrice est d\'ej\`a
en version 16 ou plus, des failles logicielles trouv\'ees par la
communaut\'e permettent dans certains cas de
\ahref{https://tiplanet.org/forum/viewtopic.php?f=113&t=25784}
{d\'everrouiller votre calculatrice}.
Si vous achetez une calculatrice Numworks d'occasion, 
demandez au vendeur si le num\'ero
de version du logiciel est au plus 15.5. 
Les versions r\'ecentes de Khi/KhiCAS ajoutent
une protection contre une mise \`a jour non intentionnelle.

\subsection{Numworks N0110 verrouillée, N0115, N0120}
\label{sec:n120}
Si votre calculatrice est un modèle récent, 
vous pouvez installer une version
de $\chi$CAS depuis la 
\ahref{https://xcas.univ-grenoble-alpes.fr/nw/nws.html}{page Numworks du site de Xcas} 
en utilisant un navigateur webUSB compatible (Chromium, Chrome, Edge...).
Il existe deux sous-versions~: la version courte occupe presque
la moitié de l'espace flash de la calculatrice, la version longue
environ les deux tiers, la différence est que la version courte
ne contient pas l'aide complète en ligne dans plusieurs langues,
mais uniquement l'aide sur les principales commandes en français
et en anglais.
Attention, cette version de $\chi$CAS n'est pas accessible en mode
examen, alors que la réglementation française autorise le calcul
formel aux examens, ce qui défavorise les élèves qui ne peuvent
pas se payer une calculatrice CAS constructeur, environ
deux fois plus chère. De plus l'application est désactivée 
en cas de crash ou de reset, il faut
alors réinstaller avec un ordinateur le lanceur de KhiCAS, ce qui 
peut engendrer une usure prématurée du secteur correspondant
de la mémoire flash. Numworks
est au courant de ces problèmes, mais n'a donné à ce jour aucune
date pour une amélioration.

{\bf Remarque essentielle}\\ 
La prise en compte du clavier est un
peu différente sur cette version de $\chi$CAS. L'appui sur la 
touche HOME de la calculatrice fait sortir immédiatement de $\chi$CAS
pour revenir au menu principal de la Numworks.
Il faut taper sur les touches shift puis EXE pour
ouvrir le menu ``fichier'' de KhiCAS (au lieu de HOME
sur les N0110 non verrouillées).

Notez que pour insérer un caractère non présent sur le clavier, vous 
pouvez taper sur shift puis \verb|*| qui ouvre la table
de caractères ASCII. La touche shift suivie de \verb|+|
renvoie le caractère de tabulation, qui permet d'indenter
dans un programme, ou d'afficher de l'aide.

\subsection{Numworks N0110 non verrouillée avec Epsilon au plus 15.5}
{\bf Attention, certains concours ou examens interdisent l'utilisation
de calculatrices formelles. Il est de la responsabilit\'e de l'utilisateur
de v\'erifier que les calculatrices formelles sont autoris\'ees
avant d'utiliser $\chi$CAS dans un examen ou concours. Les auteurs
ne sauraient \^etre tenus pour responsables en cas d'utilisation
non autoris\'ee.}

%% Il est donc n\'ecessaire
%% de compiler soi-m\^eme une version modifi\'ee de Epsilon 
%% (le firmware de la Numworks) et de compiler Giac pour produire
%% un firmware (qu'on ne peut pas diffuser publiquement). 
%% Damien Nicolet a automatis\'e la proc\'edure avec le logiciel Docker, on peut
%% l'installer 
%% \begin{itemize}
%% \item sous Linux debian compatible
%% avec la commande \\
%% \verb|sudo apt-get install docker.io|
%% \item sur Mac, installer \ahref{https://brew.sh/}{brew} puis
%% ex\'ecuter la commande\\
%% \verb|brew install docker|
%% \item sous Windows, je ne sais pas si c'est possible,
%%   voir le site de \ahref{https://docs.docker.com/docker-for-windows/install/}{Docker}
%% \end{itemize}
%% Connecter la calculatrice puis ex\'ecuter la commande~:\\
%% \verb|docker run -it --rm --privileged zardam/epsilon-builder https://github.com/zardam/epsilon.git n110-giac|\\
%% pour plus d'informations, voir le fil de
%% \ahref{https://tiplanet.org/forum/viewtopic.php?f=97&t=22980}{TI planet}

%% Une fois la compilation et le transfert termin\'es, d\'ebranchez
%% la calculatrice, elle reboote alors et une nouvelle icone (avec le flocon
%% de Xcas) apparait dans le menu principal. J'ai du enlever
%% l'application r\'egressions, car elle prend trop de place en m\'emoire
%% vive. La section \ref{sec:stat2d} explique comment faire des r\'egressions
%% avec Khicas.

%% {\bf Remarque~: je suis le premier \`a regretter 
%% devoir imposer cette manipulation compliqu\'ee.} 
%% J'ai pourtant tout fait de mon cot\'e pour que la licence libre de Giac
%% ne soit pas un obstacle \`a une diffusion sous forme de firmware compil\'e.
%% Mais contrairement
%% \`a la licence GPL qui permet de lier du code libre avec un OS propri\'etaire,
%% la licence de l'OS de la Numworks est incompatible avec toute
%% autre licence.
%% Malgr\'e mon insistance, 
%% Numworks n'a pour l'instant pas r\'epondu \`a ma demande d'autorisation
%% de lier du code sous licence GPL avec les fonctions de base de leur OS.
%% Le m\^eme raisonnement s'applique \`a tout logiciel libre, on peut donc
%% dire que
%% {\bf contrairement aux d\'eclarations d'ouverture de la soci\'et\'e, 
%% la Numworks est encore un syst\`eme ferm\'e, 
%% plus que Casio par exemple.}

Avant d'installer ou mettre \`a jour $\chi$CAS, pensez \`a sauvegarder
vos donn\'ees, car elles pourraient \^etre effac\'ees. 
{\em Si vous faites une mise \`a jour, il pourra \^etre n\'ecessaire de faire
reset+4 sur votre calculatrice pour acc\'eder \`a la flash
(i.e. appuyer sur la touche 4, puis enfoncer une pointe \`a
l'arri\`ere sur reset, relacher la touche 4).}
Puis choisir une des m\'ethodes~:
\begin{enumerate}
\item {\bf Via Internet avec un navigateur compatible avec webUSB}\\
Cliquez sur \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{ce lien}
en utilisant un navigateur supportant web USB tel que Chromium ou Edge ou Google Chrome.
Connectez la calculatrice et cliquez sur le bouton Installer
ou mettre \`a jour KhiCAS.
\item {\bf Depuis Xcas} (Windows et Linux)\\
C'est une m\'ethode d'installation locale (une fois Xcas install\'e)\footnote{sous Linux,
v\'erifiez que
\ahref{http://dfu-util.sourceforge.net/}{dfu-util} 
est bien install\'e et que le fichier
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/50-numworks-calculator.rules}{\tt
  50-numworks-calculator.rules} a \'et\'e copi\'e dans  \verb|/etc/udev/rules.d|}.\\
Connecter la calculatrice, ouvrez Xcas, puis dans le menu Fich,
sous-menu Numworks, s\'electionner \verb|Installer KhiCAS sur la
calculatrice|. Lorsqu'on vous demande de faire un reset de la
calculatrice, appuyez sur le bouton
\verb|RESET| \`a l'arri\`ere de la calculatrice.
\item Depuis le site d'\ahref{https://getupsilon.web.app/}{Upsilon}
  ou d'\ahref{https://getomega.dev/}{Omega},
  suivre les instructions
  de ces sites et installer KhiCAS comme application externe. Notez
  que le support du clavier depuis KhiCAS est moins bien optimisé
  qu'avec les autres méthodes d'installation décrites ici. Par contre
  les bootloader d'Upsilon et Omega ont du support pour lancer
  des versions plus récentes du système d'exploitation Epsilon de Numworks.
\item
{\bf Installation manuelle}\\
Pour installer ou mettre \`a jour $\chi$CAS sur votre 
Numworks N0110~:
r\'ecup\'erez sur votre ordinateur le fichier
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/khi.zip}{khi.zip}.
\begin{itemize}
\item Si n\'ecessaire, installez dfu-util
  \begin{itemize}
  \item sur Mac, installez \ahref{https://brew.sh/}{brew} si n\'ecessaire puis
depuis un Terminal (dans Utilitaires) faire\\
    \verb|brew install dfu-util|
  \item sous Linux debian compatible, ouvrir un Terminal et faire\\
  \verb|sudo apt-get install dfu-util|\\
Vous pouvez aussi compilez et installer \`a partir du \ahref{http://dfu-util.sourceforge.net/}{source}.\\
  R\'ecup\'erez 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/50-numworks-calculator.rules}{ce fichier} et copiez le
  dans \verb|/etc/udev/rules.d|. Si vous avez install\'e un package
  debian, cela peut se faire par la commande\\
\verb|sudo cp /usr/share/giac/doc/50-numworks-calculator.rules /etc/udev/rules.d|
Vous pouvez aussi cr\'eer un fichier
\verb|/etc/udev/rules.d/50-numworks-calculator.rules|  de contenu~:
\begin{verbatim}
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="a291", TAG+="uaccess"
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="df11", TAG+="uaccess"
\end{verbatim}
\item sous Windows, t\'el\'echargez et installez la version
  \ahref{http://dfu-util.sourceforge.net/releases/dfu-util-0.9-win64.zip}{64 bits}
  ou \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/dfu-win32.zip}{32 bits}
  (\ahref{http://dfu-util.sourceforge.net/releases/}{provenance}).
  L'ex\'ecutable s'appelle \verb|dfu-util-static.exe|.
  Si n\'ecessaire \'editez le fichier \verb|updaten110.bat| (64 bits)
  ou \verb|updaten110_32.bat| (32 bits)
  pour adapter les chemins d'installation. Le fichier actuel
  suppose que l'on a desarchiv\'e \verb|khi.zip|
  et \verb|dfu-util-0.9-win64.zip| depuis le m\^eme r\'epertoire racine
  (par exemple \verb|c:\temp|)
  et qu'on lance \verb|updaten110.bat| (64 bits)
  ou \verb|updaten110_32.bat| (32 bits) en cliquant sur le fichier
  dans l'explorateur de fichiers. 
  \end{itemize}
\item Tapez la commande \verb|./updaten110| (Linux/Mac) ou
  ex\'ecutez \verb|updaten110.bat| (Windows 64 bits)
  ou \verb|updaten110_32.bat| (Windows 32 bits).
  Les commandes \verb|dfu-util| sont les suivantes
\begin{verbatim}
dfu-util -i 0 -a 0 -s 0x08000000 -D bootloader.bin -R
dfu-util -i 0 -a 0 -s 0x90000000 -D khi.A.bin -R
dfu-util -i 0 -a 0 -s 0x90180000 -D khi.B.bin -R
dfu-util -i 0 -a 0 -s 0x90200000:force -D apps.tar
\end{verbatim}
Vous pouvez ajouter des fichiers scripts Python ou sessions Xcas (ou
m\^eme des programmes) \`a
l'archive \verb|apps.tar|
avec la commande \verb|tar rvf apps.tar <filenames>|. Ils seront
alors visibles depuis $\chi$CAS hors mode examen (et l'ajout est
compatible avec la certification du firmware disponible depuis
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{le
kit de connexion Numworks}).
\end{itemize}
\end{enumerate}
Apr\`es installation, red\'emarrez la calculatrice par appui sur le
bouton RESET si n\'ecessaire. 

{\bf Multi-boot}\\
Si vous avez install\'e une version r\'ecente de $\chi$CAS, votre
calculatrice peut dor\'enavant lancer deux firmwares~:
\begin{itemize}
\item une version du logiciel du constructeur Numworks,
d\'eriv\'ee de la version 15.5 d'Epsilon (c'est la derni\`ere version
dont la licence permet les modifications et redistribution, qui date
de mai 2021). C'est le firmware du slot 1.
Il est techniquement possible d'installer Epsilon 18 dans ce slot 1,
mais ce n'est pas recommand\'e, car l'utilisation de $\chi$CAS
n'est pas possible depuis Epsilon 18, il faut alors rebooter pour le
lancer depuis le slot 2.
Vous pouvez consulter la section \ref{sec:eps18} pour
trouver l'\'equivalent dans $\chi$CAS des fonctionnalit\'es
math\'ematiques qui ont \'et\'e ajout\'ees dans Epsilon par
rapport \`a la version 15.5.
\item un mini-firmware lanceur. Il n'affiche aucune des applications
du constructeur \`a part les param\`etres, mais permet
de lancer $\chi$CAS (et d'autres
applications externes) avec plus de m\'emoire disponible. 
C'est le firmware du slot 2.
\end{itemize}
Pour v\'erifier l'\'etat des slots de votre calculatrice,
maintenez la touche 4 enfonc\'ee et en appuyant sur le
bouton RESET \`a l'arri\`ere, puis relachez la touche 4. Cela
lance le multi-boot et affiche le contenu des slots. Notez que le slot 3
est incompatible avec $\chi$CAS (il s'agit du slot B du multi-boot
$\varphi$).

Pour passer du slot 1 au slot 2, appuyez sur
la touche 1 ou 2, faites simultan\'ement RESET \`a l'arri\`ere,
puis relachez la touche 1 ou 2. 

{\bf Protection contre des sites potentiellement malveillants}\\
Si vous ne l'avez pas d\'ej\`a fait, mettez \`a jour $\chi$ et $\chi$CAS afin
de b\'en\'eficier d'un minimum de protection si vous naviguez
sur Internet avec votre calculatrice branch\'ee.
Une fois cela fait, en fonctionnement normal,
il est impossible \`a un site d'\'ecrire dans la
flash de la calculatrice. Vous ne pourrez modifier
la flash qu'en activant le multi-boot (par reset+4)
ou le mode de r\'ecup\'eration (reset+6). 
{\bf Soyez particuli\`erement vigilants avant de faire reset+4 ou
  reset+6}. En particulier, si vous voulez conserver le controle de 
votre calculatrice (\'eviter un verrouillage)
et la compatibilit\'e avec $\chi$CAS, ne faites jamais reset+4 ou reset+6 depuis les
sites de Numowrks m\^eme si on vous le demande. Si votre calculatrice est bloqu\'ee ou pour
\'echanger des scripts, rendez-vous sur 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{mon
  kit de connexion Numworks}.

{\bf Mode examen}\\
L'installation de $\chi$CAS et $\chi$ dans les slots 1 et 2 est
conforme \`a la r\'eglementation fran\c{c}aise du mode examen.
Un surveillant d'examen qui souhaite s'assurer qu'une calculatrice
Numworks n'a pas subi de modifications pour frauder peut le certifier
depuis \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{mon
  kit de connexion Numworks}.

{\bf Lancement de $\chi$CAS}\\
Tapez sur la touche Back puis Entree pour lancer $\chi$CAS.

{\bf Licences d'utilisation~}:\\
la licence choisie par Numworks
pour son syst\`eme d'exploitation rend impossible la publication
d'un firmware binaire unique contenant \'egalement un logiciel libre.
Le logiciel est donc d\'ecompos\'e en deux parties,
\verb|khi.*|, sous licence
\ahref{https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode}
      {Creative Commons Attribution-NonCommercial-
  ShareAlike 4.0 International Public License}
et \verb|apps.tar| sous
licence \ahref{https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html}{GPL2}.

\section{Premiers pas}
N.B.~: vous pouvez aussi consulter ce \ahref{https://github.com/Yaya-Cout/KhiCAS_guide/blob/626b9786ff19504152628cfa42447c87ab73f648/KhiCAS_guide.pdf}{Tutoriel par fmOOmf et Yaya.Cout}.

Depuis le menu principal de la Numworks, tapez la touche Back ou
d\'eplacez le curseur jusqu'\`a l'icone KhiCAS
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'\'evaluateur 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 \ref{sec:micropy}. Pour passer \`a Xcas
(respectivement Python), depuis une ligne de commande vide, taper les
touches \verb|shift ) 8 OK|. Attention
sur les Numworks N0115/N0120/N0110 verrouillées (section \ref{sec:n120}), 
il faut taper  les touches \verb|shift| et \verb|)| en même temps.

Pour revenir au menu principal de la Numworks,
il faut taper HOME, plusieurs fois sur les N0110 non verrouillées
(2 fois depuis le shell).
Sur les Numworks N0115/N0120/N0110 verrouillées (section \ref{sec:n120}), 
la touche HOME renvoie directement au menu principal de la Numworks,
pour simuler l'action de HOME des N0110 non verrouillées, il faut
taper les touches shift puis EXE.

Par exemple, tapez 
\verb|1/2+1/6|
puis EXE, vous devriez voir le r\'esultat \verb|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\'ecuter. Par exemple, taper sur la
touche curseur vers le haut, EXE et remplacez \verb|1/6| par \verb|1/3|.

Vous pouvez utiliser le r\'esultat de la derni\`ere commande
avec la touche \verb|Ans| de la calculatrice.
Il vaut en g\'en\'eral mieux d\'efinir une variable comme r\'esultat 
d'une commande si on souhaite la r\'eutiliser. Pour cela, on
utilise une des deux instructions d'affectation~:
\begin{itemize}
\item l'affectation vers la droite \verb|=>| s'obtient avec la 
touche \verb|sto|$\rightarrow$ de la 
calculatrice, par exemple \verb|2=>a| met 2 dans la variable a.
Vous pouvez ensuite utiliser \verb|a| dans un calcul, sa
valeur sera remplac\'ee par 2.
\item l'affectation vers la gauche \verb|=|.
Par exemple \verb|a=2| fait la m\^eme chose que \verb|2=>a|.
\end{itemize}
%% Si vous commencez une ligne de commande en tapant la touche $\rightarrow$,
%% le syst\`eme ins\'ere automatiquement \verb|Ans=>| ce qui permet 
%% facilement de donner un nom au r\'esultat d'une commande.

Pour vous aider \`a saisir les commandes Xcas les plus utiles,
$\chi$CAS dispose d'un catalogue d'une centaine de commandes,
avec une courte description et le plus souvent un exemple 
d'ex\'ecution facile \`a recopier. 
Appuyez sur 
la touche Toolbox, choisissez une cat\'egorie avec le curseur, 
par exemple \verb|Algebre|, tapez EXE,
puis choisissez une commande avec le curseur, par exemple \verb|factor|.
Un deuxi\`eme appui sur la
touche Toolbox vous affiche une courte description de la commande,
en g\'en\'eral 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\^ome que celui
donn\'e en exemple. Essayez avec \verb|factor| (touche Toolbox,
puis \verb|Algebre|).

Parmi ces commandes, celles qui sont le plus utilis\'ees sont accessibles
par des menus rapides activ\'es par la touche shift suivi d'un chiffre,
de \verb|.|, de {\tt 10^x}, de \verb|(| ou de \verb|)|, comme
le rappelle la ligne en bas de l'\'ecran, par exemple shift suivi
de 1 affiche un menu d'alg\`ebre o\`u on retrouve la commande
\verb|factor|. 

Lorsqu'une commande est entr\'ee 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\`eche 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 Back (\`a droite de OK) pour effacer le tooltip.

Lorsque vous ex\'ecutez une commande et qu'elle
renvoie une expression, celle-ci est affich\'ee
en \'ecriture naturelle (affichage 2-d). Vous pouvez faire d\'efiler 
l'affichage avec les touches du curseur lorsque l'expression est grande.
Tapez sur Back (\`a droite de OK) pour revenir au shell.

Maintenant essayez de taper la commande \verb|plot(sin(x))|.
Indication: tapez Toolboox, puis s\'electionner 
\verb|Courbes|, ou utilisez le menu rapide shift 3.

Lorsqu'une commande renvoie un graphe, celui-ci est affich\'e. Vous
pouvez modifier la fen\^etre graphique d'affichage 
avec les touches \verb|+| ou \verb|-| 
(zoom in ou out),
les touches du curseur, orthonormaliser le rep\`ere (touche \verb|/|)
ou faire une recherche automatique de l'\'echelle (autoscale 
touche \verb|*|). Pour enlever ou remettre les axes et graduations,
tapez sur var.
Tapez sur Back pour revenir au shell.

Vous pouvez effacer l'historique des calculs et les variables
pour commencer un nouvel exercice~: ouvrez le menu principal 
taper shift puis EXE (calculatrices récentes verrouillées) ou HOME,
s\'electionnez \verb|9 Effacer historique|.
Vous avez ensuite le choix entre
effacer l'\'ecran en conservant les variables
(OK) ou en les effa\c{c}ant (Back). Vous pouvez visualiser
la place occup\'ee par les variables en tapant sur la touche \verb|var|.
Pour effacer une variable pour faire de la place en m\'emoire,
s\'electionnez la commande \verb|purge| dans ce menu, puis
taper le nom de variable \`a effacer (ou s\'electionnez la variable
depuis le menu \verb|var|).

Pour quitter $\chi$CAS depuis le shell, appuyez sur la touche HOME une ou
2 fois. Lorsque vous lancez
une autre application, les variables et l'historique des calculs
sont sauvegard\'es, ils seront restaur\'es lorsque vous reviendrez
dans $\chi$CAS.

Remarques~:
\begin{itemize}
\item
  Depuis le shell de calcul, les touches 1 \`a 9, 0, \verb|.| et
  \verb|x10|$^x$, \verb|(|, \verb|)|
  pr\'ec\'ed\'ees de shift (ou en maintenant shift enfoncé selon
  la version de KhICAS) font apparaitre un
  petit menu pour saisir rapidement certaines commandes.
\item Lorsque le curseur est sur la ligne de commande juste apr\`es
  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. 
\item  Exemple~: tapez shift-2, puis 3 (integrate), fl\`eche vers
  le bas, puis Ans ou EXE\\
  Modifiez l'expression \`a int\'egrer selon vos besoin puis tapez EXE
\item Lorsqu'il reste peu de mémoire (affichage en haut lorsqu'on
  tape sur la touche var), on peut essayer de restaurer de la place en
  effaçant des variables avec la commande \verb|purge|
  (accessible depuis la touche \verb|var|). On peut aussi
  quitter KhiCAS et le relancer pour repartir d'une situation où la mémoire
  n'est pas fragmentée.
\end{itemize}

\section{Sauvegarde et \'echange de donn\'ees.}
Remarque~: Si votre session n'est pas trop grande, vous pouvez l'afficher
sous forme de QR code sur la calculatrice. Depuis le shell, 
ouvrir le menu Fichier (touches shift EXE ou touche
HOME selon la version de KhiCAS),
choisir Enregistrer session, mettre le cas échéant un nom de session. 
Le QR code
s'affiche, vous pouvez le scanner avec un smartphone et obtenir un
clone de votre session sur votre smartphone. Le QR code s'affiche
également si vous quittez KhiCAS depuis le menu principal (shift EXE ou HOME
deux fois de uite). 

Si vous 
disposez du cable adéquat, vous pouvez
connecter le smartphone à une autre Numworks et y recopier la session
(cf. section suivante). Si vous n'avez pas de cable adéquat, vous pouvez
appuyer avec le doigt sur l'icone d'enveloppe en haut et envoyer la
session par email, puis depuis un PC vous pourrez recopier la session
sur une autre calculatrice.

\subsection{Depuis un navigateur webusb (Chromium ou Chrome ...)}
\begin{itemize}
\item
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{Le
  kit de connexion Numworks} utilis\'ee avec un
navigateur compatible webusb, par exemple Chrome ou Chromium ou Edge,
permet d'\'echanger des donn\'ees
avec la calculatrice Numworks~: des scripts Python ou des backups.
On peut aussi installer $\chi$CAS, 
personnaliser le contenu de la m\'emoire flash de la calculatrice.
Pour les N0110 non verrouillées, on peut porter assistance \`a une
calculatrice bloqu\'ee et certifier que le firmware install\'e
sur une calculatrice est conforme \`a la r\'eglementation fran\c{c}aise.
\item
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/xcasfr.html}{La
  version web de Xcas} 
permet d'\'echanger des donn\'ees avec la calculatrice Numworks. 
Cliquez sur le bouton Détecter à gauche du bouton Numworks$\rightarrow$
pour détecter la calculatrice, ensuite
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
$\rightarrow$Numworks. \\
N.B.~: pour afficher un graphique sur la version web, taper sur une ligne 
vide \verb|,| ou \verb|.| ou \verb|;| selon le type de graphique
%En affichant la section Numworks de la documentation
%(depuis le bouton Doc) on a \'egalement acc\`es \`a la certification
%du firmware Delta+$\chi$CAS.
\end{itemize}

\subsection{Depuis Xcas pour Windows, Linux}
V\'erifiez que 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/install_fr.html}{Xcas}.
 est en version 1.7.0-31 ou ult\'erieure,
si n\'ecessaire installez ou mettez \`a jour.

Sous Linux, v\'erifiez que
\ahref{http://dfu-util.sourceforge.net/}{dfu-util} 
est bien install\'e et que le fichier
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/50-numworks-calculator.rules}{\tt
  50-numworks-calculator.rules} a \'et\'e copi\'e dans
\verb|/etc/udev/rules.d|. Si vous avez install\'e un package
  debian, cela peut se faire par la commande\\
\verb|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
\verb|Fich|, sous-menu \verb|Numworks|.
Vous pouvez~:
\begin{itemize}
\item ouvrir un programme de la calculatrice dans la session actuelle
  Xcas ou ouvrir une session $\chi$CAS Numworks
de la calculatrice dans un nouvel onglet de Xcas,
\item envoyer la session actuelle Xcas comme une session $\chi$CAS
sur votre calculatrice,
\item envoyer le programme de l'\'editeur de programme courant
sur votre calculatrice
\item cr\'eer une nouvelle session Xcas contenant tous les programmes
de votre calculatrice
\item effacer les programmes de votre calculatrice et les
remplacer par tous les programmes de la session Xcas actuelle 
\item faire une sauvegarde de votre calculatrice
\item restaurer votre calculatrice \`a partir d'une sauvegarde
\item installer $\chi$CAS sur une calculatrice (il suffit de le
  faire une fois pour toutes)
\item d\'ebloquer une calculatrice N0110. Ceci fonctionnera
sur toute calculatrice N0110 qui n'est pas verrouill\'ee par
une mise \`a jour faite sur le site de Numworks apr\`es septembre
2021. Cela utilise
le bootloader du fabricant du microprocesseur (ST) 
que l'on lance en maintenant la touche 6
de la calculatrice enfonc\'ee en appuyant sur RESET 
\`a l'arri\`ere de la calculatrice en m\^eme temps.
Ce sous-menu envoie un bootloader ``rescue mode'' dans la RAM de la
calculatrice et l'ex\'ecute, on peut ensuite installer Khi+$\chi$CAS (ou toute
autre version d\'eriv\'ee d'Epsilon $\leq 15$).
\item certifier que la version de Khi+$\chi$CAS de la
 calculatrice N0110 non verrouillée d'un \'el\`eve est identique \`a
celle fournie avec Xcas (et n'a donc pas \'et\'e
modifi\'ee et recompil\'ee en y ajoutant des donn\'ees
personnelles).
\end{itemize}
Sur Mac, il est recommand\'e d'utiliser le kit de connectivit\'e web
Numworks de la section pr\'ec\'edente.

\subsection{Gestion de la m\'emoire flash sur la calculatrice}
Depuis la version du 14 octobre 2021,
vous pouvez lancer un mini-gestionnaire de fichiers en flash 
depuis le menu Applications de KhiCAS
(touches shift Ans
puis valider puis avant-avant-dernier item). 
Ce gestionnaire permet
\begin{itemize}
\item de lister les fichiers install\'es en flash et d'afficher
des informations (dont la date de cr\'eation)
\item de copier un script depuis la RAM vers la flash (ce qui la
  pr\'eserve d'un effacement par un reset ou un crash de la
calculatrice). 
% La date de cr\'eation de ces fichiers apparait
% alors en unit\'e de temps mesur\'e par l'horloge RTC de la
% calculatrice depuis le dernier reset.
\item de modifier la visibilit\'e d'un fichier ou de le renommer.
Dans ce sous-menu, on valide les changements par OK ou EXE,
on les annule avec la touche Back.
\item d'effacer r\'eellement les fichiers marqu\'es comme
non visibles pour faire de la place (Vider la corbeille). 
\end{itemize}
Attention, si vous faites des modifications, cela \'ecrit
en flash, or on ne peut pas \'ecrire ind\'efiniment sur
le m\^eme secteur en flash (pour
la flash externe, Numworks a assigne une taille de 64K aux secteurs).
Pour augmenter la dur\'ee de vie de la m\'emoire flash,
il est conseill\'e de ne vider la corbeille
que lorsqu'il est vraiment n\'ecessaire de faire de la place. En effet,
si on ne vide pas la corbeille, les nouveaux fichiers ajout\'es en flash
vont progressivement \^etre \'ecrits dans de nouveaux secteurs, 
ce qui r\'epartira
mieux l'usure de la flash. (Un ``vrai'' syst\`eme de fichiers fait
normalement cela automatiquement). Si vous n'avez pas besoin de
beaucoup de place pour stocker des fichiers par rapport à la place
disponible (6*64K à 1M selon la version de KhiCAS), 
vous pouvez aussi ajouter un gros fichier inerte de taille
un multiple de 64K vers le d\'ebut de l'archive (\`a partir du fichier
d'indice 10 si vous voulez conserver la certification
sur les N0110 non verrouillées), que vous
changez de temps en temps.

Par ailleurs, lorsque vous lancez le mode examen sur les N0110 
non verrouillées utilisant Khi, 
l'\'etat de la calculatrice est
automatiquement sauvegard\'e dans le dernier secteur 
de la m\'emoire flash (sauf s'il
n'y a aucun script Python).
Plus tard, lorsque vous avez quitt\'e le mode examen (en branchant la
calculatrice), vous pouvez restaurer l'\'etat de la calculatrice
depuis le menu HOME, Configuration/mode examen.

\section{Commandes usuelles de calcul formel}

\subsection{D\'evelopper et factoriser}
Depuis le catalogue, s\'electionner le sous-menu \verb|Algebre|
(2) ou le menu rapide shift-1
\begin{itemize}
\item \verb|factor|~: factorisation. Raccourci clavier shift-*
  (pr\'efix\'e) ou \verb|=>*| (infix\'e touche sto puis *),
  par exemple \giacinputmath{x^4-1=>*}.
Utiliser \verb|cfactor| pour factoriser sur $\C$.
\item \verb|partfrac|~: d\'eveloppement d'un polyn\^ome ou
d\'ecomposition en \'el\'ements simples pour une fraction. Raccourci
clavier \verb|=>+| (touche sto puis +), 
par exemple \giacinputmath{ (x+1)^4=>+} 
ou \giacinputmath{1/(x^4-1)=>+}.
\item \verb|simplify|~: essai de simplifier une expression.
Raccourci clavier \verb|=>/| (touche $\rightarrow$ puis /), 
par exemple \giacinputmath{sin(3x)/sin(x)=>/}
Attention, cette commande est gourmande en m\'emoire, et la Numworks
en a peu, le risque de reset existe.
\item \verb|ratnormal|~: d\'evelopper une expression,
\'ecrire une fraction sous forme irr\'eductible.
\end{itemize}

\subsection{Analyse}
Depuis le catalogue (Toolbox), s\'electionner le sous-menu \verb|Analyse|
(4) ou le menu rapide shift-2
\begin{itemize}
\item \verb|diff|~: d\'erivation. On peut aussi utiliser la notation
\verb|'| (alpha-shift-") pour d\'eriver par rapport \`a $x$, ainsi
\giacinputmath{diff(sin(x),x)} et \giacinputmath{sin(x)'} sont \'equivalents.
Pour d\'eriver plusieurs fois, ajouter le nombre de d\'erivations
par exemple \giacinputmath{diff(sin(x^2),x,3)}.
\item \verb|integrate|~: primitive si 1 ou 2 arguments,
par exemple 
\giacinputmath{integrate(sin(x))} ou \giacinputmath{integrate(1/(t^4-1),t)}
pour $\int \frac{1}{t^4-1} \ dt $\\
Calcul d'int\'egrale d\'efinie si 4 arguments, par
exemple \giacinputmath{integrate(sin(x)^4,x,0,pi)}
pour $\int_0^\pi \sin(x)^4 \ dx$. Mettre une des bornes
d'int\'egration sous forme approch\'ee si on souhaite un calcul
approch\'e d'int\'egrale d\'efinie, par exemple
\giacinputmath{integrate(sin(x)^4,x,0.0,pi)}\\
\item \verb|limit|~: limite d'une expression.
Exemple \giacinputmath{limit((cos(x)-1)/x^2,x=0)}
\item \verb|tabvar|~: tableau de variations d'une expression.
Par exemple \giacinputmath{tabvar(x^3-7x+5)}
on peut v\'erifier avec le graphe \giacinput{plot(x^3-7x+5,x,-4,4)}
\item \verb|taylor| et \verb|series|~: d\'eveloppement de Taylor
(ou d\'eveloppement limit\'e ou asymptotique). Par exemple
\giacinput{taylor(sin(x),x=0,5)}
\item \verb|sum|~: somme discr\`ete. Par exemple
\giacinputmath{sum(k^2,k,1,n)} calcule $\sum_{k=1}^n k^2$,
\giacinputmath{sum(k^2,k,1,n)=>*} calcule la somme et l'\'ecrit sous
forme factoris\'ee.\\
\end{itemize}

\subsection{R\'esoudre}
Depuis le catalogue, s\'electionner le sous-menu \verb|Resoudre|
(Toolbox puis touche ln)
\begin{itemize}
\item \verb|solve| permet de r\'esoudre de mani\`ere exacte
une \'equation (se ramenant \`a une \'equation polynomiale).
Il faut pr\'eciser la variable si ce n'est pas \verb|x| par
exemple \giacinputmath{solve(t^2-1=0,t)}.\\
Si la recheche exacte \'echoue, la commande \verb|fsolve|
permet de faire une r\'esolution approch\'ee, soit par
une m\'ethode it\'erative en partant d'une valeur
initiale \giacinputmath{fsolve(cos(x)=x,x=0.0)}, soit par
dichotomie  \giacinputmath{fsolve(cos(x)=x,x=0..1)}.\\
Pour avoir des solutions complexes, utiliser \verb|csolve|.\\
On peut faire des hypoth\`eses sur la variable que l'on cherche,
par exemple \giacinputmath{assume(m>1)} puis \giacinputmath{solve(m^2-4=0,m)}.
\item \verb|solve| permet aussi de r\'esoudre des syst\`emes
polynomiaux simples, on donne en 1er argument la liste des
\'equations, en 2\`eme argument la liste des variables.
Par exemple intersection d'un cercle et d'une droite
\giacinputmath{solve([x^2+y^2+2y=3,x+y=1],[x,y])}
\item \verb|linsolve| permet de r\'esoudre des syst\`emes
lin\'eaires. On lui passe la liste des \'equations et la liste
des variables (par convention une expression \'equivaut
\`a l'\'equation expression=0). Par exemple
\giacinputmath{linsolve([x+2y=3,x-y=7],[x,y])}
\verb|linsolve| renvoie la solution g\'en\'erale du syst\`eme 
(y compris si la solution n'est pas unique).
\item \verb|desolve| permet de r\'esoudre de mani\`ere exacte
certaines \'equations diff\'erentielles, par exemple 
pour r\'esoudre $y'=2y$, on tape \verb|desolve(y'=2y)|.\\
Un exemple o\`u on indique une condition initiale, 
la variable ind\'ependante
et la fonction inconnue~:\\
\verb|desolve([y'=2y,y(0)=1],x,y)|
Utiliser \verb|odesolve|
pour une r\'esolution approch\'ee et \verb|plotode| pour une
repr\'esentation graphique de solution calcul\'ee de mani\`ere
approch\'ee. 
\item \verb|rsolve| permet de r\'esoudre de mani\`ere exacte
certaines relations de r\'ecurrences $u_{n+1}=f(u_n,...)$,
par exemple les suites arithm\'etico-g\'eom\'etriques, par
exemple $u_{n+1}=2u_n+3, u_0=1$
\giacinputmath{rsolve(u(n+1)=2*u(n)+3,u(n),u(0)=1)}
\end{itemize}

\subsection{Arithm\'etique}
Lorsque cela est n\'ecessaire,
on distingue l'arithm\'etique des entiers de celle des polyn\^omes
par l'existence du pr\'efixe \verb|i| (comme \verb|integer|) dans
un nom de commande, par exemple \verb|ifactor| factorise un entier
(pas trop grand) alors que \verb|factor| factorise un polyn\^ome
(et \verb|cfactor| factorise un polyn\^ome sur les complexes).
Certaines commandes fonctionnent \`a la fois pour les entiers et
les polyn\^omes, par exemple \verb|gcd| et \verb|lcm|.

\subsubsection{Entiers}
Depuis le catalogue, s\'electionner le sous-menu \verb|Arithmetic, Crypto|
(Toolbox 5)
\begin{itemize}
\item \verb|iquo(a,b)|, 
\verb|irem(a,b)| quotient et reste de la division euclidienne
de deux entiers.\\
\giacinputmath{iquo(23,13),irem(23,13)}
\item \verb|isprime(n)| teste si $n$ est un nombre premier.
Le test est probabiliste pour de grandes valeurs de $n$.
\giacinputmath{isprime(2^64+1)}
\item \verb|ifactor(n)| factorise un entier pas trop grand
(les algorithmes utilis\'es se limitent \`a la division et Pollard-$\rho$,
il n'y avait pas de place pour le crible quadratique).
Par exemple
\giacinputmath{ifactor(2^64+1)}\\
Raccourci clavier touches $\rightarrow$ puis * (\verb|=>*|)
\item \verb|gcd(a,b)|, \verb|lcm(a,b)| PGCD et PPCM de deux entiers
ou de deux poln\^omes\\
\giacinputmath{gcd(25,15),lcm(25,15)}\\
\giacinputmath{gcd(x^3-1,x^2-1),lcm(x^3-1,x^2-1)}
\item \verb|iegcd(a,b)| renvoie 3 entiers $u,v,d$ tels que
$au+bv=d$ o\`u $d$ est le PGCD de $a$ et $b$, avec $|u|<|b|$ et
$|v|<|a|$.\\
\giacinputmath{u,v,d:=iegcd(23,13); 23u+13v}
\item \verb|ichinrem([a,m],[b,n])| lorsque cela est possible,
renvoie $c$ tel que $c=a \pmod m$ et $c=b \pmod n$ (si $m$ et $n$
sont premiers entre eux, $c$ existe).
\giacinputmath{c,n:=ichinrem([1,23],[2,13]); irem(c,23); irem(c,13)}
\item \verb|powmod(a,n,m)| calcule $a^n \pmod m$ par
l'algorithme de la puissance rapide modulaire.
\giacinputmath{powmod(7,22,23)}
\end{itemize}
Les commandes \verb|asc| et \verb|char| permettent de convertir
une chaine de caract\`eres en liste d'entiers (entre 0 et 255) et
r\'eciproquement, ce qui permet de faire facilement de la cryptographie
avec des messages sous forme de chaines de caract\`eres.

\subsubsection{Polyn\^omes}
Depuis le catalogue, s\'electionner le sous-menu \verb|Polynomes| (8).
La variable est par d\'efaut $x$, sinon il faut la sp\'ecifier en
g\'en\'eral en dernier argument, par exemple \verb|degree(x^2*y)|
ou \verb|degree(x^2*y,x)| renvoient 2, alors que \verb|degree(x^2*y,y)|
renvoie 1
\begin{itemize}
\item \verb|coeff(P,n)| coefficient de $x^n$ dans $P$, \verb|lcoeff(P)|
coefficient dominant de $P$, par exemple
\giacinputmath{P:=x^3+3x; coeff(P,1); lcoeff(P)}
\item \verb|degre(P)| degr\'e du polyn\^ome $P$.
\giacinput{degree(x^3)}
\item \verb|quo(P,Q)|, \verb|rem(P,Q)| quotient et reste de la division
euclidienne de \verb|P| par \verb|Q|
\giacinputmath{P:=x^3+7x-5; Q:=x^2+x; quo(P,Q); rem(P,Q)}
\item \verb|proot(P)|~: racines approch\'ees de $P$ (r\'eelles et complexes)\\
\giacinput{proot(x^5+x+1)}
Repr\'esentation graphique~:\\
\giacinput{point(proot(x^5+x+1))}
\item \verb|interp(X,Y)|~: pour deux listes
de m\^eme taille, polyn\^ome d'interpolation
passant par les points $(X_i,Y_i)$. \\
\giacinputmath{X,Y:=[0,1,2,3],[1,-3,-2,0]; P:=interp(X,Y)=>+}
Repr\'esentation graphique\\
\giacinput{scatterplot(X,Y); plot(P,x,-1,4)}
\item \verb|resultant(P,Q)|~: r\'esultant des polyn\^omes
$P$ et $Q$
\giacinput{P:=x^3+7x-5; Q:=x^2+x; resultant(P,Q)}
\item \verb|hermite(x,n)|~: n-i\`eme polyn\^ome de Hermite,
orthogonal pour la densit\'e $e^{-x^2}dx$ sur $\R$
\item \verb|laguerre(x,n,a)|~: n-i\`eme polyn\^ome de Laguerre,
\item \verb|legendre(x,n)|~: n-i\`eme polyn\^ome de Legendre,
orthogonal pour la densit\'e $dx$ sur $[-1,1]$
\item \verb|tchebyshev1(n)| et \verb|tchebyshev2(n)|
polyn\^omes de Tchebyshev de 1\`ere et 2\`eme esp\`ece
d\'efinis par~:
$$T_n(\cos(x))=\cos(nx), \quad U_n(\cos(x))\sin(x)=\sin((n+1)x)$$
%\item \verb|bernoulli(n,x)| polyn\^ome de Bernoulli
\end{itemize}

\subsubsection{$\mathbb{Z}/n\mathbb{Z}$ et corps finis}
Pour travailler avec des classes modulo $n$, utiliser la notation
\verb|a mod n|, par exemple \verb|sqrt(2 mod 7)|.
Ceci s'applique aussi pour travailler sur des corps finis premiers
$\mathbb{Z}/p\mathbb{Z}$. Pour travailler sur des corps finis
non premiers, il faut d'abord d\'efinir le corps avec \verb|GF|,
puis on utilise un polyn\^ome en le g\'en\'erateur du corps.

\subsection{Alg\`ebre lin\'eaire, vecteurs, matrices}
Xcas ne fait pas de diff\'erence entre vecteur et liste. Par
exemple pour faire le produit scalaire de deux vecteurs, on peut
saisir~:
\begin{giaconload}v:=[1,2]; w:=[3,4]\end{giaconload}
\giacinput{dot(v,w)}

Pour saisir une matrice \'el\'ement par \'el\'ement, taper
sur shift-7 (touche M comme matrice) puis \verb|matrix(|
ou selon le modèle \verb|shift EXE i| ou \verb|HOME i| (editer matrice). 
Vous pouvez ensuite
cr\'eer une nouvelle matrice ou \'editer
une matrice existante parmi la liste de variables propos\'ees. 
Pour de petites matrices, vous pouvez aussi
entrer en ligne de commandes
une liste de listes de m\^eme taille. Par exemple
pour d\'efinir la matrice
$$ A=\left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \end{array}\right)$$
on tape \begin{giaconload}A:=[[1,2],[3,4]]\end{giaconload} 
ou \giacinputmath{[[1,2],[3,4]]=>A}

Il est fortement conseill\'e de stocker les matrices dans des variables
pour \'eviter de les saisir plusieurs fois.

Pour entrer une matrice dont les coefficients sont
donn\'es par une formule,
on peut utiliser la commande \verb|matrix|, par
exemple 
\giacinputmath{matrix(2,2,(j,k)->1/(j+k+1))} 
renvoie
la matrice dont le coefficient ligne $j$ et colonne $k$ vaut
$\frac{1}{j+k+1}$ (attention les indices commencent \`a 0). 

La matrice identit\'e de taille $n$ 
est renvoy\'ee par la commande \verb|idn(n)|,
alors que \verb|ranm(n,m,loi,[parametres])| renvoie
une matrice \`a coefficients al\'eatoires de taille $n,m$.
Par exemple 
\giacinputmath{U:=ranm(4,4,uniformd,0,1)}
\giacinputmath{N:=ranm(4,4,normald,0,1)}

Pour ex\'ecuter une commande sur des matrices, s'il s'agit
d'arithm\'etique de base (\verb|+,-,*| inverse), on utilise
les op\'erations au clavier. Pour les autres commandes.
depuis le catalogue, s\'electionner le sous-menu \verb|Matrices|
(Toolbox sin)
\begin{itemize}
\item \giacinputmath{eigenvals(A)}
\giacinputmath{eigenvects(A)} 
renvoient les valeurs
propres et vecteurs propres d'une matrice carr\'ee $A$. 
\item \giacinputmath{P,D:=jordan(A)} 
calcule la forme normale de Jordan d'une matrice $A$
(\`a coefficients exacts) et renvoie les matrices $P$ et $D$ telles que
$P^{-1}AP=D$, avec $D$ triangulaire sup\'erieure (diagonale si $A$ est
diagonalisable)
\item \giacinputmath{Ak:=matpow(A,k)} calcule la puissance $k$-i\`eme
d'une matrice $A$ avec $k$ une variable formelle.
\item \verb|rref| effectue la r\'eduction sous forme \'echelonn\'ee
d'une matrice $A$ (pivot de Gauss)
\item \verb|lu| calcule la d\'ecomposition $LU$ d'une matrice $A$
et renvoie une permutation de matrice $P$ et deux matrices $L$
triangulaire inf\'erieure et $U$ triangulaire sup\'erieure telles que
$PA=LU$. Le r\'esultat de la commande 
\giacinput{P,L,U:=lu(A)} peut
\^etre pass\'e en argument \`a la commande \giacinput{linsolve(P,L,U,v)}
pour r\'esoudre un syst\`eme $Ax=b$ de matrice $A$ en r\'esolvant
deux syst\`emes triangulaires (calcul en $O(n^2)$ au lieu
de $O(n^3)$).
\item \verb|qr| calcule la d\'ecomposition $QR$ d'une matrice $A$
et renvoie deux matrices $Q$ orthogonale et $R$ triangulaire sup\'erieure
telles que $A=QR$.
\item \verb|svd(A)| calcule la factorisation en valeurs
singuli\`eres d'une matrice $A$, et renvoie 
$U$ orthogonale, $S$ vecteur des valeurs singulières, $Q$
orthogonale tels que \verb|A=U*diag(S)*tran(Q)|. Le rapport
de la plus grande valeur singuli\`ere de $S$ sur la plus petite
donne le nombre de condition de $A$ relativement \`a la norme euclidienne,
plus ce nombre est grand, plus on perd en pr\'ecision en r\'esolvant
un syst\`eme $Ax=b$ lorsque $b$ n'est pas connu exactement.
\end{itemize}


\section{Probabilit\'es et statistiques}

\subsection{Tirages al\'eatoires}
Depuis le catalogue, s\'electionner le sous-menu \verb|Probabilites|
(Toolbox 9) puis s\'electionnez \giacinput{rand()} (r\'eel selon
la loi uniforme dans $[0,1]$) ou 
\giacinput{n:=6:; randint(n)} 
(entier
entre 1 et $n$). De nombreuses autres fonctions al\'eatoires
existent, avec comme pr\'efixe \verb|rand|, suivi par le nom
de la loi, par exemple \verb|randbinomial(n,p)| renvoie
un entier al\'eatoire selon la loi binomiale de param\`etres $n,p$.
Pour cr\'eer un vecteur ou une matrice al\'eatoire, utiliser la commande
\verb|ranv| ou \verb|ranm| (menu \verb|Alglin, Matrice|), 
par exemple pour un vecteur de 10 composantes
selon la loi normale centr\'ee r\'eduite 
\giacinputmath{ranv(10,normald,0,1)}

\subsection{Lois de probabilit\'es}
Depuis le catalogue, s\'electionner le sous-menu \verb|Probabilites| (9).
Les lois propos\'ees dans le catalogue sont la loi binomiale, la loi normale,
la loi exponentielle et la loi uniforme. 
D'autres lois sont disponibles depuis \verb|Tout|~:
\verb|chisquared|, \verb|geometric|, \verb|multinomial|
\verb|studentd|, \verb|fisherd|, \verb|poisson|.

Pour obtenir la distribution cumul\'ee d'une loi, on saisit le nom de la loi
et le suffixe \verb|_cdf| (s\'electionner \verb|cdf| dans le catalogue
sous-menu Probabilit\'es et taper Ans). 
Pour obtenir la distribution cumul\'ee inverse,
on saisit le nom de la loi et le suffixe \verb|_icdf|  
(s\'electionner \verb|cdf| dans le catalogue
sous-menu Probabilit\'es et taper EXE).

Exemple~: calcul de l'intervalle centr\'e $I$
pour la loi normale de moyenne 5000 et d'\'ecart-type 200
tel que la probabilit\'e d'\^etre en-dehors de $I$ soit de 5\%~:
\giacinput{M:=5000; S:=200; normald_icdf(M,S,0.025);normald_icdf(M,S,0.975)}

\subsection{Statistiques descriptives 1-d}
Ces fonctions agissent sur des listes
par exemple \begin{giaconload}l:=[9,11,6,13,17,10]\end{giaconload}
Depuis le catalogue, s\'electionner le sous-menu \verb|Statistiques|
(Toolbox log)
\begin{itemize}
\item \giacinput{mean(l)}~: moyenne arithm\'etique d'une liste
\item \giacinput{stddev(l)}~: \'ecart-type d'une liste\\
Utiliser
\giacinput{stddevp(l)} pour avoir un estimateur non biais\'e
de l'\'ecart-type d'une population dont \verb|l| est un \'echantillon
\item \giacinput{median(l)}, \giacinput{quartile1(l)}, 
\giacinput{quartile3(l)}
renvoient respectivement la m\'ediane, le 1er et 3\`eme quartiles
d'une liste
\end{itemize}
Pour les statistiques 1-d de listes avec effectifs, on remplace
\verb|l| par deux listes de m\^eme longueur, la 1\`ere liste
est la liste des valeurs de la s\'erie statistique, la 2\`eme
liste est la liste des effectifs.
Voir aussi les commandes du menu \verb|shift-3| 
\verb|histogram| et \verb|barplot|.

\subsection{Statistiques descriptives 2-d, r\'egressions.} \label{sec:stat2d}
Voir aussi la section \ref{sec:tableur} expliquant le tableur.

Entrez les deux listes de donn\'ees dans deux variables, par exemple
\verb|X:=[1,2,3,4,5]| et \verb|Y:=[3,5,6,8,11]|, ou dans une variable
matrice ayant 2 colonnes,
depuis le shell avec le menu \verb|shift-6| \verb|8 matrix(|.\\
Depuis le catalogue, s\'electionner le sous-menu \verb|Statistiques|
(touches \verb|Toolbox log|), pour les r\'egressions,
depuis le shell, tapez \verb|shift-6|.
\begin{itemize}
\item \verb|correlation(X,Y)| calcule la corr\'elation entre 
2 listes de m\^eme taille.
\item \verb|covariance(X,Y)| calcule la covariance entre 
2 listes de m\^eme taille.
\item les commandes de suffixe \verb|_regression(X,Y)| calculent
  des ajustements par r\'egression au sens des moindres carr\'es,
  les commandes de suffixe \verb|_regression_plot| tracent
  la courbe repr\'esentative de la r\'egression (Ces commandes affichent
de plus le coefficient $R^2$ qui permet de quantifier la qualit\'e
de l'ajustement (plus $R^2$ est proche de 1, meilleur est
l'ajustement).
  Khicas a des commandes pour faire des r\'egressions lin\'eaires,
  exponentielles, logarithmiques, puissance, polynomiales et logistique.
\item Par exemple \verb|linear_regression(X,Y)| renvoie
les coefficients $m,p$ de la droite de r\'egression lin\'eaire
$y=mx+p$. \\
\verb|linear_regression_plot(X,Y)|  trace la droite 
d'ajustement des donn\'ees contenues dans les listes
\verb|X,Y| de m\^eme taille.
\item voir aussi les commandes \verb|scatterplot|, \verb|polygonplot|
  et \verb|polygonscatterplot| pour afficher les donn\'ees
  sur un graphique. On peut superposer plusieurs courbes de r\'egression
  sur le m\^eme graphe en les s\'eparant par un \verb|;| en ligne
  de commande.
\end{itemize}
Ainsi pour afficher la droite de r\'egression lin\'eaire correspondant
aux donn\'ees \verb|X=[1,2,3,4,5]| et \verb|Y=[3,5,6,8,11]|,
tapez les deux commandes ci-dessus ou \'editez une matrice ayant 2 colonnes
avec le raccourci \verb|shift-6 8|. Puis \verb|shift-6 EXE|
(ou \verb|Toolbox log| puis
s\'electionnez la commande \verb|linear_regression_plot(|)
compl\'etez la commande par \verb|X,Y)| ou par le nom de variable
de la matrice puis EXE.

Remarque~: si vos donn\'ees sont dans une matrice \verb|m|
ayant 2 lignes au lieu de 2 colonnes, vous pouvez utiliser \verb|m^*|
pour transposer (en fait cela transconjugue, ce qui est identique
pour des donn\'ees r\'eelles).

\section{Courbes et autres repr\'esentations graphiques.}
Pour obtenir une repr\'esentation graphique, on saisit une commande
de trac\'e (ou plusieurs commandes s\'epar\'ees par \verb|;|).
Depuis le catalogue, s\'electionner le sous-menu \verb|Courbes|
(acc\`es rapide par Toolbox 7, ou shift-3 depuis le shell).
\begin{itemize}
\item \verb|plot(f(x),x=a..b)| trace le graphe de $f(x)$ pour $x\in [a,b]$.
On peut sp\'ecifier un pas de discr\'etisation avec \verb|xstep=|,
par exemple \giacinput{plot(x^2,x=-4..4,xstep=1)}
\item \verb|plot(x+y>0 and 2x+y<4 and x+2y<5)|~: repr\'esentation
graphique des solutions de ce syst\`eme d'in\'equations. Les
in\'equations polynomiales du premier et deuxi\`eme degr\'e
(d\'elimit\'es  par des droites et des coniques) b\'en\'eficient
d'un support am\'elior\'e, les bords de la zone solution sont calcul\'es
sous forme d'une ligne polygonale exacte (si tout est de degr\'e 1)
ou approch\'ee. Sinon, une discr\'etisation est calcul\'ee et la
zone repr\'esent\'ee est une suite de petits rectangles, ce qui donne
un aspect pixelis\'e au graphe, surtout sur la Numworks o\`u la
m\'emoire disponible et le temps n\'ecessaire au calcul ne permet pas
un graphe tr\`es pr\'ecis.\\
Si vous voulez aussi tracer les droites sur
cet exemple, tapez la commande \\
\verb|plot(x+y>0 and 2x+y<4 and x+2y<5);line(x+y=0);line(2x+y=4); line(x+2y=5)|
\item \verb|LineTan(f(x),x,x0)| trace la tangente au graphe
  de $f(x)$ en $x=x_0$.
\item \verb|plotarea(f(x),x=a..b,n,methode)|
  trace le graphe de $f(x)$ pour $x\in [a,b]$, et noircit
  une portion du plan qui approche l'aire sous la courbe,
  on peut pr\'eciser une m\'ethode d'int\'egration avec \verb|n|
  subdivisions parmi \verb|rectangle_droit|, \verb|rectangle_gauche|,
  \verb|trapezes|, \verb|simpson| (aller dans Toolbox , Options
  puis taper le d\'ebut du nom de la m\'ethode pour la saisir plus
  rapidement)
\item \verb|plotseq(f(x),x=[u0,a,b])| graphe ``en toile d'araign\'ee''
de la suite r\'ecurrente $u_{n+1}=f(u_n)$ de premier terme $u_0$ donn\'e.
Par exemple si $u_{n+1}=\sqrt{2+u_n}, u_0=6$ avec une repr\'esentation
sur $[0,7]$
\giacinput{plotseq(sqrt(2+x),x=[6,0,7])}
\item \verb|plotparam([x(t),y(t)],t=tm..tM)| courbe en param\'etriques
$(x(t),y(t))$ pour $t\in [t_m,t_M]$.
On peut sp\'ecifier un pas de discr\'etisation avec \verb|tstep=|
par exemple
\giacinput{plotparam([sin(2t),cos(3t)],t,0,2*pi)}
%On peut sp\'ecifier la fen\^etre graphique avec
\item \verb|plotpolar(r(theta),theta=a..b)| courbe
en polaires $r(\theta)$ pour $\theta \in [a,b]$,
par exemple
\giacinput{plotpolar(sin(3*theta),theta,0,2*pi)}
\item \verb|plotlist(l)| pour une liste \verb|l|,
trace la ligne polygonale reliant
les points de coordonn\'ees $(i,l_i)$ (indice $i$ commen\c{c}ant \`a 0).\\
\verb|plotlist([X1,Y1],[X2,Y2],...)| 
trace la ligne polygonale reliant
les points de coordonn\'ees $(X_i,Y_i)$ 
\item \verb|scatterplot(X,Y)|, \verb|polygonscatterplot(X,Y)|
pour 2 listes \verb|X,Y| de m\^eme taille, trace un nuage de points
ou une ligne polygonale reliant
les points de coordonn\'ees $(X_i,Y_i)$ 
\item \verb|histogram(l,class_min,class_size)| trace
l'histogramme des donn\'ees de la liste \verb|l| avec
comme largeur de classe \verb|class_size| en commen\c{c}ant
\`a \verb|class_min|. Par exemple, on peut tester la qualit\'e
du g\'en\'erateur al\'eatoire avec
\giacinput{l:=ranv(500,normald,0,1); histogram(l,-4,0.25); plot(normald(x),x,-4,4)}
\item \verb|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, ...$.
\item \verb|plotdensity(f(x,y),[x=xmin..xmax,y=ymin..ymax])|
  repr\'esentation par niveaux de couleurs de la fonction de 2 variables
  \verb|x| et \verb|y| dans le rectangle sp\'ecifi\'e (par d\'efaut
  entre -4 et 4).
\item \verb|plotfield(f(t,y),[t=tmin..tmax,y=ymin..ymax])|
trace le champ des tangentes \`a l'\'equation diff\'erentielle
$y'=f(t,y)$. On peut ajouter en dernier param\`etre
optionnel \verb|,plotode=[t0,y0]|
pour tracer simultan\'ement la solution passant par la condition
initiale $y(t_0)=y_0$. Exemple $y'=\sin(ty)$ sur l'intervalle $[-3,3]$
en temps et $[-2,2]$ en $y$\\
\giacinput{plotfield(sin(t*y),[t=-3..3,y=-3..3],plotode=[0,1])}
On peut aussi utiliser la commande \verb|plotode| en-dehors d'une commande
\verb|plotfield|.
\ite pour tracer simultan\'ement plusieurs graphiques, il suffit de s\'eparer
les commandes de trac\'e par \verb|;|
\end{itemize}
Lorsqu'un graphique comporte des trac\'es de courbes (graphes de
fonction, courbes en param\'etriques ou en polaires), le mode
``trace'' est activ\'e par d\'efaut. Dans ce mode, l'appui sur la
touche curseur vers la droite ou la gauche permet de d\'eplacer
un pointeur sur la courbe active, en affichant les coordonn\'ees
du pointeur (et du param\`etre pour une courbe en param\'etriques)
et d'un vecteur tangent. S'il y a plusieurs arcs de courbe, les
touches de curseur haut et bas permettent de changer l'arc d'\'etude.
L'appui sur shift-2 permet d'afficher les informations sur la courbe
courante, si on confirme par OK ou EXE on acc\`ede \`a un tableau de valeurs.

Le menu Toolbox item 2 \'etude de courbes (raccourci touche x,n,t)
permet d'ajouter un vecteur normal pointant vers le centre de courbure
(raccourci shift-4),
ou/et le cercle osculateur (shift-5) et le rayon de courbure. On peut
aussi \`a partir de ce menu d\'eplacer le pointeur vers une position d\'etermin\'ee, ou
vers un point remarquable: racine, tangente horizontale ou verticale,
point d'inflexion, intersection avec un autre arc de courbe. On peut
enfin calculer une longueur d'arc ou l'aire sous la courbe entre
le pointeur et la marque. 

Lorsque vous faites une \'etude de courbe, les variables
\verb|x0,x1,x2,y0,y1,y2|
sont automatiquement affect\'ees avec l'expression de la position, vitesse
et acc\'el\'eration sur la courbe \'etudi\'ee. Lors de la recherche
d'une racine, tangente horizontale, inflexion, longueur d'arc, aire
sous la courbe, des variables contenant la derni\`ere recherche
sont cr\'ees.

Le menu \verb|Options| (Toolbox ,)
vous permet de sp\'ecifier certaines options graphiques~:
\begin{itemize}
\item pour les couleurs, on utilise 
\verb|display=couleur|, par exemple
\giacinput{plot(sin(x),display=red)}
\item Pour changer l'\'epaisseur des segments (y compris les lignes
polygonales utilis\'ees pour tracer une courbe), utiliser
\verb|display=line_width_2| \`a \verb|display=line_width_8|.
Pour changer \`a la fois la couleur et l'\'epaisseur, additionnez les
attributs, par exemple~:
\verb|display=red+line_width_2|
\item Les cercles ainsi que les rectangles dont les bords sont
parall\`eles aux axes peuvent \^etre remplis avec l'attribut
\verb|display=filled| (qui peut s'additionner \`a d'autres attributs).
\item Pour remplacer la fen\^etre graphique calcul\'ee automatiquement
par des valeurs pr\'ed\'efinies, saisir
\verb|gl_x| ou/et \verb|gl_y| et indiquer l'intervalle
en $x$ ou en $y$ souhait\'e, la commande doit pr\'ec\'der une
commande de trac\'e. Par exemple 
\giacinput{gl_x=-2..2;gl_y=-1..4;plot(exp(x))}
\item
Pour enlever les axes, s\'electionner \verb|axes| 
(\verb|axes=0|). La commande doit pr\'ec\'eder une commande de
trac\'e.
\end{itemize}

Les versions récentes de $\chi$CAS permettent de représenter
en 3d ou 4d des fonctions de 2 variables à valeur réelle ou complexe, par
exemple \verb|plot(x^2-y^2)| pour représenter
la fonction de $\mathbb{R}^2 \rightarrow \mahtbb{R}$
ou \verb|plot((x+i*y)^2-9)| pour représenter
la fonction de $\mathbb{C} \rightarrow \mahtbb{C}$ qui à
$z$ associe $z^2-9$. Dans ce dernier cas, le module est représenté
selon l'axe $Oz$ et l'argument par une couleur de l'arc en ciel, de $-\pi$
en bleu violet à 0 en vert (en passant par jaune et orange) et de 0 à $\pi$
en passant par cyan.

Pour préciser des options en 3d/4d,
il faut utiliser la commande \verb|plotfunc|,
par exemple\\
\verb|plotfunc((x+i*y)^3-1,[x=-2..2,y=-2..2],nstep=500)|\\
pour tracer $z \rightarrow z^3-1$ depuis le carré du plan complexe
centré en l'origine
de coté 4, avec une discrétisation utilisant 500 petits rectangles.


\section{G\'eom\'etrie analytique.}
L'application de géométrie
permet de construire des figures dans le plan ou dans l'espace,
et de faire bouger un point et tout ce qui en d\'epend pour illustrer
certaines propriétés (géométrie
dynamique). On peut faire des constructions de géométrie euclidienne
pure, mais aussi avec des graphes de fonction, des coniques, etc.
L'application possède deux ``vues'': la vue graphique et la vue
symbolique qui contient les commandes Xcas permettant de créer la figure
(la philosophie de cette application est proche de celle du logiciel
Geogebra, avec les commandes de Xcas).

\subsection{Modes, vue graphique et symbolique.}
Taper shift-Ans  pour afficher la liste des
applications additionnelles, puis OK puis sélectionnez soit une nouvelle
figure 2d ou 3d soit une figure existante. Vous pouvez aussi ouvrir
l'application de géométrie depuis un graphe (par exemple après avoir
tapé \verb|plot(sin(x))|) en tapant shift EXE ou Home 
selon le modèle puis Sauvegarder figure.

Au lancement on est dans la vue graphique en mode repère, les touches de curseur
permettent de changer de point de vue. Pour changer le mode, utiliser
la touche Toolbox, pour passer en vue symbolique et vice-versa taper OK.
Par exemple tapez Toolbox 3 pour passer en mode point
qui permet de construire des points en déplaçant
le pointeur et en tapant OK ou tapez Toolbox 5 pour passer
en mode triangle qui permet de construire
un triangle à partir de ses 3 sommets, on déplace le pointeur et on tape OK
trois fois. Pour déplacer le pointeur, utiliser les touches de déplacement,
pour se déplacer plus rapidement, faire shift touche de curseur. Si on
est proche d'un point existant, son nom apparait en bas. Pour
déplacer le pointeur vers un point existant, vous pouvez aussi
taper le nom du point (par exemple touche alpha A).

Le mode pointeur permet de sélectionner un point et de le
déplacer pour observer comment la construction varie, ce qui permet
de mettre en évidence des propriétés de la figure, par exemple concurrence
de 3 droites.

Si vous tapez sur la touche Back depuis la vue graphique
de l'application, vous revenez au mode repère ou si vous y étiez
vous passez en vue symbolique. Vous pouvez ajouter
des objets à la construction depuis cette vue, en mettant une commande
par ligne. Tapez EXE pour passer à la ligne. Tapez OK
pour revenir à la vue graphique. Dans la vue symbolique, vous
pouvez sauvegarder la construction géométrique au format texte
(avec une extension \verb|.py|, même s'il ne s'agit pas
d'un script Python).
Tapez Back pour quitter l'application de géométrie.

Lorsque vous quittez l'application de géométrie,
la figure est automatiquement sauvegardée
dans une variable Xcas qui a le même nom que celui du nom de fichier
affiché dans la vue symbolique. Vous pouvez purger la variable Xcas
si vous voulez effacer la figure de la session.

\subsection{Exemples}
\subsubsection{Exemple 2d~: cercle circonscrit.}
Depuis le shell, taper shift-Ans sélectionner nouvelle figure 2d et valider OK.
Puis Toolbox 5 Triangle, OK pour créer le premier sommet du triangle
puis déplacer le pointeur avec les touches de déplacement, OK pour créer
le 2ème sommet du triangle, déplacer le pointeur à nouveau et OK
pour créer le triangle.

Version longue en construisant le centre~:
Taper Toolbox 7, sélectionner 8 Mediatrice, déplacer
le pointeur de sorte que seul un segment du triangle
soit sélectionné (affichage
en bas à droite \verb|perpen_bisector D5,D|),
taper OK pour créer la médiatrice du segment, déplacer le curseur
sur une autre arête du triangle et OK pour créer la 2ème médiatrice,
optionnellement sur le 3ème segment pour avoir les 3 médiatrices.
Puis Toolbox 6 et 4 Intersection unique. Déplacer le curseur vers
une des médiatrices, taper OK puis vers une autre médiatrice, taper OK,
ceci crée le centre du cercle circonscrit. Pour tracer le cercle,
taper Toolbox 4, déplacer le curseur au centre du cercle (vous pouvez
utiliser les touches de déplacement ou juste taper
alpha H ou la bonne lettre si le centre du cercle s'appelle autrement),
puis OK puis sur un des sommets et OK.

Version courte avec la commande \verb|circonscrit|~:
taper Toolbox 9 puis circonscrit puis sélectionner chaque
sommet avec OK (alpha A OK alpha B OK alpha C OK, remplacez A, B, C
par les lettres du sommet du triangle).

Version en vue symbolique~:
taper Back puis en fin de script sur une ligne vide (taper EXE s'il
faut en créer une), taper\\
\verb|c:=circonscrit(A,B,C)| OK

\subsubsection{Exemple 3d: bac septembre 2019~}
On considère un cube $ABCDEFGH$ et on vérifie que le segment $DE$ est 
perpendiculaire au plan $ABG$\\
Taper shift Ans pour lancer l'application de géométrie puis nouvelle figure 3d.
\begin{itemize}
\item Taper Puis Back ou OK pour passer en vue symbolique.
Puis alpha c shift =
puis Toolbox flèche haut deux fois pour sélectionner 3D puis OK puis 5 pour cube
puis Toolbox (aide), qui explique que
les 2 premiers arguments de cube sont les sommets d'une ar\^ete,
le troisième est un point d'un plan d'une face. Le premier
exemple nous convient ici exactement, on tape Ans et on obtient
\verb|c=cube([0,0,0],[1,0,0],[0,1,0])|
On tape EXE pour voir le cube puis + plusieurs fois pour zoomer et EXE
pour revenir à la vue symbolique.
\item
Vous pouvez sauvegarder à tout moment la construction au format
texte depuis
le menu (touche shift-EXE ou Home selon le modèle).
\item
On passe à la ligne en tapant EXE. Puis on définit les sommets
du cube en tapant \verb|A,B,C,D,E,F,G,H:=|
(taper alpha shift A , alpha shift B etc.),
puis Toolbox et flèche vers le haut 3 fois
pour sélectionner Géometrie puis flèche vers le haut 4 fois pour sélectionner
\verb|sommets| OK et mettre c en argument \verb|sommets(c)|.
Taper OK pour visualiser puis OK à nouveau pour revenir en vue
symbolique.
\item
Passer à la ligne avec EXE puis créer le plan ABG
en tapant alpha shift P = puis shift-2 pour
ouvrir le menu rapide lines et 8 pour saisir plane. La commande plan
prend en arguments 3 points pour définir le plan (on peut aussi donner
une équation cartésienne), ici A,B,G, \verb|P=plan(A,B,G,|
on va lui ajouter une couleur avec le menu rapide shift 4 disp
\verb|display=filled+green|, vérifier en visualisant avec OK OK.
\item
On passe à la ligne (EXE) et on crée le segment DE
alpha S = shift 2 sélectionner la commande segment avec OK
puis D,E et shift 4 pour lui donner une couleur
\verb|S=segment(D,E,color=cyan)|
(on pouvait aussi créer le segment depuis la vue graphique en mode Lignes
mais déplacer le pointeur est un peu lent).
\end{itemize}
La construction est donc la suivante:
\begin{verbatim}
c=cube([0,0,0],[1,0,0],[0,1,0])
A,B,C,D,E,F,G,H=sommets(c)
P=plan(A,B,G,display=filled+green)
S=segment(D,E,display=cyan)
\end{verbatim}
Vous pouvez taper OK pour la visualiser et utiliser les flèches de
déplacement pour changer de point de vue. Taper OK ou Back pour revenir
en vue symbolique. Pour quitter l'application taper Back. Taper OK pour
sauvegarder la figure si nécessaire.

Vous pouvez depuis le shell de KhiCAS accéder à de nombreuses informations
de géométrie analytique, par exemple \verb|equation(P)| (menu
Toolbox Géométrie) vous donnera
l'équation cartésienne du plan $P$ ou \verb|is_orthogonal(P,S)|
(à saisir depuis le catalogue complet Toolbox OK)
vous confirmera que le plan $P$ est orthogonal au segment $S$.

%% Pour le moment, aucune application de g\'eom\'etrie interactive n'a \'et\'e
%% port\'ee, l'utilisation de commandes de g\'eom\'etrie analytique
%% de Xcas est donc
%% possible en ligne de commandes, avec des noms de commande en anglais
%% pour le moment, par exemple \verb|point|, \verb|segment|,
%% \verb|circle|, \verb|circumcircle|, \verb|incircle|
%% \verb|line|, \verb|triangle|, \verb|polygon|,
%% \verb|parallel|, \verb|perpendicular|, \verb|bisector|,
%% \verb|perpen_bisector|, \verb|center|, \verb|radius|,
%% \verb|distance|, ...

\section{Unit\'es et constantes physiques.}
Le menu Toolbox permet d'ouvrir
un sous-menu constantes physiques (raccourci \verb|Toolbox pi|)
et unit\'es physiques (raccourci \verb|Toolbox sqrt|) avec
\begin{itemize}
  \item des commandes de gestion d'unit\'e\\
    \verb|mksa| pour convertir vers les unit\'es fondementales du syst\`eme
    international\\
    \verb|usimplify| pour simplifier en utilisant une seule
    unit\'e lorsque c'est possible, ou un produit de deux.\\
    \verb|ufactor| pour forcer l'\'ecriture d'une unit\'e en fonction
    d'une autre\\
    \verb|=>| (raccourci touche sto) pour convertir entre deux unit\'es
    compatibles
  \item une liste non exhaustive d'unit\'es physiques
  \item une liste de constantes physiques fondementales.
\end{itemize}
Exemples de commandes~:\\
\verb|60_(km/h) => _(m/s)|\\
\verb|mksa(_hbar_)|\\
\verb|usimplify(1_W*1_s)|\\
\verb|ufactor(1_W,1_J)|

\section{L'\'editeur d'expressions}
Lorsqu'un calcul renvoie une expression, elle est affich\'ee en plein 
\'ecran dans
l'\'editeur d'expression 2d. Depuis l'historique des calculs, si le niveau
s\'electionn\'e est une expression, l'appui sur shift-5 (2d) affiche
l'expression dans l'\'editeur 2d. En ligne de commande, l'appui
sur shift-5 ouvre aussi l'\'editeur 2d, soit avec 0 si la ligne
de commande \'etait vide, ou avec le contenu de la ligne de commande si
celle-ci est syntaxiquement correcte.

Lorsque l'\'editeur 2d est ouvert, l'expression est affich\'ee en
plein \'ecran et une
partie de l'expression est s\'electionn\'ee. On peut alors agir sur
la s\'election en ex\'ecutant des commandes saisies via les menus
ou le clavier, on peut aussi \'editer la s\'election (en mode de saisie
1d). Ceci permet de retravailler des sous-expressions
ou d'\'editer une expression en \'ecriture naturelle.

Vous pouvez annuler la derni\`ere modification effectu\'ee en
tapant sur shift-3 (undo).

Taper OK pour quitter l'\'editeur 2d et copier l'expression en ligne de
commande, taper Back pour quitter sans recopier l'expression.

Exemple 1~: nous allons saisir 
$$ \lim_{x \rightarrow 0} \frac{\sin(x)}{x}$$
Depuis une ligne de commande vide, taper shift-5 (2d), vous devez voir 0 
s\'electionn\'e. Tapez sur la touche x et EXE, maintenant c'est x qui
est en surbrillance. Tapez sur la touche sin, c'est $\sin(x)$ qui
est en surbrillance. Tapez sur la touche de division (au-dessus de -), 
vous devez voir $\frac{\sin(x)}{0}$ avec 0 en surbrillance, tapez
x puis EXE, vous devez voir $\frac{\sin(x)}{x}$ avec
x au d\'enominateur en surbrillance. Tapez sur le curseur
fl\`eche vers le haut pour mettre $\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 \`a nouveau pour
ex\'ecuter le calcul.
Si on avait voulu
une limite en $+\infty$, il aurait fallu d\'eplacer la s\'election
avec curseur vers la droite, puis faire shift-1 7 (oo) OK.

Exemple 2~: nous allons saisir
$$ \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
$$ \int_0^1 0 \ dx$$
avec $x$ s\'electionn\'e. Il faut donc changer le 1 de la borne sup\'erieure
et le 0 \`a int\'egrer. Pour modifier le 0, curseur vers la gauche pour
le s\'electionner puis \verb|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\'esultat s'affiche
dans l'\'editeur 2d, OK quitte l'\'editeur avec dans l'historique
l'int\'egrale et sa valeur (en syntaxe alg\'ebrique 1d).

Exemple 3~: nous allons calculer et simplifier 
$$ \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
$$ \int_0^1 0 \ dx$$
D\'eplacez le curseur sur le 0 de la borne inf\'erieure de l'int\'egrale
et tapez sur la touche DEL, vous devez voir
$$ \int 0 \ dx$$
avec le tout s\'electionn\'e. Utilisez le curseur vers le bas
pour s\'electionner 0 et tapez \verb|1/(x^4+1)| EXE puis OK pour
recopier en ligne de commande puis OK pour ex\'ecuter le calcul,
le r\'esultat s'affiche maintenant dans l'\'editeur 2d.\\
On peut alors s\'electionner avec les touches du curseur par exemple
l'argument d'un des arctangentes et ex\'ecuter shift-1 EXE (simplify) 
pour effectuer une simplification partielle du r\'esultat, puis
recommencer avec l'autre arctangente.\\
On peut simplifier encore plus, en rassemblant les logarithmes. Pour
cela il faut d'abord \'echanger deux des arguments de la somme. 
S\'electionnez un des logarithmes avec des d\'eplacements du curseur,
puis tapez shift-curseur droit ou gauche,
cela \'echange l'argument s\'electionn\'e avec son fr\`ere de droite ou
de gauche. Tapez ensuite 
 alpha curseur vers la droite ou vers la gauche, ceci augmente la
s\'election en ajoutant le fr\`ere de droite ou de gauche.
Une fois les deux logarithmes s\'electionn\'es, menu shift-1 2 EXE
(factor), puis
descendez la s\'election sur la somme ou diff\'erence de logarithmes,
allez dans le menu Toolbox puis EXE (Tout), tapez les lettres l, n, c
ce qui d\'eplace \`a la premi\`ere commande commen\c{c}ant par \verb|lnc|,
s\'electionnez \verb|lncollect|, validez et tapez enfin sur EXE (eval).

\section{Sessions de calculs}

\subsection{Edition de l'historique.}
En utilisant la touche curseur vers le haut/bas, on se d\'eplace 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\'e 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'\'editeur 2d qui est appel\'e si le niveau
est une expression, dans le
deuxi\`eme cas, c'est l'\'editeur texte qui est appel\'e.
Taper Back pour annuler les modifications ou EXE pour valider.
Si les modifications sont valid\'ees, les lignes de commande situ\'ees
en-dessous de la ligne modifi\'ee seront automatiquement calcul\'ees,
tenant compte des modifications, par exemple si vous modifiez un niveau
comme \verb|A:=1|, les lignes situ\'ees en-dessous d\'ependant de \verb|A|
seront actualis\'ees.

Ce processus peut \^etre automatis\'e en utilisant un curseur,
que l'on peut cr\'eer avec un assistant, depuis le menu principal
(shift EXE ou HOME), Parameter. 
Une fois cr\'e\'e, vous pouvez modifier un curseur
en tapant sur les touches + ou - lorsque le niveau contenant
la commande \verb|assume| ou \verb|parameter| est s\'electionn\'e
(tapez * ou / pour une modification plus rapide).

\subsection{Variables}
En appuyant sur la touche \verb|var| vous affichez la liste
des variables qui ont une valeur, ainsi que des commandes de gestion
de variables. D\'eplacez 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 \verb|restart| permet d'effacer toutes les variables.
La commande \verb|assume| permet de faire une hypoth\`ese sur
une variable, par exemple \verb|assume(x>5)| (\verb|>| se trouve
dans le menu shift-PRGM).


%% \subsection{Sauvegarde et \'echange de sessions avec Xcas.}
%% Depuis l'historique des calculs, avec le menu HOME, vous pouvez sauvegarder
%% une session de travail sur la m\'emoire de stockage de la
%% calculatrice. Les fichiers ont comme extension \verb|xw|.
%% Mais il n'existe actuellement pas de moyen d'\'echanger ces fichiers
%% avec un ordinateur et la m\'emoire de stockage est tr\`es restreinte.
%% Vous pouvez alors sauvegarder ces fichiers sur votre ordinateur en
%% connectant la calculatrice comme clef USB (choix F1), depuis
%% l'explorateur de fichiers de votre ordinateur.

%% Ces fichiers sont compatibles avec Xcas et Xcas pour Firefox. Vous
%% pouvez ouvrir une session depuis le menu Fich, Ouvrir de Xcas
%% ou depuis le bouton Charger/Parcourir de la page de 
%% \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/xcasfr.html}{Xcas pour Firefox}.
%% Vous pouvez sauvegarder des sessions Xcas et Xcas pour Firefox au format
%% \verb|xw| dans le menu Fich, Exporter comme Khicas de Xcas, 
%% ou le bouton Export de Xcas pour Firefox.



\section{Programmation}
L'environnement de programmation de $\chi$cas est assez complet:
un \'editeur, l'interpr\'eteur de Xcas avec toutes ses commandes
(compatibilit\'e 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\'ecution en pas \`a pas.

Vous pouvez programmer en utilisant
les structures de commande en fran\c{c}ais de Xcas
ou en utilisant la compatibilit\'e de
syntaxe Python. Les programmes tr\`es courts (en une ligne)
peuvent \^etre saisis directement en ligne de commande. Les
programmes plus longs ou que l'on souhaite sauvegarder
seront saisis dans l'\'editeur de programmes sur
la calculatrice, ou bien transf\'er\'es depuis un PC ou
une autre calculatrice.

Plusieurs programmes sont install\'es apr\`es un reset de la calculatrice
(des polygones avec la tortue, la fractale de Mandelbrot, le calcul
des racines d'un polyn\^ome de degr\'e 2).
Vous pouvez les visualiser depuis le shell en tapant shift-EXE ou Home 
selon le modèle de calculatrice,
puis Ouvrir script, les interpr\'eter avec la touche OK et les
ex\'ecuter depuis le shell (Back puis var pour s\'electionner la fonction).

%% Attention
%% sur les Numworks N0115/N0120/N0110 verrouillées (section \ref{sec:n120}), 
%% la touche HOME renvoie directement au menu principal de la Numworks,
%% pour simuler l'action de HOME des N0110 non verrouillées, il faut
%% taper les touches shift puis EXE.

\subsection{Prise en main (programmation)}
{\bf Un premier exemple en ligne de commande~}:\\
une fonction d\'efinie par une expression alg\'ebrique. On
saisit \verb|nom_fonction(parametres):=expression|
Par exemple, pour d\'efinir le p\'erim\`etre d'un cercle de
rayon $r$, on peut taper
\giacinput{peri(r):=2*pi*r}
puis on peut calculer \giacinput{peri(1)}.

{\bf Autre exemple, pour calculer l'intervalle de confiance de seconde}
connaissant une fr\'equence $p$ et un effectif $n$, on tape\\
\giacinput{F(P,N):=[P-1/sqrt(N),P+1/sqrt(N)]}\\
puis on teste \giacinput{F(0.4,30)}

{\bf Autre exemple~: avec la tortue de Xcas}\\
La tortue de Xcas est un petit robot qui se d\'eplace selon des 
ordres qui lui sont donn\'es 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$.
Saisir la commande {\tt avance} dans ce menu puis valider, vous
devez voir la tortue (symbolis\'ee par un triangle) avancer de 10 pixels.
Taper Back pour revenir en ligne de commande.
Saisir la commande \verb|tourne_gauche| et valider, la tortue a tourn\'e
de 90 degr\'es. R\'ep\'eter
3 fois ces deux commandes pour afficher un carr\'e.\\
Pour effacer le dessin et ramener la tortue \`a l'origine,
saisir la commande {\tt efface}.
Pour faire des dessins tortue, il est conseill\'e d'utiliser l'\'editeur
de programmes (cf. ci-dessous).

{\bf Autre exemple~: une boucle ``oneliner'' en syntaxe Xcas.}\\
Ouvrez le menu Programmes (Toolbox cos), puis s\'electionnez l'exemple
de \verb|pour| (curseur sur pour puis Ans)\\
\giacinput{pour j de 1 jusque 10 faire print(j,j^2); fpour;}
tapez sur EXE, vous devez voir les carr\'es des entiers de 1 \`a 10.

{\bf Exercice~:} faire faire un carr\'e \`a la tortue en utilisant
une boucle.

{\bf Utilisation de l'\'editeur}\\
Modifions cet exemple pour faire afficher les carr\'es de 1 \`a $n$
en utilisant la syntaxe compatible Python et
l'\'editeur de programmes.
Tapez sur Back pour passer du shell \`a l'\'editeur de programmes.
Si on vous demande programme ou Tortue faites OK.
Ceci ouvre l'\'editeur avec une maquette de fonction
\verb|def f(x):|
V\'erifiez que la syntaxe Python
est activ\'ee (menu principal shift EXE ou HOME), sinon activez-la (8).
Remplacez \verb|x| par \verb|n|, puis 
d\'eplacez le curseur en fin de ligne et passez \`a la
ligne (EXE).
Tapez Shift-2 puis EXE (\verb|for|), placez
un \verb|j| entre \verb|for | et \verb|in range(|
puis un \verb|n| entre les parenth\`eses de \verb|range()|.
\`A la ligne suivante, tapez shift-3 7 (\verb|print|)
et validez (EXE), puis tapez \verb|j,j^2)|. Vous devriez avoir le 
programme suivant~:
\begin{giacprog}
def f(n):
  for j in range(1,n+1):
    print(j,j^2)
  return x
\end{giacprog}
Remplacez \verb|x| par \verb|n| dans \verb|return| (ou effacez la ligne).
N.B.: pour la puissance, on peut utiliser \verb|^| ou \verb|**|
dans KhiCAS
(il faut utiliser \verb|**| en Python).

Maintenant, tapez OK.
Si tout va bien, vous devez voir \verb|Success| dans la ligne d'\'etat.
Sinon, le num\'ero de ligne de la premi\`ere erreur est indiqu\'e ainsi que
le mot qui a provoqu\'e l'erreur. Le curseur est positionn\'e sur la ligne
o\`u l'erreur a \'et\'e d\'etect\'ee (il peut arriver que l'erreur soit 
situ\'ee avant mais d\'etect\'ee 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\'ees le sont par
rapport \`a cette traduction (donc des mots-clefs de fin de structure
comme \verb|end| peuvent avoir \'et\'e ajout\'ees).

Si le programme est syntaxiquement correct, vous pouvez le sauvegarder
depuis le menu principal (shift EXE ou HOME). Pour l'ex\'ecuter, revenez \`a la
ligne de commande en tapant la touche Back, tapez par
exemple \verb|f(10)|, vous devriez voir s'afficher
les carr\'es de 1 \`a 10.


{\bf 3i\`eme exemple~: Calcul de l'intervalle de confiance de terminale S}\\
En syntaxe Xcas.
On peut le saisir en ligne de commande
\giacinput{F(P,N):=[P-1.96*sqrt(P*(1-P)/N),P+1.96*sqrt(P*(1-P)/N)]}
On peut \'eviter les calculs redondants en utilisant une variable
locale (utiliser Toolbox Programmes
pour saisir fonction, local, return et ffonction)\\
\begin{giacprog}
fonction F(P,N) 
  local D; 
  D:=1.96*sqrt(P*(1-P)/N); 
  return [P-D,P+D]; 
ffonction;
\end{giacprog}

{\bf Exercice~} Cr\'eez un fichier \verb|carre.py| contenant
un script pour afficher un carr\'e avec la tortue.
Cr\'eez un fichier \verb|carren.py| 
pour afficher un carr\'e de $n$ pixels, en utilisant
une fonction d'argument $n$ et l'instruction \verb|repete|.

{\bf Solution~}
Depuis l'\'editeur de script, faire shift EXE ou HOME  puis 5 (Effacer).
Puis shift-4 \verb|efface|.
Ajouter 4 fois \verb|avance; tourne_gauche;|.
Appuyer sur OK pour tester. Sauvegardez (shift EXE ou HOME puis 
3 Sauvegarder comme).

Effacer \`a nouveau (shift EXE ou HOME 5 effacer)
Puis shift-4 \verb|efface|.
Ajouter avant la ligne \verb|efface|
\begin{verbatim}
def f(n):
  for j in range(4):
    avance(n)
    tourne_gauche
\end{verbatim}
puis apr\`es la ligne \verb|efface;| tapez par exemple \verb|f(40)|
puis OK. Ensuite faire shift EXE ou HOME 3 (Sauvegardez comme).

{\bf Un exemple de fonction non alg\'ebrique~: le calcul du PGCD de 2 entiers.}\\
Utiliser EXE pour passer \`a la ligne. 
En syntaxe Xcas 
\begin{giacprog}
fonction pgcd(a,b)
  tantque b!=0 faire
    a,b:=b,irem(a,b);
  ftantque;
  return a;
ffonction
\end{giacprog}
Le m\^eme en syntaxe Python 
\begin{giacprog}
def pgcd(a,b):
  while b!=0:
    a,b=b,a % b
  return a
\end{giacprog}
On v\'erifie \giacinput{pgcd(12345,3425)}

{\bf Mise au point}\\
La commande \verb|debug| permet 
d'ex\'ecuter une fonction en mode pas-\`a-pas, i.e.
visualiser l'\'evolution des variables instruction par instruction,
par exemple\\
\verb|debug(pgcd(12345,3425))|

\subsection{Quelques exemples}
Le r\'epertoire \verb|prog| de l'archive 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/khicasio.zip}{khicasio.zip}
contient quelques exemples de TP pour classes de seconde de l'IREM
de Grenoble~:
\begin{itemize}
\item utilisation de la tortue pour introduire la programmation textuelle
et la notion de fonction (PDF+corrections fichiers py)
\item longueur approch\'ee d'un arc de courbe (PDF+correction fichier py)
\item tableau de valeurs, recherche de minimum (enonce et morceaux
de programmes, fichier tabval.py)
\end{itemize}
ainsi que quelques autres programmes (avec fr\'equemment
une repr\'esentation graphique)~:
\begin{itemize}
\item fr\'equence dans un \'echantillon, intervalle de fluctuations (freq.py)
\item le paradoxe du duc de Toscane (toscane.py)
\item r\'esolution d'\'equation du second degr\'e (deg2.py)
\item dichotomie (dicho.py)
\item m\'ethode des rectangles (integr.py),
\item fractale de Mandelbrot (mandel.py)
\item un benchmark utilis\'e par tiplanet pour mesurer la vitesse
de l'interpr\'eteur (qcc.py)
\end{itemize}

\subsection{Commandes utilisables}
Contrairement aux adaptations de MicroPython propos\'ees par
les constructeurs (dont
celui de la Numworks N0110), la programmation en (simili-)Python 
dans KhiCAS n'est pas une application ind\'ependante. 
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 \`a un environnement Python avec les modules
\verb|math|, \verb|cmath|, \verb|random| (plus complet
que le module \verb|urandom| fourni par les constructeurs),
\verb|scipy|, \verb|numpy|, un petit module de graphiques
pixelis\'e 
(\verb|set_pixel(x,y,c)|, \verb|set_pixel()|
pour synchroniser l'affichage, \verb|clear()|,
\verb|draw_line(x1,y1,x2,y2,c)|, 
\verb|draw_polygon([[x1,y1],[x2,y2],...],c)|,
\verb|draw_rectangle(x,y,w,h,c)|, \verb|draw_circle(x,y,r,c)|,
la couleur+epaisseur+remplissage \verb|c| est un param\`etre optionnel,
\verb|draw_arc(x,y,rx,ry,t1,t2,c)| permet de tracer un arc
d'ellipse).
et pour remplacer \verb|matplotlib| on peut utiliser
les commande graphiques dans un rep\`ere de $\chi$CAS
(\verb|point|, \verb|line|, \verb|segment|, \verb|circle|,
\verb|barplot|, \verb|histogram| et les commandes \verb|plot...|).
De plus, vous pouvez travailler avec des expressions et faire
du calcul formel dessus.
Pour la liste compl\`ete des commandes
et une pr\'esentation d\'etaill\'ee, on renvoie \`a la documentation
de Xcas.

\section{Interpr\'eteur MicroPython int\'egr\'e} \label{sec:micropy}
$\chi$CAS est maintenant fourni avec son propre interpr\'eteur MicroPython
(qui n'est pas identique \`a celui fourni par Numworks).
Pour passer dans
$\chi$CAS de l'interpr\'eteur Xcas \`a MicroPython et r\'eciproquement
vous pouvez taper la commande \verb|python| ou \verb|xcas| dans
le shell sur une ligne vide. Ces commandes sont accessibles
dans le menu rapide shift ).

Attention, si vous lancez MicroPython apr\`es avoir travaill\'e
avec Xcas ou/et avec le tableur, il peut ne pas y avoir assez
de m\'emoire pour le tas MicroPython, dans ce cas vous risquez
de perdre votre session de travail, pensez \`a la sauvegarder.
Par d\'efaut, 40K sont r\'eserv\'es pour MicroPython. Vous
pouvez modifier cette valeur jusqu'\`a 64K dans la configuration
(shift EXE ou Home puis touche ln). Si vous choisissez une valeur
haute, il peut \^etre n\'ecessaire de quitter $\chi$CAS
et de le r\'eouvrir pour que le tas puisse \^etre allou\'e
dans une zone m\'emoire contigu\"e (probl\`eme de fragmentation
du tas sinon). 

Remarque~: lorsque l'interpr\'eteur Xcas est actif, si vous passez
en argument \`a la commande \verb|xcas| ou \verb|python| le
nom de variable d'une fonction que vous avez programm\'ee, cela
affiche son texte source sous forme d'une chaine de caract\`eres
en syntaxe Xcas ou Python. Vous pouvez donc programmer en syntaxe
Xcas et traduire ensuite en Python si vous devez vous
conformer \`a des r\`egles qui imposent ce langage.

\subsection{Les modules math, cmath, random}
Ce sont les modules natifs fournis par MicroPython (\verb|urandom|
a \'et\'e renomm\'e \verb|random|), et qui sont
conforme au standard. D'autres modules MicroPython standard
qui ne sont pas destin\'es \`a faire des maths sont disponibles.

\subsection{Le module graphic}
Il s'agit d'un module natif MicroPython qui exporte de Xcas des fonctions
de trac\'e pixelis\'es. Une partie des commandes est accessible
depuis le menu rapide shift 0.
Ce module a des synonymes, \verb|kandinsky| et \verb|casioplot|
afin de faciliter l'utilisation de scripts Python pour
calculatrices Numworks (Epsilon) et Casio.

\subsection{Le module matplotl}
Il s'agit d'un module natif MicroPython qui exporte de Xcas des fonctions
de trac\'e rep\'er\'e et vise \`a une certaine compatibilit\'e avec
le module \verb|matplotlib| (ou un de ses sous-modules) sur PC.
Une partie des commandes est accessible
depuis le menu rapide shift \verb|.|

\subsection{Le module arit}
C'est un module natif qui exporte de Xcas
des fonctions d'arithm\'etique enti\`ere~:
test de primalit\'e et prochain nombre premier (par Miller-Rabin),
factorisation d'entiers pas trop gros (d\'etection
par Pollard-rho du plus petit facteur premier, donc jusqu'\`a environ
9 chiffres), pgcd et identit\'e de B\`ezout, indicatrice d'Euler (si
on sait factoriser). J'y ai aussi inclus
deux fonctions de conversion liste vers chaine
de caract\`eres pour faciliter l'enseignement d'un peu de cryptographie.


\subsection{Le module linalg}
Il permet de manipuler les listes comme des vecteurs et les listes
de listes comme des matrices. Contrairement \`a Xcas,
Python n'est pas un langage sp\'ecifiquement adapt\'e aux maths,
il faut utiliser des
commandes pr\'efix\'ees \verb|add, sub, mul| pour effectuer
les op\'erations arithm\'etiques de base \verb|+ - *| sur les
vecteurs et matrices repr\'esent\'es par des listes.

Le module \verb|linalg| est un module natif, qui utilise Xcas
pour effectuer la quasi-totalit\'e des calculs.

\subsection{Le module numpy}
C'est une surcouche du module \verb|linalg| qui d\'efinit une
classe \verb|array| pour repr\'esenter les vecteurs et les matrices.
On peut alors utiliser \verb|+ - *| pour faire les op\'erations
de base sur vecteurs et matrices.

Le module \verb|numpy| n'est pas un module natif, c'est un texte
source \'ecrit en Python. Son importation consomme donc de la m\'emoire
RAM. Vous pouvez \'ecrire votre propre version de \verb|numpy.py|
et la stocker dans le scriptstore, elle prendra alors la pr\'ec\'edence
sur la version utilis\'ee par d\'efaut. Cette derni\`ere vise \`a assurer
un minimum de compatibilit\'e avec le module du m\^eme nom sur PC.
Bien que non natif, ce module est disponible en mode examen
(le texte source par d\'efaut est int\'egr\'e au code source de
l'interpr\'eteur MicroPython).
%\begin[language=Python]{lstlisting}
\begin{verbatim}
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)
\end{verbatim}
%\end{lstlisting}

\section{Applications additionnelles}
Les applications additionnelles sont accessibles en tapant shift Ans.
Il y a actuellement un tableur, le tableau p\'eriodique des \'el\'ements
(d'apr\`es Maxime Friess),
et trois exemples d'addin qui peuvent servir de mod\`ele aux
programmeurs~: la suite de Syracuse (tr\`es simple), la
fractale de Mandelbrot et les bassins d'attraction de la méthode
de Newton, et un jeu
de mastermind (qui peut aussi servir de passe-temps).

\section{Le tableur} \label{sec: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 (shift EXE ou Home puis configuration), mais attention, chaque cellule
utilise de la m\'emoire, 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\'emoire de la Numworks est tr\`es limit\'ee,
s'il n'y a pas assez de m\'emoire lors d'une allocation, vous
perdrez votre session de travail.
Pensez \`a faire une sauvegarde de votre session de temps en temps!

La syntaxe pour cr\'eer une formule est identique \`a celle d'un tableur
classique, on tape sur shift = puis on entre la formule, avec
des r\'ef\'erences relatives (par exemple \verb|=a1+1|)
ou absolues (\verb|=$a$1+1|). Pour saisir une cellule après avoir
tapé \verb|=|, on peut
déplacer le curseur vers la cellule cible, à condition de commencer
par un déplacement de curseur vers le haut ou vers le bas (sinon
le déplacement vers la droite ou la gauche déplace dans la ligne
de commande, pas dans le tableur).
On peut utiliser les commandes
de Xcas ainsi que des fonctions qu'on a programm\'ees.

Il y a des assistants de saisie sp\'ecifiques au tableur
dans les menus rapides shift 1, 2 et 3.
Par exemple pour g\'en\'erer des entiers cons\'ecutifs,
taper shift 3 puis OK ce qui cr\'ee une ligne de commande
contenant \verb|range(|, il suffit de mettre un entier $a$ ou deux entiers
$a$ et $b$ en arguments pour cr\'eer la liste des entiers entre 0 et $a-1$
ou entre $a$ et $b-1$ et la dispatcher sur la colonne.

Autre exemple, pour
avoir un tableau de valeurs de fonctions, se placer au d\'ebut
d'une colonne vide dont la colonne \`a droite est aussi vide
et taper shift 3, s\'electionner \verb|tablefunc| puis passer
en argument l'expression, par exemple \verb|sin(x)| (ou \verb|f(x)|
si vous avez d\'efini une fonction \verb|f|). Vous pouvez
ensuite r\'egler la valeur de d\'ebut et le pas dans le tableur.
Pour une suite r\'ecurrente, se placer en haut d'une colonne vide
et utiliser la commande \verb|tableseq| du menu rapide shift 3.

Pour s\'electionner une plage de cellules, taper simultan\'ement sur
shift et une touche de direction, vous pouvez ensuite
relacher shift et d\'eplacer le curseur en fin de s\'election.
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\'election 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\'election des 2 colonnes avant de choisir la commande.
Par exemple, en 1\`ere ligne, 1\`ere colonne, tapez shift 3
s\'electionnez \verb|range| puis compl\'etez en \verb|range(6)|
comme valeurs de X
puis en face en 2\`eme colonne entrez des valeurs et Y.
D\'eplacez le curseur en 1\`ere ligne et en 1\`ere colonne,
puis shift-curseur
vers le base puis d\'eplacements du
curseur pour rejoindre l'autre extr\'emit\'e de la s\'election,
puis shift 2, puis par exemple \verb|polygonscatterplot|.
Pour voir le graphique, tapez shift 6. Pour voir sur le m\^eme graphique
la droite de r\'egression lin\'eaire correspondante, vous pouvez recommencer
la proc\'edure ou bien recopier la cellule contenant
la formule de \verb|polygonscatterplot| avec shift-copy shift-copy
et la coller avec shift paste en-dessous, puis la modifier (shift 4 OK)
en rempla\c{c}ant
\verb|polygonscatterplot| par \verb|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 \`a partir de la liste en utilisant la commande
\verb|matrix(l,c,liste)| o\`u \verb|l,c| sont les dimensions
de la matrice (c'est ce que fait l'assistant \verb|scatterplot|
du menu rapide de statistiques 2d (shift 2) si on s\'electionne
la plage de cellules auparavant).

Dans le menu accessible depuis la touche shift EXE ou HOME, vous pouvez ins\'erer
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\'ee dans cette variable, que vous pouvez utiliser ensuite depuis
le shell.

Si vous entrez dans une cellule une formule donnant un r\'esultat vecteur
ou matrice, celle-ci sera dispatch\'ee par d\'efaut
dans plusieurs cellules. On peut modifier cela dans la configuration
du tableur.



\section{Raccourcis claviers.} \label{sec:clavier}
\begin{itemize}
\item shift * (N0110 verrouillées, N0115, N0120): table de caractères
\item shift + (N0110 verrouillées, N0115, N0120): indentation ou aide
\item La touche d'effacement en mode alphab\'etique  a \'et\'e modifi\'ee
  (dans tout l'OS) pour effacer et ne pas renvoyer \verb|%|,
  car cela rend la correction d'erreur de frappes tr\`es p\'enible. Pour
  saisir \verb|%|, tapez shift \verb|/| (ce qui est facile
  \`a retenir quand on programme un peu).
\item on peut taper alpha-shift-\verb|"| pour saisir \verb|'|
  \item le caract\`ere \verb|\| est accessible via shift-\verb|-|.
  \item shift-1 \`a shift-6: selon le mode (Xcas ou Python)
    voir les l\'egendes
\item shift-7 (M) matrice, 8 complexes, 9 arithm\'etique enti\`ere,
  \verb|(| listes, \verb|)| programmation,
  \verb|0| probas \verb|.| r\'eels,
  \verb|x10^| arithm\'etique polynomiale,
  %, \verb|)|
  Si MicroPython est activ\'e, shift 7 linalg, 8 numpy,
  9 arithm\'etique enti\`ere, \verb|(| listes, \verb|)| programmation,
  \verb|0| matplotl, \verb|.| graphic, \verb|x10^| couleurs
\item Si Xcas est actif,
  \verb|=>| suivi d'une unit\'e physique effectue une conversion
  d'unit\'e, 
  \verb|=>| suivi d'une fonction permet d'ex\'ecuter des actions:\\
  \verb|=>*| \'ecriture sous forme de produit (pour une unit\'e, \'ecriture
  en utilisant les unit\'es fondementales du syst\`eme MKSA),\\
  \verb|=>+| \'ecriture sous forme de somme (pour une unit\'e, \'ecriture
  sous forme le plus simple possible),\\
  \verb|=>/| \'ecriture sous forme de quotient,\\
  \verb|=>sin|, \verb|=>cos|, \verb|=>tan|
  conversion vers des sinus, cosinus ou tangentes.\\
  \verb|=>,| permet de chronom\'etrer une \'evaluation,\\
  \verb|16=>=>| \'ecrit les entiers en base 16,
  \verb|10=>=>| en base 10, \verb|8=>=>| en base 8
\item shift-) 8 EXE permet de changer d'interpr\'eteur.
\end{itemize}

Dans l'\'editeur de programmes~:
\begin{itemize}
\item touches curseur shift\'ees: d\'eplacement en d\'ebut/fin de ligne/fichier.
\item shift copy ou shift et touche curseur simultan\'ement:
  d\'ebut de s\'election. D\'eplacer le curseur \`a l'autre
extr\'emit\'e puis taper sur DEL pour effacer la s\'election
et la copier dans le presse-papier ou sur
shift copy pour copier la s\'election sans l'effacer.
Pour coller le presse-papier, taper shift paste.
%Taper sur DEL pour annuler.
\item EXE: si une recherche/remplacement
de mot est active (apr\`es avoir fait shift EXE 6 ou Home 6 selon le modèle),
recherche l'occurence suivante d'un mot. Sinon, passe \`a la ligne.
\item DEL efface le caract\`ere pr\'ec\'edent ou la s\'election.
\item shift PASTE: copie le presse-papier
%\item AC/ON: annule la s\'election ou annule la recherche, sinon
%efface la ligne courante et la copie dans le presse-papier
\item var: bascule entre l'\'editeur et la figure tortue
\item Back: quitte l'\'editeur et revient en ligne de commandes. On
peut revenir ensuite \`a l'\'editeur en tapant \`a nouveau Back.
\end{itemize}

\section{Moteur de rendu 3d et g\'eom\'etrie.} \label{sec:geo3d}
La derni\`ere version de KhiCAS pour Numworks fournit un moteur
de rendu de graphique 3d, inspir\'e au d\'epart par le script 
\ahref{https://my.numworks.com/python/schraf/graph3d}{Python 3d} de Eric
Schrafstetter. 

Ce moteur de rendu apparait si vous créez une figure 3d
ou si vous entrez dans le shell ou
l'\'editeur de programmes
une commande renvoyant un graphe dans l'espace, par exemple
depuis le menu Toolbox, sous-menu 3d (raccourci \verb|(|)~:
\begin{itemize}
\item un plan, donn\'e par 3 points ou une \'equation cart\'esienne
par exemple \giacinput{plan(z=x)}
\item une surface $z=f(x,y)$ avec la commande \verb|plot(f(x,y))|
ou la commande \verb|plotfunc(f(x,y),[x,y],nstep=N)|
\item une surface param\'etr\'ee avec la commande \verb|plotparam|
\item un poly\`edre, en particulier les poly\`edres r\'eguliers
  (solides de Platon)
  correspondent \`a une commande \verb|tetrahedron|, \verb|cube|,
\verb|octahedron|, \verb|dodecahedron|, \verb|icosahedron|
\item une droite, un segment donn\'ee par 2 points ou par 2
  \'equations cart\'esiennes (droite uniquement).
\item une courbe gauche param\'etr\'ee, par exemple
\giacinput{plotparam([t,cos(t),sin(t)])}
\end{itemize}
Depuis le moteur, appuyez sur 
sur shift EXE ou HOME (ou sur Toolbox sauf depuis l'application
de géométrie 3d) pour modifier les
r\'eglages num\'eriquement et pour voir la liste des raccourcis
clavier, dont voici les plus importants~:
\begin{itemize}
\item les touches du curseur permettent de changer de point de vue.
Pendant le changement de point de vue, le calcul/affichage de la
sc\`ene est effectu\'e avec une pr\'ecision plus faible et
peut être interrompu en appuyant sur la touche Back.
\item la touche 5 permet de revenir au point de vue initial
\item la touche $y^x$ recalcule et affiche la sc\`ene 3d en
  pr\'ecision maximale, ce qui peut \^etre assez long. Vous pouvez
interrompre le calcul pr\'ecis en appuyant sur la touche Back
\item les touches \verb|+| et \verb|-| permettent de zoomer in ou out,
les touches \verb|*| et \verb|/| de faire un autoscale ou une
orthonormalisation
\item les touches 7,9,1,3 permettent de se d\'eplacer dans la sc\`ene
  3d selon $x$ et $y$.
\end{itemize}

Il est possible de cr\'eer des figures g\'eom\'etriques 2d ou 3d, et
de faire des calculs de g\'eom\'etrie analytique. Ouvrez l'\'editeur
de programmes, effacez si n\'ecessaire le patron \verb|def ...| ou
\verb|efface ...|, puis entrez une instruction par ligne. Pour passer
\`a la ligne, utilisez la touche EXE, pour afficher la construction
utilisez la touche OK. Les principales commandes de g\'eom\'etrie
se trouvent dans le menu Toolbox. Le menu rapide shift \verb|+|
affiche les commandes de g\'eom\'etrie les plus fr\'equentes,
le menu shift \verb|*| permet de donner facilement des couleurs
aux objets g\'eom\'etriques cr\'e\'es.

%% \section{Remarques}
%% La m\'emoire vive (RAM) disponible sur la Numworks est vraiment
%% tr\`es faible
%% (esp\'erons que ce sera modifi\'e dans les prochains mod\`eles!).
%% $\chi$CAS impl\'emente des garde-fous lorsque la m\'emoire est satur\'ee,
%% mais vous risquez de perdre le travail qui n'a pas \'et\'e
%% sauvegard\'e dans $\chi$CAS, ou pire dans l'ensemble des applications
%% de la calculatrice si elle reboote.

%% Il est donc conseill\'e de transf\'erer vos
%% programmes sur un ordinateur en branchant la calculatrice
%% et en faisant pointer sur l'ordinateur le navigateur
%% Chromium ou compatible sur
%% \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{ce site}
%% ou avec les fonctions d'\'echange avec Xcas PC.

%% Il n'y
%% a pas pour le moment de m\'ecanisme de sauvegarde sur la flash des
%% donn\'ees. Ce serait bienvenu, d'une part cela lib\'ererait un peu
%% de RAM, d'autre part cela permettrait d'\^etre r\'esistant \`a un crash
%% et d'avoir une biblioth\`eque bien plus importante de programmes
%% mais aussi de sessions compatibles Xcas, Xcas pour Firefox et $\chi$cas
%% pour Casio (qu'il serait agr\'eable de pouvoir \'echanger sur le
%% workshop Numworks ou sur un autre espace par exemple sur tiplanet).

%% Certains changements de Khi affectent l'application Python
%% ou l'ensemble des applications~:
%% \begin{itemize}
%% \item La prise en compte du clavier a \'et\'e un peu modifi\'ee,
%%   cf. la section \ref{sec:clavier}.
%% %% \item L'espace de stockage pour les scripts passe de 16K \`a 20K,
%% %%   mais une partie de cet espace sert \`a stocker la session courante
%% %%   de $\chi$CAS.
%% %% \item La taille maximale d'un script \'editable dans l'application
%% %%   Python est ramen\'ee de 16K \`a 12K
%% %%   Vous pouvez avoir plusieurs scripts.
%% %%   Vous pouvez aussi \'editer vos scripts depuis $\chi$CAS en b\'en\'eficiant
%% %%   des plus de l'\'editeur de $\chi$CAS (parenthese matching, choix
%% %%   de la petite fonte de caract\`eres, plus besoin de faire du d\'efilement
%% %%   horizontal, test de la syntaxe directement depuis l'\'editeur, etc.).
%% %%   Vous pouvez aussi mettre au point vos scripts
%% %%   compatibles depuis le d\'ebuggueur de $\chi$CAS et les ex\'ecuter
%% %%   dans MicroPython si vous avez besoin de plus de vitesse que
%% %%   celle de l'interpr\'eteur de $\chi$CAS.
%% %% \item l'espace de travail pour MicroPython passe de 16K \`a 28K.
%% %%   Si vous \^etes limit\'e par l'espace m\'emoire de MicroPython
%% %%   et si votre script est compatible $\chi$CAS, sachez que l'espace
%% %%   de travail de $\chi$CAS est de 56K environ, et que la taille
%% %%   des objets de base est environ 3 fois plus faible dans $\chi$CAS
%% %%   (8 octets pour un petit entier ou flottant contre 24 en MicroPython).
%% %%   Par contre, la taille d'un script interpr\'et\'e dans $\chi$CAS
%% %%   est importante (de l'ordre de 6K pour l'exemple de Mandelbrot dont
%% %%   le source fait 440 octets).
%% %% \item 2 fonctions ont \'et\'e rajout\'ees dans MicroPython~: \verb|get_key()|
%% %%   qui renvoie un code touche (cf. \ref{sec:os}), et \verb|Pause(n)|
%% %%   qui attend approximativement $n$ secondes.
%% %%   On peut \`a nouveau utiliser un seul entier pour
%% %%   d\'ecrire une couleur.
%%   \item L'espace de travail pour les calculs hors de $\chi$CAS
%% est divis\'e par 2, afin de laisser de la place pour les calculs
%% dans $\chi$CAS. Je pense que cela suffit aux besoins des applications
%% interactives de Epsilon, pour les calculs un peu plus gros,
%% vous pouvez utiliser $\chi$CAS qui est g\'en\'erallement
%% plus rapide ou plus pr\'ecis. Quelques exemples~:
%% \begin{itemize}
%% \item calcul num\'erique
%%   $$ \sum_{n=1}^{1000} \sin(\cos(n+.5))$$
%%   $\chi$CAS: 0.64s, Epsilon: 1.5s environ
%%   (mesur\'e en prenant la somme jusque 10000 et en divisant par 10)
%% \item calcul matriciel exact, $a$ une matrice 4,4 inversible
%%   \`a coefficients entiers
%%   entre 0 et 10, on calcule \verb|det(1/a^32)|, il faut environ 0.1
%%   seconde avec $\chi$CAS et 5 secondes avec Epsilon.
%% \item le calcul d'une int\'egrale num\'erique g\'en\'eralis\'ee telle
%%   que $$ \int_{0.0}^1 \ln(x) \ dx$$
%%   renvoie undef avec Epsilon.
%%   Pr\`es d'une extr\'emit\'e singuli\`ere
%%   $$ \int_{0.001}^1 x \cos\left(\frac{1}{x}\right) \ dx $$
%%   $\chi$CAS renvoie 0.0181170904, Epsilon 0.01793743 (erreur relative 1\%)
%% \end{itemize}
%% \end{itemize}
%% Vous pouvez modifier ces param\'etrages en modifiant les sources de
%% Delta (les fichiers \`a modifier
%% sont \verb|poincare/include/poincare/tree_pool.h|,
%% \verb|apps/code/app.h|,
%% \verb|ion/include/ion/storage|) et en recompilant
%% (section \ref{sec:epsilon12}).

\section{Copyright, licences et remerciements}
\begin{itemize}
\item OS \ahref{https://github.com/numworks/epsilon}{Epsilon 15.5}
  de la Numworks, (c) 2021 Numworks.
  Sous licence
  \ahref{https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode}
      {Creative Commons Attribution-NonCommercial-
        ShareAlike 4.0 International Public License}\\
      Modifications par Damien Nicolet et Bernard Parisse, (c) 2019 et 2021
      (projets Delta, Khi), sous la m\^eme licence. Modifications par
      l'\'equipe du projet
      \ahref{https://github.com/Omega-Numworks/Omega}{Omega}
  (c) 2021 sous la m\^eme licence.
  \item Giac et $\chi$CAS, noyau de calcul (c) B. Parisse et R. De Graeve, 2024.
    Les calculs en entiers sont effectu\'es avec
    \ahref{https://gmplib.org/}{GMP}, les flottants multip\'ecision
    avec \ahref{https://www.mpfr.org/}{MPFR},
    l'arithm\'etique d'intervalle avec
    \ahref{https://gforge.inria.fr/projects/mpfi/}{MPFI}
\item Interface de $\chi$CAS adapt\'ee par B. Parisse \`a partir
de l'interface utilisateur du code source d'Eigenmath
cr\'e\'ee par Gabriel Maia et de l'interface utilisateur de Xcas.\\
  License d'utilisation de $\chi$CAS: GPL2.
  (voir le d\'etail
des conditions dans le fichier
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/LICENSE.GPL2}{LICENSE.GPL2} 
ou sur la page
\ahref{https://www.gnu.org/licenses/old-licenses/gpl-2.0.fr.html}{GPL2}
du site de la Free Software Foundation).
\item
Le code source de $\chi$CAS ainsi que des librairies 
GMP, MPFR, MPFI et de la version modifi\'ee de l'OS Numworks, sont
disponibles
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/khi.tgz}{pour la version N0110 non verrouillée}
et \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/khib.tgz}{pour les autres modèles}, qui utilisent aussi un
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/numworks/launch.tgz}{lanceur d'application externe}.
\item
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/apps.tar}{L'archive apps.tar pour N0110 non verrouillée} 
contient d'autres applications, dont les licences sont (sauf
erreur involontaire de ma part)~:
\begin{itemize}
\item Nofrendo sous licence \ahref{https://www.gnu.org/licenses/old-licenses/lgpl-2.1.fr.html}{LGPL2}
\item Peanut-GB sous licence \ahref{https://opensource.org/licenses/MIT}{MIT}
\item Hexedit sous licence \ahref{https://opensource.org/licenses/BSD-2-Clause}{BSD2}
\end{itemize}
\item
  Remerciements \`a Damien Nicolet pour le premier portage de giac
  sur Numworks N100 (au prix d'une modification mat\'erielle), pour
  le portage de la newlib (librairie C/C++) sur N110 et la maintenance
  des sources au format git et la compatibilit\'e avec les sources
  de Numworks. Sans lui, ce portage n'existerait pas.\\
  Remerciement \`a Jean-Baptiste Boric pour tests et conseils,
  \`a Maxime Friess pour son squelette d'application hello
  et \`a toute l'\'equipe d'Omega pour les am\'eliorations qu'ils ont
  apport\'e \`a Epsilon.\\
  Remerciement \`a l'\'equipe de tiplanet, en particulier Xavier Andr\'eani,
  Lionel Debroux et Adrien Bertrand, pour le forum de discussion
  et tout le travail de
  mise en valeur de $\chi$cas (stockages d'archives, articles, concours).\\
  Remerciement à Yaya.Cout pour de longues discussions par email
  et du code pour accéder aux informations des firmwares verrouillés
  et la rédaction de ce \ahref{https://github.com/Yaya-Cout/KhiCAS_guide/blob/626b9786ff19504152628cfa42447c87ab73f648/KhiCAS_guide.pdf}{Tutoriel (par fmOOmf et Yaya-Cout)}.\\
  Remerciements au (ou à la) mystérieux ScarlettSpell, créateur
du site Nwagyu (aujourd'hui abandonné),
dont le portage de KhiCAS en application externe Numworks
m'a fortement incité à créer la nouvelle version de KhiCAS pour les Numworks
récentes verrouillées.
\item le tableau p\'eriodique des \'el\'ements est un portage de
  \ahref{https://github.com/M4xi1m3/nw-atom}{l'application de Maxime Friess} 
  avec son autorisation de diffusion sous licence GPL.
%\item Remerciement \`a Numworks France pour le pr\^et d'une
%calculatrice et une licence d'utilisation de l'\'emulateur.
\end{itemize}

\section{D\'eveloppement en C/C++.} \label{sec:dev}
Cette section s'adresse aux utilisateurs avanc\'es qui souhaitent programmer
leur calcultrice en exploitant toute sa puissance, donc
sans \^etre limit\'e par la faible quantit\'e de m\'emoire
disponible pour des scripts Python et la lenteur relative du
langage interpr\'et\'e. Le syst\`eme non modifi\'e
de la Numworks permet de le faire, mais il est difficile de
le maitriser, au-del\`a de modifications simples du code
existant (par exemple modifier la valeur de certains param\`etres),
il faut bien connaitre C++, la programmation orient\'e objet
et se limiter \`a une librairie standard tr\`es spartiate.
Cela limite \`a mon avis le nombre de d\'eveloppeurs
et la vitesse de d\'eveloppement sur cette plateforme,
encore plus si on est habitu\'e \`a un
environement de d\'eveloppement frugal, personnellement
j'utilise \verb|emacs| comme \'editeur de texte et un terminal,
les arborescences \`a plusieurs niveaux et les espaces de noms
imbriqu\'es d'Epsilon sont un cauchemar. Le temps n\'ecessaire \`a
la compilation d'Epsilon est d'ailleurs un indicateur de cette
complexit\'e.

Un autre probl\`eme est que modifier
Epsilon n\'ecessite d'utiliser la m\^eme licence de logiciel,
on ne peut donc pas d\'evelopper du logiciel libre.

Damien Nicolet et moi-m\^eme avons d\'evelopp\'e des modifications
autour de Epsilon, qui permettent de lancer un firmware d'extensions
\`a partir de Epsilon. C'est le projet Delta/Khi, qui permet d'utiliser la
\verb|newlib|, une impl\'ementation compl\`ete 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\'eratif tr\`es 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\'ecessite une dizaine de lignes de code,
programmer la fractale de Mandelbrot et les bassins
d'attraction ou
le jeu de mastermind font une bonne centaine de lignes (ces
trois exemples se trouvent dans le fichier \verb|kadd.cc| du
source de \verb|giac|) et l'interface
du tableur de $\chi$CAS de l'ordre d'un millier de lignes.

{\bf Licences}\\
L'utilisation du SDK de base de l'OS (\ref{sec:os}) vous impose
de choisir une licence permettant d'utiliser les services de base
d'un OS propri\'etaire, 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.

\subsection{Installation de l'environnement de d\'eveloppement.}
Je d\'ecris l'installation sous Linux debian/ubuntu compatible
depuis un terminal avec comme shell \verb|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
\ahref{https://www.virtualbox.org/wiki/Downloads}{Virtualbox} et
y mettre une distribution Linux debian-compatible, par exemple
\ahref{https://xubuntu.org/}{xubuntu}.


On installe les packages n\'ecessaires pour compiler giac et pour
cross-compiler pour le processeur ARM~:
\begin{verbatim}
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
\end{verbatim}

%% \subsubsection{Epsilon 12} \label{sec:epsilon12}
%% Pour r\'ecup\'erar les sources, utilisez une des deux m\'ethodes suivantes
%% \begin{itemize}
%%   \item on r\'ecup\`ere tout en une seule commande~:
%% \begin{verbatim}
%% git clone https://github.com/Delta-NumWorks/delta
%% \end{verbatim}
%% \item
%%   on r\'ecup\`ere s\'epar\'ement Delta (la version modifi\'ee de Epsilon),
%%   puis les librairies n\'ecessaires pour compiler giac, puis giac.
%%   Cela assure d'avoir la version de Giac la plus \`a jour.
%% \begin{verbatim}
%% wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/delta12.tgz
%% tar xvfz delta12.tgz
%% cd delta
%% wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tgz
%% tar xvfz ext.tgz 
%% cd ext
%% wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac/giac_unstable.tgz
%% tar xvfz giac_unstable.tgz
%% cd ../..
%% \end{verbatim}
%%   \end{itemize}

%% Compilation pour la Numworks.
%% Les librairies n\'ecessaires \`a la compilation
%% de KhiCAS pour Numworks
%% sont pr\'ecompil\'ees dans le r\'epertoire \verb|ext/n0110/lib|. Il
%% faut juste compiler Delta.
%% \begin{verbatim}
%% cd delta
%% make V=1 USE_LIBA=0 EPSILON_DEVICE_BENCH=0 EPSILON_USB_DFU_XIP=0 EPSILON_ONBOARDING_APP=0 EPSILON_BOOT_PROMPT=update epsilon.dfu 
%% \end{verbatim}
%% Si vous voyez des messages tels que \verb|... switch -mcpu=cortex-m7 conflicts...|, c'est que le cross-compilateur ARM de votre distribution
%% Linux est trop ancien. Allez sur le site du
%% \ahref{https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads}{ARM SDK}, descendez
%% jusqu'\`a faire apparaitre la version 7 (vous pouvez essayer une version
%% plus r\'ecente mais les binaires risquent de ne pas fonctionner
%% sur votre distribution Linux), t\'el\'echargez
%% pour Linux x64 et ex\'ecutez la commande\\
%% \verb|cd && tar xvfj Downloads/gcc-arm-none-eabi-7-2018-q2-update-linux.tar.bz2|\\
%% puis ajoutez dans votre fichier \verb|~/.bashrc| la ligne\\
%% \verb|export PATH=~/gcc-arm-none-eabi-7-2018-q2-update/bin:$PATH|\\
%% sauvegardez, puis tapez les commandes\\
%% \verb|source ~/.bashrc|\\
%% \verb|cd delta|\\
%% \verb|make clean|\\
%% \verb|make V=1 USE_LIBA=0 EPSILON_DEVICE_BENCH=0 EPSILON_USB_DFU_XIP=0 EPSILON_ONBOARDING_APP=0 EPSILON_BOOT_PROMPT=update epsilon.dfu|

%% Les fichiers firmware d'extension \verb|dfu| sont dans le r\'epertoire
%% \verb|output/device/release/n0110|.
%% Pour les flasher sur la calculatrice faire
%% \begin{verbatim}
%% dfu-util -i0 -a0 -D  output/device/release/n0110/epsilon_cc.dfu #-s 0x90000000
%% dfu-util -i0 -a0 -D  output/device/release/n0110/epsilon_gpl.dfu #-s 0x92000000
%% \end{verbatim}
%% Le premier fichier est le firmware Epsilon avec les modifications
%% du projet Delta, qui fournit une interface pour programmer la calculatrice
%% en C et permet d'appeler une fonction de prototype
%% \verb|int ext_main()|, fonction qui doit \^etre
%% impl\'ement\'ee dans le deuxi\`eme firmware,
%% l'adresse fixe de \verb|ext_main| doit \^etre \verb|0x92000000| 
%% (plus pr\'ecis\'ement \verb|0x92000001| en mode Thumb du processeur ARM).
%% Par exemple, l'impl\'ementation de la fonction \verb|ext_main|
%% dans le firmware KhiCAS (sous licence GPL) compil\'e ici
%% lance le shell KhiCAS. On peut remplacer le firmware KhiCAS par
%% un autre firmware impl\'ementant une fonction
%% \verb|extern "C" int ext_main();| et
%% link\'ee \`a l'adresse fixe en \verb|0x92000001|
%% sans modifier le firmware Delta. Pour faire cela, il faut mettre
%% une ligne du type \verb|*(.text.ext_main)|
%% au d\'ebut de la section de la flash gpl
%% dans le fichier du linker (\verb|flash.ld|).

%% Pour compiler le simulateur, faire
%% \begin{verbatim}
%% cd 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
%% \end{verbatim}
%% Essayez mantenant de taper \verb|./simu| puis de lancer Khicas sur
%% le simulateur. 

%% Si vous modifiez un fichier de \verb|giac|, il faut mettre \`a jour
%% la libraire pour les deux architectures et la recopier
%% \begin{verbatim}
%% cd ext/giac-1.5.0/src
%% make -f Makefile.numworks.gmp
%% /bin/cp device/libgiac.a ../../n0110/lib
%% make -f Makefile.numworks.simulator
%% /bin/cp simu/libgiac.a ../../simulator/lib
%% cd ../../..
%% \end{verbatim}
%% % # ln -sf config.h.numworks.gmp config.h
%% % # make -f Makefile.numworks.gmp clean
%% % # make  -f Makefile.numworks.simulator clean
%% puis forcer l'\'edition de liens du firmware
%% \begin{verbatim}
%% /bin/rm output/device/release/n0110/epsilon*elf
%% make V=1 USE_LIBA=0 EPSILON_DEVICE_BENCH=0 EPSILON_USB_DFU_XIP=0 EPSILON_ONBOARDING_APP=0 EPSILON_BOOT_PROMPT=update epsilon.dfu
%% \end{verbatim}
%% et celle du simulateur
%% \begin{verbatim}
%% /bin/rm output/device/release/simulator/epsilon.elf
%% make V=1 DEBUG=1 PLATFORM=simulator
%% \end{verbatim}


\subsubsection{Epsilon 15.3.1/Khi (calculatrice), 12.3 (simulateur)}
\label{sec:epsilon12}
{\bf Simulateur Delta}\\
Pour r\'ecup\'erar les sources du simulateur, faire
\begin{verbatim}
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/delta_simu.tar.bz2
tar xvfj delta_simu.tar.bz2 
\end{verbatim}
Pour compiler le simulateur, vous pouvez lancer le script
\verb|delta/mksimu| 
ou vous pouvez ex\'ecuter les instructions suivantes
\begin{verbatim}
cd delta/ext/giac-1.6.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
\end{verbatim}
Essayez mantenant de taper \verb|./simu| puis de lancer Khicas sur
le simulateur en tapant \verb|\| ou \verb|$| selon le clavier (cette touche
permet de simuler l'appui sur la touche HOME).

Attention, le support de MicroPython et de l'ex\'ecution en mode pas \`a pas
n'est pas compatible, \`a cause du code assembleur de certaines
fonctions situ\'ees dans les fichiers \verb|delta/python/src/py/nlr*|. En
cons\'equence si vous s\'electionnez MicroPython pour
\'evaluer dans KhiCAS, le simulateur plantera d\`es la premi\`ere
\'evaluation. Pour contourner ce probl\`eme,
il faut compiler ces fichiers \verb|nlr*| en mode release
puis copier les fichiers objets obtenus dans le r\'epertoire \verb|debug|
d'Epsilon/Delta. Pour faire cela, vous pouvez lancer le script
\verb|delta/mksimu|, puis le script \verb|delta/cpnlr|.
La prochaine ex\'ecution de \verb|delta/mksimu| devrait
alors donner un ex\'ecutable \verb|simu| qui permet d'activer
simultan\'ement l'\'evaluation MicroPython et la mise au point.

{\bf Version du source calculatrice avec le multi-boot Khi}~: faites
\begin{verbatim}
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/khi2.tgz
tar xvfz khi2.tgz
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/khi18.tgz
tar xvfz khi18.tgz
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/khiext.tgz
tar xvfz khiext.tgz
\end{verbatim}
khi2 est pour le slot 1, khi18 pour le slot 2 (et contient le
bootloader avec slot 2 en 0x90180000 et slot 3 en 0x90400000).

Il y a donc quatre arborescences distinctes, trois pour la calculatrice
(\verb|khi18|, \verb|khi2| et \verb|khiext|), une (\verb|delta|)
pour avoir un environnement de d\'eveloppement avec possibilit\'e
d'ex\'ecuter le code pas \`a pas. Cela pour deux raisons
\begin{itemize}
\item le simulateur a chang\'e dans Epsilon 14, et la nouvelle
  version est inutilisable sur ma machine (affichage flou peu lisible),
  je travaille donc avec l'ancienne version du simulateur (qui par
  ailleurs utilise le m\^eme toolkit FLTK que Xcas ce qui me facilite
  le travail pour adapter le simulateur pour debugguer efficacement)
\item le shell KhiCAS permet maintenant de choisir MicroPython comme
  \'evaluateur. Sur la calculatrice, KhiCAS et Epsilon sont compl\`etement
  s\'epar\'es 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\^eme
  source pour le MicroPython dans Epsilon et dans KhiCAS.
\end{itemize}

Le r\'epertoire \verb|khi2| contient l'arborescence pour compiler
pour l'OS calculatrice, \verb|khiext| pour les extensions. Les librairies n\'ecessaires
sont pr\'ecompil\'ees dans le r\'epertoire \verb|khiext/apps|.
\begin{verbatim}
cd khi2
make MODEL=bootloader epsilon.A.bin  
cd ../khiext
make 
\end{verbatim}
Si vous voyez des messages tels que \verb|... switch -mcpu=cortex-m7
conflicts...|, 
c'est que le cross-compilateur ARM de votre distribution
Linux est trop ancien. Allez sur le site du
\ahref{https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads}{ARM SDK}, descendez
jusqu'\`a faire apparaitre la version 9 (vous pouvez essayer une version
plus r\'ecente si votre distribution Linux est r\'ecente), t\'el\'echargez
pour Linux x64 et ex\'ecutez la commande\\
\verb|cd && tar xvfj Downloads/gcc-arm-none-eabi-9-2020-q2-update-linux.tar.bz2|\\
puis ajoutez dans votre fichier \verb|~/.bashrc| la ligne\\
\verb|export PATH=~/gcc-arm-none-eabi-9-2020-q2-update/bin:$PATH|\\
sauvegardez, puis tapez les commandes\\
\verb|source ~/.bashrc|\\
\verb|cd chemin_vers_khi2|\\
\verb|make|\\
\verb|cd ../khiext|\\
\verb|make|\\
\verb|cd ../|\\
{\bf Vous pouvez aussi \'editer les scripts \verb|mkarm|  des r\'epertoires
\verb|khi2| et \verb|khiext| et les ex\'ecuter \`a la place de \verb|make|}

Le fichier firmware de la version modifi\'ee de Epsilon,
\verb|epsilon.A.bin| est dans le sous-r\'epertoire
\verb|output/release/device/bootloader| de \verb|khi2|,
le fichier contenant les applications externes est \verb|apps.tar|
dans le r\'epertoire \verb|khiext|.
Pour les flasher sur la calculatrice, faire reset+4 sur la
calculatrice et
\begin{verbatim}
dfu-util -i0 -a0 -s 0x90000000 -D khi2/output/release/device/bootloader/epsilon.A.bin -R
dfu-util -i0 -a0 -D khiext/apps.tar -s 0x90200000:force
\end{verbatim}
Le premier fichier est le firmware Epsilon avec les modifications
des projet Delta/Omega/Khi. Ce projet 
fournit une interface pour programmer la calculatrice
en C et permet d'ex\'ecuter du code contenu
dans un fichier \verb|apps.tar| qui est stock\'e dans le
deuxi\`eme firmware.

Le r\'epertoire \verb|khi18| contient une version all\'eg\'ee de
Epsilon pour fournir un firmware de lancement minimal, qui permet
d'acc\'eder \`a plus de m\'emoire RAM dans KhiCAS. La compilation
est quasi-identique \`a celle dans \verb|khi2|\\
\verb|make MODEL=bootloader epsilon.B.bin|\\
ou \'editer et ex\'ecuter le script \verb|mkarm|.


{\bf KhiCAS}\\
Si vous modifiez le source de giac, il faut recompiler
la librairie \verb|libgiac.a| et la copier
dans \verb|../../lib|,
pour cela vous pouvez utiliser le script \verb|mkarm| dans le r\'epertoire
\verb|khiext|.
N'oubliez pas de r\'epercuter la modification dans le code source du
simulateur.

\subsubsection{Epsilon 22/23, KhiCAS pour N0115/N0120.}
Pour installer le simulateur avec KhiCAS,
exécutez depuis un terminal les commandes
\begin{verbatim}
git clone https://github.com/parisseb/epsilon
cd epsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfa ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfa nwsimu.tgz
./mk
ln -sf output/release/simulator/linux/epsilon.bin simu
\end{verbatim}
Notez que la compilation par le script mk se fait en deux temps, d'abord
la compilation normale d'Epsilon mais qui renvoie des erreurs car elle
ne linke pas avec les librairies contenant Xcas et ses dépendances,
puis une édition de liens avec ce qui est nécessaire, et qui elle
ne doit pas renvoyer d'erreurs.

Pour lancer le simulateur, tapez \verb|./simu| depuis le répertoire
\verb|epsilon|. Ensuite pour lancer KhiCAS, vous pouvez utiliser le
raccourci Esc depuis le menu principal de la Numworks simulée. 
Attention, la touche shift du clavier ne simule pas
la touche shift de la calculatrice, afin de pouvoir composer les
caractères tels que 1 à 9 ou 0 sur un clavier français. Il faut taper
la touche Ctrl pour simuler un appui sur shift. L'appui sur la touche
shift gauche du clavier simule l'appui sur la touche HOME.

Le code source pour la calculatrice physique est disponible 
dans les deux archives
\ahref{https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/launch.tgz}{lanceur d'application externe}, \ahref{https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/}{version de KhiCAS}.

Le lanceur d'application externe se compile avec \verb|make|
et génère un fichier \verb|output/khicas.nwa| qui 
s'installe depuis le site des 
\ahref{https://my.numworks.com/apps}{applications externes de Numworks}.
Il est lié à l'EADK de Numworks, avec quelques ajouts pour les fonctions
manquantes, afin de donner accès à la même API que l'application External
des N0110 non verrouillées. 
\begin{verbatim}
  extern "C" void (* const apiPointers[])(void) = {
    (void (*)(void)) extapp_millis,
    (void (*)(void)) extapp_msleep,
    (void (*)(void)) extapp_scanKeyboard,
    (void (*)(void)) extapp_pushRect,
    (void (*)(void)) extapp_pushRectUniform, // 4
    (void (*)(void)) extapp_pullRect,
    (void (*)(void)) extapp_drawTextLarge,
    (void (*)(void)) extapp_drawTextSmall,
    (void (*)(void)) extapp_waitForVBlank, // 8
    (void (*)(void)) extapp_clipboardStore,
    (void (*)(void)) extapp_clipboardText,
    (void (*)(void)) extapp_fileListWithExtension,
    (void (*)(void)) extapp_fileExists, // 12
    (void (*)(void)) extapp_fileErase,
    (void (*)(void)) extapp_fileRead,
    (void (*)(void)) extapp_fileWrite,
    (void (*)(void)) extapp_lockAlpha, // 16
    (void (*)(void)) extapp_resetKeyboard,
    (void (*)(void)) extapp_getKey,
    (void (*)(void)) extapp_restorebackup,
    (void (*)(void)) extapp_erasesector, // 20
    (void (*)(void)) extapp_writememory,
    (void (*)(void)) extapp_inexammode,
    (void (*)(void)) extapp_isalphaactive, 
    (void (*)(void)) extapp_kbdstatus,  // 24
    (void (*)(void)) nullptr,
  };
\end{verbatim} 
L'adresse de ce tableau est ensuite passé en paramètre à la fonction \verb|extapp_start| de \verb|khib/startup.c|\\
\verb|uint32_t _extapp_start(const uint32_t api_version, const void * api_base, void * heap, const uint32_t heap_size);|\\
qui va copier ces paramètres, en particulier le tableau apiPointers qui sert
à faire fonctionner le SDK C  dans \verb|khib/api.c|,
initialiser la RAM statique, puis appeler \verb|extapp_main|
dans \verb|khib/main.c|, qui
appelle \verb|ext_main| qui appelle \verb|caseval("*")| ce
qui est une convention de la librairie Giac/Xcas 
pour lancer le shell de KhiCAS.

KhiCAS peut se compiler en deux versions: une version allégée sans
l'aide complète qui tient dans le 2ème slot Numworks
(commençant à 0x90400000) ou en version complète qui génère alors
deux fichiers binaires, un commençant en 0x90260000 et finissant en 0x903f0000
(les données read only), le deuxième commençant en 0x90400000, il 
se présente comme une archive tar à laquelle on peut ajouter des fichiers
de données/scripts qui seront accessibles en lecture seule sur la calculatrice.
On utilise l'une des commandes \verb|./mkb| ou \verb|./mkab|. 
On peut envoyer à la calculatrice une autre archive tar en 0x90200000
qui contient des données/scripts accessible en lecture/écriture depuis
la calculatrice.
Il y a donc 4 versions de fichiers de link (*.ld) selon 
le modèle de calculatrice
cible et la version allégée ou non de KhiCAS:
\verb|n01?0.ld, n01?0ab.ld|. On compile par paires, en choisissant
comme cible \verb|khi110b.tar khi120b.tar| ou 
\verb|khi110ab.tar khi120ab.tar| avec comme define
en ligne de compilation de g++ \verb|-DNUMWORKS_SLOTB| ou
\verb|-DNUMWORKS_SLOTAB|.
La RAM statique est située 16K avant la fin de la RAM pour les apps externes
(13K sont utilisés actuellement), et le lanceur alloue 128K pour le tas
(malloc) de KhiCAS.

Le modèle actuel est donc le suivant:
\begin{itemize}
\item RAM du tas commençant en \verb|0x2?012A28| avec Epsilon 22.2.1
(remplacer ? par 0 ou 4 selon le modèle)
\item
RAM statique: \verb|0x2?033000| (16K réservés, 13K utilisés)
\item
flash tar file R/W:  \verb|0x90200000| (6*64K disponible)
\item
flash \verb|.rodata 0x90260000-0x903f0000|: fichier khia, pour
la version longue de KhiCAS
\item
flash \verb|.text 0x90400000-0x907f0000| (dont
environ 0.5M disponible pour tar file RO en version longue), fichier
khi1?0ab.tar, ou fichier khi1?0b.tar (version courte).
\end{itemize}
Les commandes dfu pour flasher sans accès Internet
\begin{verbatim}
dfu-util -i 0 -a 0 -s 0x90400000 -D khi120b.tar
    (version courte) ou (version longue)
dfu-util -i 0 -a 0 -s 0x90400000 -D khi120ab.tar
dfu-util -i 0 -a 0 -s 0x90260000 -D khia
    exemples de scripts:
dfu-util -i 0 -a 0 -s 0x90200000 -D khi92
\end{verbatim}
Pour reflasher le secteur de lancement de l'application sans accès
Internet, commencer par récupérer une fois pour toutes
une version du secteur lorsque KhiCAS est visible, sur une N0120:
\begin{verbatim}
#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90190000:0x10000:force -U sector19
\end{verbatim}
sur une N0110/N0115:
\begin{verbatim}
#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90180000:0x10000:force -U sector18
\end{verbatim}
puis exécuter sur N0120 la commande
\begin{verbatim}
#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90190000 -D sector19
\end{verbatim}
et sur N0110/N0115
\begin{verbatim}
#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90180000 -D sector18
\end{verbatim}

{\bf Remarques~:}
\begin{itemize} 
\item KhiCAS peut se compiler en version courte en français uniquement en 
tapant \verb|./mkfr|, cette version occupe environ 4M-90K. On peut
alléger plus en supprimant le support de MicroPython (enlever
\verb|-DMICROPY_LIB| dans le Makefile).
\item
La compilation du lanceur pourrait sans doute
être accélérée et fonctionner sans accès Internet en bypassant 
le linker de Numworks, avec un fichier ld qui utiliserait 
un secteur fixe pour la flash (\verb|0x90190000|)
et le fonds de la pile (stack) pour la RAM statique
(\verb|0x2?380000|) vu que la pile a pas mal de place disponible, 
il faudrait aussi remplacer les
appels à l'EADK par des appels SVC et ajouter le nécessaire
(headers) pour être reconnu comme app externe Numworks. 
\begin{verbatim}
ion/src/device/userland/drivers/external_apps.cpp
ion/include/ion/external_apps.h
  /* The ExternalApp start with its info layout as:
   * - 4 bytes: a magic code 0xBABECODE
   * - 4 bytes: the API level of the AppInfo layout
   * - 4 bytes: the address of the app name
   * - 4 bytes: the size of the compressed icon
   * - 4 bytes: the address of the compressed icon data
   * - 4 bytes: the address of the entry point
   * - 4 bytes: the size of the external app including the AppInfo header
   * - 4 bytes: the same magic code 0xBABECODE
   */
apps/home/controller.cpp: affichage et lancement par switchToExternalApp
apps/apps_container.cpp:void AppsContainer::switchToExternalApp(Ion::ExternalApps::App app)
\end{verbatim}
\end{itemize}

%% \subsubsection{Avec le lanceur d'applications externes}
%% Damien Nicolet a impl\'ement\'e un syst\`eme de lancement
%% d'applications externes pour la Numworks, qui apporte des
%% am\'eliorations notables, dont une augmentation du tas disponible
%% pour les applications (128K, presque le double), et la possibilit\'e
%% de relancer une application avec un tas r\'einitialis\'e.

%% Pour compiler, faire~:
%% \begin{verbatim}
%% git clone -b external https://github.com/Delta-NumWorks/delta
%% cd delta 
%% make epsilon.dfu
%% cd  ..
%% git clone https://github.com/Delta-NumWorks/nw-external-apps
%% cd nw-external-apps
%% make apps.tar
%% cd ..
%% \end{verbatim}

%% Pour flasher la calculatrice
%% \begin{verbatim}
%% dfu-util -i0 -a0 -D delta/output/device/release/n0110/epsilon.dfu
%% dfu-util -i 0 -a 0 -s 0x90200000 -D external-apps/apps.tar
%% \end{verbatim}
%% ou \verb|sudo apt-get install chromium-browser| puis
%% \verb|chromium-browser index.html|.

%% Pour mettre \`a jour \verb|libgiac.a|, il faut la recompiler comme expliqu\'e
%% dans les sections pr\'ec\'edentes, puis la recopier dans
%% \verb|nw-external-apps/apps/khicas|.

%% Dans cette version, la taille maximale des donn\'ees initialis\'ees
%% (data) et non initialis\'ees (bss) est fix\'ee \`a 16K (elle utilise
%% la zone dite ITCM-RAM à l'adresse 0), la taille de la pile (partag\'ee
%% avec Epsilon) est de 32K et le tas pour les applications externes
%% est de 128K.

%% \subsubsection{Epsilon 11}
%% Attention, ici on va g\'en\'erer un firmware monolithique
%% donc non redistribuable. Mais on gagne 4K de RAM, environ 10\% de
%% plus de m\'emoire.
%% On r\'ecup\`ere
%% les sources de giac et epsilon/delta, et on compile pour la Numworks
%% \begin{verbatim}
%% cd
%% mkdir numworks
%% cd numworks
%% wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/gmpfri_numworks.tgz
%% tar xvfz gmpfri_numworks.tgz
%% wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac/giac_unstable.tgz
%% tar xvfz giac_unstable.tgz
%% cd giac-1.5.0/src
%% /bin/cp config.h.numworks.gmp config.h
%% /bin/cp Makefile.numworks.gmp Makefile
%% /bin/cp static_lexer_numworks.h static_lexer.h
%% /bin/cp static_lexer__numworks.h static_lexer_.h
%% make
%% \end{verbatim}
%% Si vous voyez des messages tels que \verb|... switch -mcpu=cortex-m7 conflicts...|, c'est que le cross-compilateur ARM de votre distribution
%% Linux est trop ancien. Allez sur le site du
%% \ahref{https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads}{ARM SDK}, descendez
%% jusqu'\`a faire apparaitre la version 7 (vous pouvez essayer une version
%% plus r\'ecente mais les binaires risquent de ne pas fonctionner
%% sur votre distribution Linux), t\'el\'echargez
%% pour Linux x64 et ex\'ecutez la commande\\
%% \verb|cd && tar xvfj Downloads/gcc-arm-none-eabi-7-2018-q2-update-linux.tar.bz2|\\
%% puis ajoutez dans votre fichier \verb|~/.bashrc| la ligne\\
%% \verb|export PATH=~/gcc-arm-none-eabi-7-2018-q2-update/bin:$PATH|\\
%% sauvegardez, puis tapez les commandes\\
%% \verb|source ~/.bashrc|\\
%% \verb|cd numworks/giac-1.5.0/src|\\
%% \verb|make clean|\\
%% \verb|make|\\
%% Il ne devrait plus y avoir d'avertissements. Lorsque la compilation de
%% giac est termin\'ee, tapez~:
%% \begin{verbatim}
%% cp libgiac.a ../../lib
%% cd ~/numworks
%% #git clone -b n110-giac https://github.com/zardam/epsilon
%% wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/delta11.tgz
%% tar xvfz delta11.tgz
%% cd epsilon
%% #/bin/rm build/device/n0110/epsilon.elf
%% make V=1 USE_LIBA=0 EPSILON_DEVICE_BENCH=0 EPSILON_USB_DFU_XIP=0 EPSILON_ONBOARDING_APP=1 EPSILON_BOOT_PROMPT=update build/device/n0110/epsilon_two_binaries #-j
%% arm-none-eabi-objdump -t build/device/n0110/epsilon.elf > dump_t
%% \end{verbatim}
%% La derni\`ere commande cr\'ee un fichier avec la liste des symboles, ce qui
%% permet de v\'erifier qu'on n'a pas cr\'e\'e par exemple une grosse
%% variable qui prend trop de place en m\'emoire RAM.

%% Attention, ce firmware n'est pas redistribuable!

%% Pour compiler pour le simulateur (et pouvoir mettre au point),
%% %% installez gcc version 8 si n\'ecessaire\\
%% %% \verb|sudo apt-get install gcc-8 g++-8|\\
%% %% \verb|sudo ln -sf /usr/bin/gcc-8 /usr/bin/gcc|\\
%% %% \verb|sudo ln -sf /usr/bin/g++-8 /usr/bin/g++|\\
%% %% choisir une des deux m\'ethodes ci-dessous
%% \begin{enumerate}
%%   \item Installation plus simple mais sans pouvoir utiliser Xcas~:
%% \begin{verbatim}
%% cd
%% mkdir amd64
%% cd amd64
%% tar xvfz ../numworks/giac_unstable.tgz
%% cd giac-1.5.0/
%% export CXXFLAGS='-g -DNUMWORKS'
%% ./configure --prefix=/usr --disable-gui
%% unset CXXFLAGS
%% \end{verbatim}
%% Ouvrir \verb|src/config.h| avec un \'editeur texte et commentez
%% vers la ligne 100~:\\
%% \verb|/* #define HAVE_GETTEXT 1 */|\\
%% Puis tapez~:
%% \begin{verbatim}
%% make 
%% sudo make install
%% cd ~/numworks/epsilon
%% make V=1 DEBUG=1 PLATFORM=simulator
%% ln -s build/simulator/epsilon.elf simu
%% \end{verbatim}
%% Attention, ceci est incompatible avec une installation de Giac/Xcas.
%% \item Installation moins simple mais permettant d'avoir Xcas simultan\'ement.
%% \begin{verbatim}
%% cd
%% mkdir amd64
%% cd amd64
%% tar xvfz ../numworks/giac_unstable.tgz
%% cd giac-1.5.0
%% ./mkdebian
%% sudo dpkg -i ../giac*deb*
%% export CXXFLAGS='-g -DNUMWORKS'
%% ./configure --prefix=/home/username/amd64 --disable-gui
%% \end{verbatim}
%%   {\bf Atttention}, ci-dessus remplacer \verb|username| par votre
%%   nom d'utilisateur.
%%   Ouvrir \verb|src/config.h| avec un \'editeur texte et commentez vers
%%   la ligne 100 l'utilisation de gettext~:\\
%% \verb|/* #define HAVE_GETTEXT 1 */|\\
%% Puis tapez~:
%% \begin{verbatim}
%% unset CXXFLAGS
%% make 
%% make install
%% export LD_LIBRARY_PATH=~/amd64/lib
%% cd ~/numworks/epsilon
%% make V=1 DEBUG=1 PLATFORM=simulator
%% ln -sf build/simulator/epsilon.elf simu
%% \end{verbatim}
%% Essayez mantenant de taper \verb|./simu| puis de lancer Khicas sur
%% le simulateur. Si une erreur de link ou une erreur de symbole non
%% d\'efini apparait, vous pouvez essayer de linker avec la librairie
%% statique \verb|libgiac.a|, pour cela v\'erifiez avec un \'editeur
%% de texte le shell script \verb|mkstat1| puis lancez la commande\\
%% \verb|sh mkstat1|\\

%% Pour pouvoir utiliser Xcas, il faut le lancer depuis un autre shell
%% ou faire \verb|unset LD_LIBRARY_PATH|. Pour pouvoir linker Epsilon+giac
%% (avec la librairie giac dynamique)
%% ou pour le d\'ebugguer au simulateur, il faut s'assurer d'avoir fait la
%% commande\\
%% \verb|export LD_LIBRARY_PATH=~/amd64/lib|
%% \end{enumerate}
%% L'ex\'ecutable du simulateur se lance par la commande \verb|./simu|
%% depuis le r\'epertoire \verb|numworks/epsilon|,

\subsection{Utilisation du d\'ebuggueur}
Le simulateur peut se lancer avec le d\'ebuggueur en tapant
\verb|gdb ./simu| ou
depuis votre \'editeur de texte ou votre environnement de d\'eveloppement.
Par exemple si vous utilisez
\verb|emacs|, tapez \verb|Esc x gdb|, valider, mettre \verb|simu|
comme nom d'ex\'ecutable, valider. Voir par exemple
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/info/gdb.pdf}{ici}
un guide de prise en main d'utilisation du d\'ebuggueur avec emacs.
Vous pouvez ex\'ecuter la commande\\
\verb|cp delta/ext/giac-1.6.0/src/.gdbinit delta|\\
ou télécharger le fichier \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/giac/.gdbinit}{.gdbinit}
pour d\'efinir la macro \verb|v| de \verb|gdb| qui vous permettra
de visualiser les variables de type \verb|giac::gen| de mani\`ere
plus parlante qu'avec la commande \verb|p|.

Par exemple, si vous faites dans la console \verb|gdb| la commande
\verb|b khicas_addins_menu| (breakpoint, i.e. point d'arr\^et
\`a cette fonction), puis \verb|r| pour lancer
le programme, il s'interrompra
dans le menu d'affichage des applications tierces (shift-Ans),
vous pouvez alors ex\'ecuter ligne apr\`es ligne avec la
commande \verb|n|, en visualisant le contenu des variables
avec la commande \verb|p| ou \verb|v| pour des variables Xcas de type gen.

\subsection{Int\'egration avec le shell Khicas}
Pour ajouter une application au menu \verb|shift-Ans| des
applications ajout\'ees dans Khicas,
il faut modifier la fonction \verb|khicas_addins_menu()|
dans \verb|kadd.cc|. 
Incr\'ementez \verb|smallmenu.numitems|,
d\'efinissez \verb|smallmenuitems[j].text| pour
la premi\`ere valeur de \verb|j| disponible, puis dans
la boucle \verb|while(1) {...}|, ajoutez
la d\'efinition de votre fonction ou un appel vers votre fonction
avec \verb|if (smallmenu.selection==j+1)|.
Pour compiler et tester, cf. la fin de la section \ref{sec:epsilon12}.

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

Conseils~:
\begin{itemize}
  \item Pour commencer \`a programmer votre propre version de KhiCAS,
    vous pouvez modifier un de ces exemples. Par exemple,
    demander des param\`etres 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 \'ecran de saisie puis afficher une courbe.
  \item Si vous utilisez des donn\'ees constantes,
    n'oubliez pas de mettre le modificateur \verb|const| pour \'economiser
    la m\'emoire RAM.
  \item Pour travailler avec des chaines de caract\`eres
    sans vous soucier des allocations m\'emoires,
    vous pouvez utiliser \verb|string|, pour
    des tableaux de taille dynamique \verb|vector<>|
    (voir par exemple le site \ahref{cplusplus.com}{cplusplus.com}
    pour la description des fonctions de la librairie standard C++)
  \item Il faut \^etre \'econome en m\'emoire,
    la disponibilit\'e sur le tas est faible (un peu plus de 100 kilo-octets si
    aucune variable KhiCAS n'est stock\'ee en m\'emoire, que le tas
    Micro-Python n'est pas actif et qu'il n'y a pas de tableur).
\end{itemize}

Les paragraphes qui suivent d\'ecrivent bri\`evement le SDK.
Pour plus de d\'etails, il faut ensuite se r\'ef\'erer \`a
\verb|k_csdk.h| et \verb|kdisplay.h/kdisplay.cc| pour l'interface
et aux fichiers headers de \verb|giac| pour
toutes les fonctions de \verb|giac|.  

\subsection{Fonctions de base de l'OS.} \label{sec:os}
Les fonctions de bas niveau de Epsilon sont d\'eclar\'ees
dans \verb|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\'eer une extension
ind\'ependante de KhiCAS, vous pouvez vous inspirer
d'une des applications de \verb|final/nw-external-apps|,
d\'efinissez votre propre fonction \verb|int main()|
et linkez avec votre fichier objet \`a la place de
\verb|-lgiac|, dans ce cas vous
pouvez choisir n'importe quelle licence de logiciel qui peut
se lier avec une licence d'OS propri\'etaire.

Le clavier~:
\begin{itemize}
\item \verb|int getkey(int allow_suspend);|\\
  renvoie un code touche, \verb|allow_suspend| est non nul
  si on autorise l'utilisateur \`a \'eteindre la calculatrice
  (attention dans ce cas \`a g\'erer l'affichage).
  Les touches sont d\'efinies comme suit, la 2i\`eme ligne correspond
  aux touches Home (jaune) et Power (noire), avec 4 codes
  de touches inexistantes,
  les lignes \`a partir de la 6i\`eme ont un code de touche inexistant sur le
  clavier.
  
\begin{verbatim}
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_CTRL_INS,'%',-1,
   KEY_CTRL_F1,KEY_CTRL_F2,KEY_CTRL_F3,'\t','\\',-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,
  };
\end{verbatim}
\item \verb|int getkey_raw(bool allow_suspend);|\\
  renvoie le scan code de Numworks,
  de 0 \`a 53 pour le clavier non shift\'e, ajouter 54 pour shift\'e,
  ajouter 108 pour alpha, 162 pour alpha shift\'e
\item \verb|void GetKey(int * key);|\\
  renvoie une touche au clavier, en utilisant le m\^eme prototype
  que le SDK pour calculatrices Casio.
\item \verb|bool os_set_angle_unit(int mode);|
  change l'unit\'e d'angle (0 radians, 1 degr\'es)
\item \verb|int os_get_angle_unit();|
  renvoie l'unit\'e d'angle
\item \verb|bool isalphaactive();|\\
  renvoie vrai si le mode alpha est actif.
\item \verb|bool alphawasactive();|\\
  renvoie vrai si le mode alpha \'etait actif avant la derni\`ere
  frappe de touche
\item \verb|void lock_alpha();|\\
  verrouille le mode alpha
\item \verb|bool back_key_pressed();|\\
  renvoie vrai en cas d'appui sur la touche Back. Utile pour
  permettre d'interrompre un programme. Ceci n\'ecessite de tester
  souvent l'appui sur Back. Attention, pour \'eviter des probl\`emes
  lors de l'initialisation, les 400 premiers appels \`a cette
  fonction renvoient faux.
  \item \verb|bool is_keydown(int key);|
\item \verb|void reset_kbd();|\\
  enl\`eve les modes shift et alpha s'ils \'etaient actifs.
\end{itemize}

{\bf Les affichages.}\\
Notez que $y=0$  correspond \`a
la premi\`ere ligne en-dessous de la ligne d'\'etat (18 pixels de hauteur),
on a donc $0 \leq y<222$  et $0\leq x <320$\\
Les couleurs utilisent un entier 16 bits au format RGB 565, on peut
convertir depuis RGB888 par
\begin{verbatim}
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);
}
\end{verbatim}
\begin{itemize}
\item \verb|void statusline(int mode=0);|\\
  affiche la ligne d'\'etat standard
\item \verb|void statuslinemsg(const char * msg);|\\
  affiche une chaine de caract\`eres dans la ligne d'\'etat
\item \verb|void os_fill_rect(int x,int y,int w,int h,int c);|\\
  remplit un rectangle avec une couleur de couleur \verb|c| donn\'e
  en rgb565, 
  \item \verb|void os_set_pixel(int x,int y,int c);|\\
    affiche un pixel de couleur \verb|c| donn\'e en rgb565
  \item \verb|int os_get_pixel(int x,int y);|\\
    renvoie la couleur rgb565 d'un pixel.
  \item \verb|int os_draw_string(int x,int y,int c,int bg,const char * s,bool fake=false);|\\
    \verb|int os_draw_string_small(int x,int y,int c,int bg,const char * s,bool fake=false);|\\
    \'ecrit une chaine de caract\`ere avec la fonte de taille normale
    ou petite \`a
    partir du pixel $x,y$ en couleur \verb|c| (rgb565 ), avec une couleur de
    fonds \verb|bg|. Renvoie la position finale de $x$.
    Si \verb|fake| est \verb|true|, il n'y a pas d\'ecriture, juste
    le calcul de la position finale de $x$.
  \item \verb|bool waitforvblank()|\\
    synchronisation \'ecran, \`a appeler juste avant de faire
    des op\'erations de trac\'e pour \'eviter le scintillement.
  \item \verb|void os_redraw();|\\
    signale \`a l'OS Numworks qu'il doit retracer l'\'ecran en entier
\end{itemize}

Le syst\`eme de fichiers.
\begin{itemize}
\item \verb|bool file_exists(const char * filename);|
\item \verb|bool erase_file(const char * filename);|
\item \verb|const char * read_file(const char * filename);|
\item \verb|bool write_file(const char * filename,const char * s,size_t len=0);|
\item \verb|int os_filebrowser(const char ** filenames,int maxrecords,const char * extension);|\\
  Place dans \verb|filenames| la liste des noms de fichiers d'extension
  \verb|extension|  
\end{itemize}

Gestion du temps
\begin{itemize}
\item \verb|void os_wait_1ms(int ms);|\\
  attend \verb|ms| millisecondes.
\item \verb|double millis();|\\
  renvoie un nombre de millisecondes depuis le dernier d\'emarrage.
  Attention, l'horloge syst\`eme ne tourne pas \`a la bonne vitesse
  lorsque la calculatrice est \'eteinte, il n'est donc pas possible
  de s'en servir pour afficher l'heure.
\end{itemize}

\subsection{Commandes graphiques compl\'ementaires}
\begin{itemize}
\item \verb|void xcas::draw_line(int x1, int y1, int x2, int y2, int color);|\\
  segment de droite
\item \verb|void xcas::draw_rectangle(int x, int y, int width, int height, int color);|\\
  rectangle rempli
\item \verb|void xcas::draw_polygon(std::vector< std::vector<int> > & v1,int color)|\\
  polygone de sommets dans la matrice de $n$ lignes \verb|v|, une ligne
  par sommet, chaque ligne est un vecteur de 2 entiers
  (coordonn\'ees en pixels). 
\item \verb|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$ lignes \verb|v|, une ligne
  par sommet, chaque ligne est un vecteur de 2 entiers
  (coordonn\'ees en pixels). Le polygone rempli est trac\'e
  avec ``clipping'' dans le rectangle d\'efini par \verb|x1,y1,x2,y2|.
\item \verb|void xcas::draw_circle(int xc,int yc,int r,int color);|\\
  cercle de centre \verb|(xc,yc)| et rayon \verb|r|
\item  \verb|void xcas::draw_filled_circle(int xc,int yc,int r,int color);|\\
  disque  de centre \verb|(xc,yc)| et rayon \verb|r|
\item   \verb|void xcas::draw_arc(int xc,int yc,int rx,int ry,int color,double theta1, double theta2);|\\
  arc d'ellipse.
\item  \verb|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.

\end{itemize}

\subsection{Interaction avec l'UI Khicas}
Certaines fonctions utilisent un pointeur vers le contexte
du moteur de calcul (qui contient les variables assign\'ees, le mode
radian/degr\'e, etc.), de type
\verb|giac::context *|, et dont
la valeur est en g\'en\'eral stock\'ee dans la variable \verb|contextptr|
dans les fonctions d'interface de Khicas de \verb|kdisplay.cc|
(on peut aussi passer un pointeur nul).
\begin{itemize}
\item \verb|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\`eres en affichant le
  message \verb|msg1| et en pr\'eremplissant la chaine \`a entrer avec
  \verb|msg2|. Seuls les caract\`eres utilisables pour un nombre
  sont accept\'es si \verb|numeric| est \verb|true|. La position
  verticale de la ligne de commande est ajustable en changeant la
  valeur de \verb|ypos|. Renvoie 0 si l'utilisateur a annul\'e en tapant
  sur Back.
\item \verb|bool inputdouble(const char * msg1,double & d,const giac::context *contextptr)|\\
  permet d'entrer un nombre flottant en affichant le message \verb|msg1|,
  renvoir \verb|false| si l'utilisateur a annul\'e en tapant sur Back.
  \verb|int select_item(const char ** ptr,const char * title);|\\
  affiche un menu \`a choix et renvoie le choix de l'utilisateur.
\item \verb|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 \verb|acexit| est \verb|true|, l'appui sur Back
  renvoie -1. Sinon, l'appui sur Back renvoie l'entier
  \verb|KEY_CTRL_F6|. L'appui
  sur \verb|OK| ou \verb|EXE| renvoie l'entier \verb|KEY_CTRL_F1|.
  \item \verb|int giac_filebrowser(char * filename,const char * extension,const char * title);|\\
  affiche un menu de s\'election parmi les fichiers dont l'extension
  est \verb|extension|. Si l'utilisateur s\'electionne un fichier,
  renvoie 1 et met le nom de fichier dans \verb|filename|, qui doit
  avoir une taille suffisante.

\item \verb|void displaygraph(const giac::gen & ge, const giac::context * contextptr);|\\
  affiche un \verb|gen| de type graphique (si \verb|ge.is_symb_of_sommet(at_pnt)|)
\item \verb|void displaylogo();|\\
  affiche la tortue logo
\item \verb|giac::gen eqw(const giac::gen & ge,bool editable,const giac::context * contextptr);|\\
  affiche une expression dans l'\'editeur 2d.
\item \verb|void add(textArea *edptr,const std::string & s);|\\
  \'ecrit la chaine C++ \verb|s| vers le buffer texte point\'e
  par \verb|edptr| (dans \verb|edptr->elements|)
\item \verb|int doTextArea(textArea* text,const giac::context * contextptr); |\\
  ouvre l'\'editeur de texte,
  renvoie 0 si l'utilisateur quitte avec la touche Back,
  1 si \verb|text->allowEXE| est \`a \verb|true| et si l'utilisateur
  appuie sur \verb|EXE|, 2 si \verb|text->allowF1| est \`a \verb|true|
  et l'utilisateur appuie sur F1.
\item \verb|std::string merge_area(const std::vector<textElement> & v);|\\
  renvoie la chaine C++ correspondant \`a \verb|v|, si \verb|edptr| est
  un pointeur sur \verb|textArea|, on prendra pour \verb|v|
  \verb|edptr->elements|.
\end{itemize}
L'internationalisation est g\'er\'ee par la commande\\
\verb|const char * gettext(const char *)|\\
Pour ajouter une chaine en plusieurs langues, par exemple Hello,
mettez dans votre code \verb|gettext("Hello")|, et ajoutez
au fichier \verb|numworks_translate.h|, {\em dans l'ordre alphab\'etique}
une ligne du type\\
\verb|{"Hello",0,0/* zt */,"Bonjour" /* fr */,"Guten Tag" /* de */,0 /* es */,0 /* nl */,0 /* pt */,0},|
\\
Attention, l'utilisation du fichier \verb|numworks_translate.h|
ne peut se faire qu'avec du code GPL qui est link\'e avec KhiCAS
(mais rien ne vous emp\^eche d'utiliser \verb|gettext| dans
un programme compatible avec la GPL
avec un autre fichier de traductions en repartant de z\'ero).

\subsection{Interaction avec giac}
Le type \verb|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
\begin{verbatim}
gen g(1.2),h(3);
\end{verbatim}
ou avec
l'interpr\'eteur (avec une chaine de caract\`eres), dans ce dernier
cas il faut \'evaluer le gen avec un appel \`a \verb|eval|,
par exemple
\begin{verbatim}
gen g("x^4-1",contextptr);
g=eval(g,1,contextptr);
\end{verbatim}

En g\'en\'eral
une fonction de Xcas a un \'equivalent C++ avec le m\^eme nom pr\'ec\'ed\'e
par \verb|_|,
et deux arguments, un de type \verb|giac::gen|
et un deuxi\`eme
qui est un pointeur sur le contexte d'\'evaluation.
Lorsqu'une commande Xcas prend plusieurs arguments, il faut les grouper
en un gen de type vecteur, en utilisant une commande \verb|makesequence|.
Par exemple \verb|_randNorm(makesequence(0.0,2.0),contextptr)|
\'equivaut \`a la commande \verb|randNorm(0.0,2.0)| de Xcas.
Notez que les fonctions usuelles n'ont pas de pr\'efixe \verb|_|.

\subsection{Sauvegardes et restauration (N0110 non verrouillée)}
Il est possible de sauvegarder l'ensemble des donn\'ees de votre
calculatrice en local sur votre PC, i.e. sans connexion Internet.
Xcas le permet depuis le menu Numworks. On peut aussi 
appeler \verb|dfu-util| directement, cf. la section
\ref{sec:install}. Il faut ensuite r\'ecup\'erer les informations sur
la calculatrice avec la commande\\
\verb|dfu-util -i0 -a0 -s 0x080001c4:0x20 -U platform.info|\\
ce qui place dans le fichier binaire \verb|platform.info| (de taille
32 octets) des informations sur la Numworks
(cf. \verb|ion/src/shared/platform_info.cpp|)
\begin{itemize}
\item offset 0 0xDEC00DF0
\item offset 4 la version (8 caract\`eres)
\item offset 12 le num\'ero de patch (8 caract\`eres)
\item offset 20 (0x14) l'adresse A de l'espace de stockage de la Numworks
\item offset 24 (0x18) la taille T de l'espace de stockage
\item offset 28 (0x1C) 0xDEC00DF0
\end{itemize}
Ensuite en rempla\c{c}ant A et T par leur valeur dans la commande\\
\verb|dfu-util -i0 -a0 -s A:T:force -U numworks.storage|\\
vous pouvez archiver l'ensemble des donn\'ees de votre calculatrice
dans le fichier \verb|numworks.storage|. A devrait valoir
\verb|0x20000b60|, et T \verb|0x8014| (dont 4 octets valant
\verb|0xEE0BDDBA| puis 32K de data puis \`a
nouveau les 4 octets du d\'ebut, et 3 pointeurs) ce qui donne la
commande\\
\verb|rm -f numworks.storage &&dfu-util -i0 -a0 -s 0x20000b60:0x8014:force -U numworks.storage|

Vous pourrez ensuite restaurer l'archive par la commande\\
 \verb|dfu-util -i0 -a0 -s A:T:force -D numworks.storage|\\
avec Khi\\
\verb|dfu-util -i0 -a0 -s 0x20000b60:0x8014:force -D numworks.storage|\\

\appendix

\section{Opinions}
\subsection{Quelques mots sur les calculatrices.}
La calculatrice est devenue incontournable dans les enseignements
de math\'ematique
au lyc\'ee, avec trop souvent une utilisation presse-boutons,
alors qu'elle est sous-utilis\'ee dans les \'etudes
scientifiques, partiellement en r\'eaction. De ce fait,
les constructeurs mettent l'accent sur le d\'eveloppement
de fonctionnalit\'es pour le lyc\'ee, en faisant apprendre
des s\'equences de touches \`a effectuer pour certaines
taches bien pr\'ecises, plutot qu'une m\'ethode
plus g\'en\'erale, 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\'evues, c'est facile et en g\'en\'eral
intuitif, mais il
devient vite difficile de faire quelque chose qui n'est pas pr\'evu
(par exemple simuler des donn\'ees avec un programme et les utiliser
dans une des applis de statistiques, repr\'esenter graphiquement
une fonction d\'efinie par un programme, utiliser dans Calculs ou
dans Python
certaines fonctions des applications probabilit\'e ou statistiques, ...).

Je pense que ce n'est pas adapt\'e pour
les \'el\`eves qui doivent pouvoir exp\'erimenter
des choses que le constructeur n'a pas impl\'ement\'e parce
que cela ne correspond pas aux programmes (c'est particuli\`erement
vrai pour les bons \'el\`eves si on ne veut pas qu'ils s'ennuient!).
\`A court terme,
c'est plus facile pour enseigner d'utiliser une application
comme Fonctions, mais \`a long terme, c'est plus formateur
pour de futurs \'etudiants (au moins en sciences et en maths)
d'apprendre \`a utiliser un shell puissant en y tapant des 
commandes\footnote{On peut d'ailleurs s\'erieusement se demander 
\`a quoi cela rime d'apprendre un peu de programmation en Python
sans avoir au pr\'ealable un minimum de maitrise dans l'\'ecriture 
d'une ligne de commande simple}.
Bien sur, les deux approches doivent se compl\'eter.
Or les \'el\`eves sont souvent tributaires du choix de mod\`ele
demand\'e par leur enseignant de seconde, ils n'ont pas encore
de recul pour choisir un autre mod\`ele que celui
demand\'e par l'enseignant et comprendre toutes
les cons\'equences du choix, en particulier si la calculatrice
ne permet pas d'y installer ou/et utiliser un shell puissant.
Il est donc important de pouvoir proposer pour le plus possible
de mod\`eles populaires une alternative \`a la calculatrice
officielle, permettant aussi aux bons \'el\`eves d'exploiter
toutes les possibilit\'es de leur calculatrice et
de favoriser leur curiosit\'e\footnote{Pour moi, une calculatrice qui
fait aimer les maths, c'est une calculatrice qui va donner envie \`a un
\'el\`eve d'exp\'erimenter sur sa calculatrice des questions
en prolongement du programme scolaire. \`A cot\'e 
d'applications intuitives, il faut un espace de libert\'e
qui ne soit pas limit\'e aux quelques fonctionnalit\'es d'une
interface d'application. C'est le
sens de $\chi$CAS, pour Numworks ici, disponible \'egalement
pour d'autres mod\`eles
(Casio Graph 90/35eii, TI Nspire).}.

Il faut aussi que les enseignants qui 
conseillent un mod\`ele de calculatrices en seconde prennent bien
conscience que le choix ne se limite pas \`a une utilisation pendant
une ann\'ee ou m\^eme pendant les 3 ann\'ees de lyc\'ee mais 
impacte toutes les ann\'ees d'\'etudes, en particulier pour les
\'el\`eves bons en sciences et en maths. La Numworks non verrouill\'ee
r\'ealise d'une certaine mani\`ere un bon \'equilibre 
entre la facilit\'e d'utilisation pour tous en seconde
(Epsilon 15 ici) et les
possibilit\'es ensuite pour les bons \'el\`eves qui auront des maths
ensuite ($\chi$CAS ici). Mais le passage \`a une version plus
r\'ecente d'Espilon casse cet \'equilibre, un enseignant soucieux de ses
bons \'el\`eves devrait les mettre en garde pour qu'ils ne mettent
pas \`a jour!

\subsection{Mes relations compliquées avec Numworks.}
C'est en mai 2016 que j'ai entendu parler pour la premi\`ere fois de
Numworks. Romain Goyet, qui d\'emarrait son projet, m'a contact\'e
pour me sonder un peu dans le domaine des calculatrices. La
recommandation principale que je lui avais faite \'etait la suivante~:
il ne faut pas chercher \`a faire des \'economies sur la m\'emoire,
car on le regrette. Ensuite, je n'ai plus eu aucune nouvelle
avant d'apprendre par tiplanet le lancement de la calculatrice en aout
2017, en particulier je n'ai pas particip\'e au programme de
beta-tests. Cette attitude a
sans doute contribu\'e \`a ce que j'exprime sans retenue 
mon scepticisme vis-\`a-vis
de la Numworks dans plusieurs posts sur tiplanet~: \`a propos
de la m\'emoire, des fonctionnalit\'es et de la communication
\`a mon avis trompeuse sur le caract\`ere open-source. Ce qui m'a sans doute
valu d'\^etre consid\'er\'e comme un anti-Numworks par Goyet, alors
que l'accueil du reste de la communaut\'e \'etait \`a l'\'epoque
tr\`es (trop?) enthousiaste. Mais
je ne regrette pas du tout d'avoir exprim\'e publiquement mes
r\'eserves, si tout le monde \'etait rest\'e sans rien dire, il n'y
aurait pas eu de changement dans la licence d'Epsilon, et les firmwares
Omega, Upsilon, Delta (et Khi leur h\'eritier direct) n'auraient pas pu exister.

Je ne sais pas si ma recommandation de 2016 sur la m\'emoire a eu un quelconque effet,
peut-\^etre que sans elle, les premi\`eres Numworks auraient encore
eu moins de m\'emoire. En tout cas, la m\'emoire disponible
\'etait et reste encore vraiment tr\`es limit\'ee, m\^eme s'il y a eu
un progr\`es pour le stockage en flash avec le passage de 1M \`a 8M
en 2019, probablement parce que Numworks s'est rendu compte que la taille
des firmwares successifs atteindrait plus vite que pr\'evu la taille
de 1M. Il me semble qu'il y aurait des marges de progression peu
on\'ereuses sur la RAM. Et je continue \`a penser que Numworks a perdu et perd
toujours beaucoup de temps de d\'eveloppement avec la gestion de la
tr\`es faible quantit\'e de RAM (256K).

 Les relations avec
Numworks se sont ensuite am\'elior\'ees en 2018, lors
d'une rencontre \`a l'APMEP de Bordeaux,
o\`u je leur avais montr\'e mon module de tortue logo sur les
calculatrices Casio (J.B. Boric avait aussi implement\'e un module
turtle pour la Numworks). Numworks comprend alors l'int\'er\^et d'avoir
un module officiellement support\'e pour faire la transition
avec le coll\`ege. \`A cette occasion, ils me donnent une
N0100. J'appr\'ecie le geste, m\^eme si je n'en ai pas l'usage
pour y porter Giac (\`a cette \'epoque, 
Damien Nicolet, alias zardam, avait r\'eussi \`a porter Giac 
sur sa Numworks N0100 mais en modifiant le hardware ce dont
je suis personnellement incapable).
En mai 2019, Numworks me contacte
pour me proposer de signer un accord de confidentialit\'e, ce que
j'interpr\`ete comme le signe qu'un nouveau mod\`ele allait sortir
permettant de porter Giac (sans modification hardware). Mais certaines
clauses de l'accord ne me convenaient pas~: je voulais m'assurer que
rien n'entrave le d\'eveloppement de Giac/Xcas. Numworks refusant de
modifier les clauses en question, je ne signe pas l'accord de
confidentialit\'e. Le nouveau mod\`ele de Numworks (N0110) est annonc\'e
deux mois plus tard, et j'en ach\`ete un. \`A la rentr\'ee 2019, avec
l'aide de J.B. Boric et Damien Nicolet,
j'arrive \`a faire tourner sur ma N0110
un prototype logiciel qui permet d'utilise le moteur de calcul de Giac dans l'appli
Calculs. Se pose alors la question de l'incompatibilit\'e des licences
entre Giac sous licence GPL et Epsilon, qui n'est pas un logiciel
libre. Mais Numworks est inflexible sur la licence d'Epsilon. Ce qui
conduit Damien Nicolet \`a d\'evelopper un syst\`eme permettant
de compiler deux firmwares \`a installer s\'epar\'ement, l'un
d\'eriv\'e d'Epsilon (sous sa licence) et l'autre sous licence
GPL (le deuxi\`eme sera remplac\'e plus tard par la gestion des
applications externes dans Delta/Omega/Upsilon/Khi). En novembre 2019,
nous informons Numworks de ce succ\`es et leur demandons
s'ils voient encore des probl\`emes juridiques. Fin 2019, n'ayant pas re\c{c}u de r\'eponse,
nous publions alors la premi\`ere version de Delta/KhiCAS.
Je n'ai pas de statistiques du nombre de personnes qui ont install\'e
KhiCAS sur leur Numworks, j'ai par contre le nombre de personnes qui
ont consult\'e la documentation, pour l'ann\'ee 2020/21 cela d\'epasse
un peu les 5000 et pour 2021/22 on d\'epasse les 9000, 
ce qui n'est pas n\'egligeable du tout compar\'e aux
chiffres de ventes estim\'es. Pour l'année 2023, on est encore
un peu au-dessus de 8000, alors qu'il devient de plus en plus
difficile de se procurer une Numworks non verrouillée.

En 2017/2018, les ventes de calculatrices Numworks en France
ont du \^etre confidentielles~: avec une sortie fin aout 2017, ce ne
sont pas des scolaires qui ont achet\'e, uniquement des
passion\'es et des profs (avec le soutien de L. Ch\'eno de l'inspection
g\'en\'erale). En 2018/19, quelques profs 
enthousiastes (en particulier par le module de programmation en Python)
ont commenc\'e \`a recommander la Numworks \`a
leurs \'el\`eves, mais les ventes \'etaient certainement encore
faibles (j'estime \`a quelques milliers d'unit\'es). Le succ\`es en France s'est dessin\'e \`a la
rentr\'ee 2019 (j'estime qu'ils ont vendu 10 \`a 15 000 calculatrices en
2019/20) et encore plus en 2020 (probablement le double).
\`A la rentr\'ee 2022, j'estime que Numworks poss\`ede environ la moiti\'e
du march\'e des calculatrices couleurs avec de l'ordre de
40 000 calculatrices vendues par an.
Je pense que c'est en voyant
les ventes d\'ecoller \`a la rentr\'ee 2019, que Numworks a d\'ecid\'e de
tourner le dos  au calcul formel sur leurs
calculatrices, par crainte de ne pas pouvoir se d\'evelopper \`a
l'\'etranger, alors qu'en mai 2019, ils envisagaient encore la chose
en se disant que cela pouvait aider \`a booster les ventes en France
(sinon ils ne m'auraient pas propos\'e de signer un accord de
confidentialit\'e). Ils ont d\^u \^etre tr\`es d\'esagr\'eablement
surpris de la solution technique r\'ealis\'ee par zardam (et qui est
sans \'equivalent de leur cot\'e \`a ce jour!), alors qu'ils
esp\'eraient sans doute pouvoir bloquer la diffusion par des questions de licence.
La suite n'a fait que confirmer cette tendance~: ils ont commenc\'e par
cacher les
(maigres) capacit\'es de calcul symbolique d'Epsilon (on peut
les retrouver dans Omega et Khi), puis d\'ecid\'e de verrouiller
leurs calculatrices et modifi\'e la licence d'Epsilon. 

En 2023, les chiffres de vente d'amazon sont disponibles, on peut estimer
les ventes (probablement mondiales) à 30 000 unités via ce distributeur.
Pas d'estimations aussi précise sur les autres canaux de vente, 
on sait juste qu'à la rentrée 2023 la TI83
et la Numworks se disputaient la 1ère place à la fnac. Probablement
un peu plus de 80 000 unités vendues dans le monde en 2023, dont au moins
4/5èmes en France, 
et des parts de marché qui continuent à progresser en France, précipitant
l'annonce par Casio de nouveaux modèles de calculatrices graphiques
pour la rentrée 2024 en France. 

L'objectif de Numworks,
c'est maintenant le march\'e am\'ericain. 
On verra si ils r\'eussissent aussi bien
qu'en France, o\`u les conditions \'etaient bien plus favorables~:
maintenant ils ne peuvent plus communiquer sur l'open-source,
le chauvinisme ne va pas dans le bon sens (vis-\`a-vis de Texas
Instruments en particulier) et il n'y a probablement pas
d'\'equivalent \`a un inspecteur g\'en\'eral
qui vous soutient parce que vous allez dans le sens de sa r\'eforme Python.
Pour le moment, le décollage aux US semble plus lent qu'anticipé par Numworks.
C'est un pari pour Numworks, sans compter que TI est sans doute vaccin\'e par ce
qui s'est pass\'e en France. Le choix fait par Numworks
risque d'\^etre perdant-perdant~: malgr\'e sa faible m\'emoire, la
N0110 est (je devrais plut\^ot dire \'etait) une calculatrice avec un excellent
rapport qualit\'e-prix pour installer Khicas (avec Xcas en
parall\`ele), et cot\'e Numworks, KhiCAS ouvrait le march\'e
fran\c{c}ais des BTS et pr\'epas scientifiques, et aux USA des tests
autorisant le calcul formel.

En conclusion, c'est quand m\^eme dommage de ne pas chercher
une solution qui permette aux élèves français équipés de Numworks
de ne pas être défavorisés par rapport à ceux équipés de modèles
CAS haut de gamme (TI Nspire CX2, HP Prime ou Casio Classpad), 
il y a pas mal de possibilités techniques (par
exemple avoir deux mod\`eles de calculatrices, avoir plusieurs modes
examens, signer KhiCAS pour la France...). Il est
d'ailleurs assez
symptomatique que Numworks ait discut\'e du verrouillage pendant plusieurs mois
avec beaucoup de monde dans la communaut\'e ... mais jamais avec moi!

\subsection{D\'evelopper pour Epsilon/Omega/Upsilon vs Giac/KhiCAS~: une querelle ancien-moderne?}
Epsilon (et ses d\'eriv\'es) est \'ecrit en C++ 
en utilisant des fonctionnalit\'es
avanc\'ees du langage, il est difficile de naviguer dans le code
source avec des \'editeurs comme emacs (il y a beaucoup de petits
fichiers sources avec des arborescences profondes et des espaces
de noms imbriqu\'es) et pour compiler il faut une version
r\'ecente de gcc (9). Giac est aussi \'ecrit en C++ mais en fait c'est un
style tr\`es proche du C, imp\'eratif, avec des noms de fonction
courts, peu de fichiers sources dans un m\^eme r\'epertoire
et on peut compiler avec des versions anciennes de gcc (4).

Epsilon n'utilise pas les librairies standards (libc, libstdc++) 
contrairement \`a Giac. Il n'y a pratiquement pas de m\'emoire
sur le tas pour allouer des structures de donn\'ees avec malloc ou
new. Je pense que ce choix, li\'e aux faibles capacit\'es m\'emoire
de la calculatrice, a fait et fait perdre pas mal de temps de
d\'eveloppement, d'abord parce que dans les premi\`eres versions
 Epsilon utilisait le tas, ils a fallu r\'e\'ecrire ensuite autrement,
 ensuite parce qu'ils doivent rajouter manuellement des algorithmes
standard des librairies standards lorsqu'ils en ont besoin, enfin
parce que l'architecture du syst\`eme est beaucoup plus complexe. 

La complexit\'e est parfois n\'ecessaire, mais si on se laisse
fasciner, on risque d'oublier l'objectif ou/et coder de mani\`ere
inefficace ou renoncer devant des objectifs plus difficiles. 
Et surtout la marche est haute pour commencer \`a 
d\'evelopper~: ici il faut s'approprier une architecture
complexe et compiler un firmware complet,
voir par exemple
\ahref{https://www.codingame.com/playgrounds/55846/reader-faire-une-application-pour-omega-sur-numworks/introduction}{un
  tutoriel ici}. Tr\`es bien fait, mais on est d\'ej\`a bien fatigu\'e
avant d'avoir pu \'ecrire un algorithme un peu original! Pas \'etonnant
finalement qu'il n'y ait que deux applications Omega (RPN et Atomic)
qui ne sont pas de Numworks (trois si on y ajoute External qui permet
d'utiliser KhiCAS, un \'editeur hexa, des jeux), alors
que les sources de l'OS sont disponibles depuis 5 ans.
Upsilon, un fork du projet Omega, est de mon point de vue
un peu meilleur sur cet aspect de développement original, avec
une application liseuse de fichiers texte (support partiel de commandes
LaTeX) et un support de MicroPython plus récent que celui
de Numworks et avec des modules scientifiques complémentaires.
On peut aussi observer que ni Epsilon ni ses forks ne proposent de tableur,
plus de 5 ans apr\`es la sortie de la premi\`ere version d'Epsilon.
(alors qu'il existait plusieurs tableurs d\'evelopp\'es par la
communaut\'e pour
les HP48 il y a 25 ans, bien sur, avec une interface plus rudimentaire,
mais fonctionnels). Il y a des centaines de programmes disponibles
pour les calculatrices concurrentes avec des communautés assez actives,
on ne peut pas dire que c'est le cas pour la Numworks, l'activité
récente de Omega et Upsilon consiste essentiellement à rester compatible
avec les protections des dernières versions d'Epsilon.

On verra s'il y a d'autres d\'eveloppeurs qui se
lancent pour cr\'eer des applications externes avec ce que propose Epsilon
16 ou supérieur,
mais le squelette d'application exemple est aussi relativement complexe,
cf. \ahref{https://github.com/numworks/epsilon-sample-app-cpp}{l'exemple},
avec 21 fichiers sources pour 773 lignes de code.
On peut comparer avec les exemples d'applications additionnelles
dans KhiCAS de complexit\'e croissante, allant de la suite de
Syracuse (25 lignes) \`a la fractale de
Mandelbrot (29 lignes), au mastermind (132 lignes) ou au tableau
p\'eriodique (environ 400 lignes) jusqu'au tableur (un peu plus de
1000 lignes), le tout dans un ou deux fichiers source (kadd.cc, 
kdisplay.cc pour le tableau p\'eriodique).

Comme je l'\'ecrivais en titre, c'est peut-\^etre une querelle
ancien-moderne. Mais peut-\^etre aussi une question de culture.
Le matheux que je suis voit vraiment l'informatique comme un outil
pour calculer, et \'ecrire des algorithmes, en g\'en\'eral en lien
avec les maths. \'Ecrire du code d'interface ne m'int\'eresse pas, je
le fais par obligation. L'inverse est certainement vrai pour beaucoup
de passion\'es d'informatique, en tout cas c'est mon impression
quand j'enseigne les maths en parcours informatique ou quand 
j'\'echange sur les forums. Lorsque Numworks dit que sa calculatrice
va faire aimer les maths, cela n'a absolument pas le m\^eme sens
pour eux que pour moi. Pour eux, cela veut visiblement dire proposer
une belle interface qui donne aux \'el\`eves avec le moins d'effort
possible les r\'eponses aux probl\`emes types de maths donn\'es au lyc\'ee.
Alors que moi je souhaite rendre les \'el\`eves autonomes pour
\^etre capable de r\'esoudre des probl\`emes en-dehors des exercices
types de lyc\'ee, et 
donner aux \'el\`eves motiv\'es l'envie d'aller
au-del\`a des programmes scolaires en utilisant toute la puissance
de calcul \`a leur disposition sur la calculatrice pour explorer.
Malheureusement, j'ai l'impression que de moins en moins
de gens sont de mon avis, y compris chez certains profs de maths.
La principale raison \`a mon avis, c'est le d\'eclassement
du m\'etier de prof, qui a conduit \`a une crise de recrutement,
et un niveau moyen en maths des \'etudiants au capes de plus en plus
faible. Parall\`element, le mauvais usage des outils de calcul (en
presse-boutons) conduit \`a une contre-r\'eaction hostile parmi
les profs de maths qui sont bons dans leur discipline.

Il y a aussi une controverse sur les outils de d\'eveloppement et collaboration.
L'outil de synchronisation \`a la mode aujourd'hui est \verb|git| avec un 
h\'ebergement sur \verb|github| et les jeunes ne jurent que par
Discord. Personnellement,
je travaille essentiellement seul et j'ai l'habitude d'utiliser des 
archives tar pour mes sauvegardes.
Pour collaborer, j'ai l'habitude d'utiliser \verb|svn|, que je trouve
plus simple pour faire un commit que \verb|git| (une \'etape et pas
deux). Je n'aime pas du tout l'id\'ee d'h\'eberger des projets sur
\verb|github|, cela donne trop de controle \`a l'h\'ebergeur
(Microsoft ici) et c'est aussi bien trop centralis\'e \`a mon gout
(le contraire
de ce qui a donn\'e naissance \`a Internet), sans compter
que le cout en ressources doit \^etre gigantesque.
Si d'autres d\'eveloppeurs le font, je respecte leur choix, 
et je consulte ou utilise du code source ind\'ependamment de
la fa\c{c}on dont il est produit et publié, ce qui importe c'est le code
lui-m\^eme.
Je n'ai jamais essay\'e Discord et je n'ai pas
l'intention d'essayer, c'est peut-\^etre
tr\`es convivial en particulier pour de la communication synchrone, 
mais c'est du logiciel propri\'etaire sur
lequel on n'a aucun controle alors qu'il y a des logiciels libres 
qui permettent de g\'erer des forums, o\`u on discute
de mani\`ere asynchrone  ce qui de plus me convient mieux.
Bref, je ne vois pas au nom de quoi github+discord devrait \^etre la seule et
unique fa\c{c}on de d\'evelopper et collaborer, surtout que cela pourrait
\^etre remplac\'e par d'autres outils dans quelques ann\'ees
(comme cvs par svn puis git, ou SourceForge). Il y a une forme
d'int\'egrisme dans l'usage de l'outil informatique chez certains
(y compris au plus haut niveau de l'\'education nationale avec
l'imposition de Python comme unique langage de programmation 
au lyc\'ee),
qui devient un peu comme une religion. 
Il serait souhaitable je pense qu'il y ait plus
de tol\'erance, la diversit\'e est une richesse.

Je travaille depuis 24 ans
sur Giac et je programme du calcul formel depuis 30 ans,
au d\'ebut le web n'existait m\^eme pas, les \'echanges se faisaient
via des newsgroup et des serveurs ftp. Je ne suis sur aucun r\'eseau
social, ni sur des syst\`emes d'\'echange synchrones 
et je n'en vois pas trop l'int\'er\^et, la consultation
asynchrone de forums et d'emails me semble bien plus appropri\'e, on
est dans sa bulle quand on code et on ne se laisse pas distraire 
par des notifications. Je ne me pr\'ecipite pas sur la derni\`ere
mise \`a jour ou la derni\`ere nouveaut\'e, j'ai appris \`a mes d\'epens 
que quand quelque chose marche, il faut y r\'efl\'echir \`a deux
fois avant de le modifier (et bien conserver une sauvegarde de 
ce qui marchait). J'ai aussi appris que le monde est complexe, il m'a fallu
parfois plusieurs mois pour porter Giac et ses d\'ependances 
sur une calculatrice. Les
erreurs de compilation ou d'\'edition de liens lors d'un nouveau portage 
sont normales et se comptent souvent par centaines. Si on ne travaille
que sur des petits projets ou des projets r\'ecents, on risque de prendre
des habitudes de confort o\`u tout marche du premier coup et 
de renoncer \`a la premi\`ere difficult\'e.


%% \section{Si vous avez mis \`a jour vers Epsilon 16 sans en connaitre
%%   les cons\'equences.}
%% \label{sec:appendix}

%% Une faille du syst\`eme de verrouillage a \'et\'e d\'ecouverte par
%% M4x1m3,
%% {\bf il est donc temporairement possible \`a la date du 27 mars 2022
%% de d\'everrouiller votre calculatrice si elle est verrouill\'ee,
%% rendez-vous \ahref{https://phi.getomega.dev/}{ici}}. Numworks a combl\'e
%% cette faille le 28 mars, si vous avez mis \`a jour apr\`es, 
%% la faille ne fonctionnera plus pour vous, je vous invite \`a lire le reste de cette section.

%% Remarque pr\'eliminaire~: je ne suis pas juriste, et de toutes
%% fa\c{c}ons le droit est soumis \`a des interpr\'etations, contrairement
%% \`a la preuve d'un th\'eor\`eme math\'ematique. N\'eanmoins, j'ai pas mal
%% \'etudi\'e les questions juridiques li\'ees aux logiciels, j'en ai
%% discut\'e et jusqu'\`a pr\'esent personne n'a contest\'e
%% s\'erieusement cette analyse. Si vous y voyez des erreurs, merci de me
%% les signaler.

%% Si vous avez mis \`a jour vers Epsilon 16 sans en r\'ealiser toutes
%%   les cons\'equences\footnote{Attention, vous n'\^etes pas concern\'e
%%   si vous avez achet\'e une calculatrice qui \'etait pr\'echarg\'ee
%%   avec Epsilon 16}, il vous reste  un recours~: contacter rapidement
%% Numworks et leur demander un moyen
%% technique permettant
%% l'effacement complet de leurs logiciels, i.e. le retour au bootloader de
%% ST (ensuite vous pourrez installer au choix Khi, Omega ou Epsilon 15). Je pense
%% qu'ils n'ont l\'egalement pas le droit de refuser, car pour le moment
%% ils n'affichent aucun avertissement sur le changement de licence du
%% logiciel lors de la mise \`a jour et n'en demandent pas
%% l'approbation. 
%% Voici un argumentaire juridique. 


%% L'utilisation du logiciel de
%% la calculatrice se fait selon un contrat de licence qui lie
%% l'utilisateur \`a l'\'editeur (Numworks). En l'absence d'autre
%% indication\footnote{Contrairement \`a d'autres constructeurs. Par
%%   exemple lors de l'achat d'une TI Nspire CX, j'ai trouv\'e dans le
%%   boitier un contrat de licence imprim\'e intitul\'e ``Les unit\'es Nomades
%%   d'Apprentissage des Math\'ematiques et des Sciences TI-Nspire 3.x,
%%   Licence Individuelle d'Utilisation'' qui reprend des extraits de
%%   lois du code de la propri\'et\'e intellectuelle},
%%  c'est
%% la licence indiqu\'ee sur le site github d'Epsilon qui fait foi, 
%% pour la version 15.5 d'Epsilon ou pour Omega ou Delta 
%% ``NumWorks Epsilon is released under a 
%% \ahref{https://github.com/numworks/epsilon/blob/version-15/LICENSE}{[CC
%%   BY-NC-SA License]}''
%% Pour la version 16, la mention a \'et\'e chang\'ee en ``All rights
%% reserved'' (commit f06b642 le 30 Juillet 2021 par EmilieNumworks). 

%% C'est une diff\'erence fondementale en droit avec les mises \`a jour
%% pr\'ec\'edentes d'Epsilon (ou celles propos\'ees par les constructeurs concurrents).
%% car ce changement de licence logicielle est une modification unilat\'erale
%% du contrat de licence. 
%% \ahref{https://www.legifrance.gouv.fr/codes/article_lc/LEGIARTI000032041314}{L'article
%%  1193} du code civil stipule que
%% ``Les contrats ne peuvent être modifiés ou révoqués que du
%% consentement mutuel des parties, ou pour les causes que la loi
%% autorise''. Comme il ne s'agit pas ici d'un cas particulier autoris\'e
%% par la loi, Numworks aurait du vous avertir du changement de licence
%% et vous demander d'approuver la modification du contrat (et pour un
%% \'el\`eve mineur, je pense que c'est
%% un repr\'esentant l\'egal qui doit approuver la nouvelle licence). 

%% Or cela n'est pas fait me semble-t-il sur le site de Numworks lors de la
%% mise \`a jour (je n'ai \'evidemment pas test\'e toute la proc\'edure
%% en risquant de voir ma calculatrice mise \`a jour). Rien n'est
%% explicitement indiqu\'e
%% dans la lettre d'information Numletter du 1er Septembre incitant \`a
%% faire cette mise \`a jour 
%% ``Nous vous invitons à installer la dernière mise à jour disponible
%% (version 16) sur votre calculatrice pour profiter de nos
%% nouveautés. Léo vous enverra très prochainement un email pour vous les
%% détailler.'' et dans la lettre du 6 octobre de L\'eo, on a d\'ej\`a \'et\'e
%% invit\'e par trois fois \`a faire la mise \`a jour avant d'avoir un
%% lien sur les changements li\'es \`a la s\'ecurisation.

%% Si Numworks refuse de vous permettre de d\'everrouiller votre calculatrice,
%% en argumentant sur une exigence de s\'ecurit\'e aux examens, vous
%% pouvez contrer l'argument en indiquant que la r\'eglementation
%% n'a pas \'evolu\'e en France\footnote{Et m\^eme si la r\'eglementation
%%   \'evolue,  il y a une hi\'erachie en droit, une loi est prioritaire sur une
%%   r\'eglementation}.
%% De plus, si vous avez install\'e KhiCAS,
%% vous pouvez certifier sur
%% \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/nws.html}{cette
%% page} que le firmware install\'e est conforme \`a la r\'eglementation en vigueur en France.

%% Agissez vite, plus le temps passe, plus votre absence de r\'eaction
%% risque d'\^etre interpr\'et\'ee comme une acceptation tacite de la
%% nouvelle licence. Par comparaison, la modification unilatérale par 
%% le fournisseur d’un service de communications est possible dès lors 
%% que l’abonné est informé d’une telle modification et qu’il a la
%% liberté de sortir du contrat, mais il y a un d\'elai pour sortir du
%% contrat. La sortie du contrat de licence signifie ici que l'on doit
%% pouvoir effacer tous les logiciels sous licence avec Numworks, y compris
%% le logiciel de verrouillage, et revenir au bootloader de ST. Pour cela
%% Numworks pourrait publier un mini-firmware sign\'e qui repasse la protection
%% de niveau 1 au niveau 0, ce qui a pour effet d'ex\'ecuter un
%% effacement complet (il est d'ailleurs fort possible que ce
%% mini-firmware existe d\'ej\`a en usage interne chez Numworks).

%% Il ne faut probablement pas s'attendre \`a une r\'eponse positive de
%% Numworks sur un simple email du type ``Je veux retourner en version 15.5'',
%% il faut bien motiver votre courrier. Il faudra peut-\^etre
%% une pression plus importante, \c{c}a peut \^etre un nombre
%% important de courriers (surtout si ce sont des profs qui les
%% \'ecrivent), ou ayant un aspect plus officiel (par exemple
%% courrier d'une association de consommateurs,
%% lettre recommand\'ee avec accus\'e de r\'eception...).
%% Si la pression est suffisamment importante, j'esp\`ere que Numworks
%% r\'ealisera que sa meilleure strat\'egie\footnote{Certainement
%% meilleure que de finir comme
%% \ahref{https://www.playstationlifestyle.net/2016/06/21/sony-closing-in-on-settlement-for-ps3-linux-debacle/}{le
%%   cas de la console PS3/linux}.
%% Si on compare avec ce cas, on peut quantifier la perte de
%% fonctionnalit\'e CAS du verrouillage d'Epsilon 16 en
%% regardant la diff\'erence de prix entre calculatrice
%% non CAS et CAS qui est d'environ 50 euros.
%% } est de permettre aux
%% possesseurs de Numworks N0110 de d\'everrouiller leurs calculatrices,
%% et de vendre \`a destination des USA (et autres march\'es dont
%% ils envisagent la conqu\^ete) un nouveau mod\`ele (disons une N0120)
%% verrouill\'ee d\`es le d\'epart. D'autant plus que du point de vue
%% s\'ecurit\'e c'est une solution bien plus sure. En effet, rien
%% n'emp\^eche un possesseur de Numworks N0110 non verrouill\'ee
%% de simuler ce qu'un surveillant pourra raisonnablement v\'erifier,
%% par exemple le num\'ero de version dans les Param\`etres. Avec un
%% mod\`ele diff\'erent et facile \`a distinguer, il suffit aux pays
%% qui le souhaitent d'autoriser la N0120 et interdire la N0110.

\section{\'Equivalents dans $\chi$CAS de fonctionnalit\'es math\'ematiques
d'Epsilon $\geq$ 16.} \label{sec:eps18}
Dans cette section on explique comment faire avec $\chi$CAS
pour retrouver les fonctionnalit\'es math\'ematiques r\'ecemment
introduites par Numworks dans Epsilon.
En effet $\chi$CAS s'utilise conjointement avec la version 15.5 d'Epsilon
et il n'est pas commode ou pas possible d'installer une version plus 
r\'ecente d'Epsilon en parall\`ele.

\begin{itemize}
\item Epsilon 16: R\'esolution exacte d'\'equations polynomiales de degr\'e 3.\\
Utiliser la commande \verb|solve| (menu rapide shift-2). Par exemple\\
\giacinputmath{solve(x^3-x^2+x-1=0)}\\
Le solveur de $\chi$CAS d\'etermine les solutions rationnelles 
pour toutes les \'equations polynomiales. Il g\`ere aussi certaines
autres \'equations, parfois \`a l'aide de fonctions sp\'eciales,
par exemple\\
\giacinputmath{solve(x-2=ln(x))}
\item Epsilon 17: Coniques.\\
Vous pouvez tracer n'importe quelle conique avec la commande \verb|plot|
(menu rapide shift-3), par exemple\\
\giacinput{plot(x^2+y^2+x*y=4)}\\
Pour tracer plusieurs graphes simultan\'ement, s\'eparez les commandes de
trac\'e par \verb|;|. Pour donner une couleur \`a un trac\'e, utilisez
un argument optionnel en fin de commande, par exemple\\
\giacinput{p=plot(x^2+y^2+x*y=4,color=red)}\\
Pour d\'eterminer le centre, un foyer et un point sur le grand axe 
de cette ellipse, on peut utiliser la commande
\verb|centre| qui se trouve dans le menu principal (touche Toolbox),
sous-menu G\'eom\'etrie (raccourci $x^2$)\\
\giacinput{centre(p),0}\\
(le \verb|,0| a \'et\'e ajout\'e pour voir les coordonn\'ees des points,
sinon les points sont affich\'es dans un graphique).
La commande \verb|rayon| affiche les valeurs des param\`etres $a,b,c,e$ 
de l'ellipse.
\item Epsilon 17, in\'equations.\\
Pour tracer un graphe d'in\'equation, on utilise aussi la commande
\verb|plot|, par exemple\\
\giacinput{plot(4>x^2+y^2+x*y)}\\
Il est possible de combiner plusieurs in\'equations\\
\giacinput{plot(4>x^2+y^2+x*y and x>y)}\\
On peut bien sur combiner des trac\'es d'in\'equations avec d'autres
trac\'es de graphes (menu Toolbox Courbes) ou g\'eom\'etriques 
(menu Toolbox G\'eom\'etrie), il suffit de taper 
les commandes correspondantes dans une m\^eme ligne
de commande en les s\'eparant par un \verb|;|.
\item Epsilon 17: Pente, \'equation d'une droite\\
Utiliser la commande \verb|slope| ou \verb|equation| ou \verb|parameq|, 
par exemple\\
\giacinput{slope(droite(point(1,2),point(-1,1)))}
\item Epsilon 17: tests statistiques, intervalles de confiance\\
Test du $\chi^2$: \verb|chisquaret|. Taper \verb|chi| puis la touche
fl\`eche vers le bas, puis s\'electionner la commande, vous avez une
description et deux exemples.\\
Autres tests:  Kolmogorov-Smirnov \verb|kolmogorovt| (taper \verb|k|
puis fl\`eche vers le bas, etc.), test Z de la loi normale \verb|normalt|,
test de Student \verb|studentt|.\\
Pour les intervalles de confiance, on peut utiliser les distributions
inverses, le nom de commande est le nom de la loi suivi du suffixe
\verb|_icdf| par exemple \verb|normald_icdf| pour la loi normale\\
\giacinput{normald_icdf(0.975)}
\item Epsilon 18, finances\\
$\chi$CAS dispose d'une application finance, depuis le menu des applications
shift Ans 
\end{itemize}

\end{giacjshere}
\end{document}
