% Merci a Yannick Chevallier pour la version mathjax-enabled
\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{amsmath,amsfonts,amssymb}
\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.ujf-grenoble.fr/\home{parisse}/giac_fr.html}{Giac/Xcas}.}
\giacmathjax
%HEVEA\renewcommand{\footertext}{}

\begin{document}
\title{$\chi$CAS pour TI Nspire CX et CX II}
\author{Bernard.Parisse@univ-grenoble-alpes.fr}
\date{2022}

\begin{giacjshere}

\maketitle

\tableofcontents

%\printindex

\section{Introduction}
Ce document explique comment prendre en main et utiliser efficacement
sur calculatrices TI Nspire CX
le syst\`eme de calcul formel $\chi$CAS (une version adapt\'ee
du
\ahref{https://www-fourier.ujf-grenoble.fr/\home{parisse}/giac_fr.html}{logiciel
  Xcas} pour cette calculatrice)
ainsi que l'environnement MicroPython le plus complet \`a ce jour pour faire
des math\'ematiques sur calculatrices (section \ref{sec:micropy}).

$\chi$CAS est une calculatrice graphique formelle ind\'ependante
de la calculatrice nspire avec 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,
g\'eom\'etrie analytique, 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.

Toutes ces fonctionnalit\'es 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. De plus
les sessions de calcul sont compatibles avec Xcas, Xcas pour Firefox
et avec d'autres calculatrices compatibles $\chi$CAS (Numworks,
Casio Graph 90 et 35eii).

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 et la vitesse
de la TI (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}

Avant d'installer $\chi$CAS, vous devrez installer
\ahref{http://ndless.me/}{ndless}
en suivant l'un des tutoriels suivants~:
\begin{itemize}
\item Tutoriel si vous poss\'edez une
\ahref{https://tiplanet.org/forum/viewtopic.php?t=20446}{Nspire CX
 ou CX CAS avec OS 4.5.0 ou inf\'erieur}.
\item Tutoriel si vous poss\'edez une
\ahref{https://tiplanet.org/forum/viewtopic.php?f=57&t=24267}{Nspire 
CX ou CX CAS avec un OS 4.5.x (x entre 1 et 3)}
\item Tutoriel si vous poss\'edez une
\ahref{https://tiplanet.org/forum/viewtopic.php?f=57&t=24264}{Nspire
  CX II ou CX CAS II}
\end{itemize}

Ensuite, ouvrez le logiciel de communication de la TI Nspire et
transf\'erez
\begin{itemize}
\item \verb|luagiac.luax.tns| et \verb|khicaslua.tns| (interface
  pretty print)
\item \verb|khicas.tns| (interface shell)
\item \'eventuellement le r\'epertoire d'exemples \verb|Xcas|.
\end{itemize}

{\bf Examens}~:
\begin{itemize}
\item {\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.
\item $\chi$CAS n'est pour l'instant pas compatible avec le mode examen.
\end{itemize}

{\bf Mise en garde}~:\\
Texas Instruments ne semble pas vouloir laisser ses utilisateurs 
libres d'utiliser des \ahref{http://ndless.me/#apps}{programmes ndless}, et
fait tout son possible pour rendre ndless inutilisable \`a chaque mise
\`a jour (en g\'en\'eral sous pr\'etexte de ``s\'ecurit\'e''). 
Si vous faites une mise \`a jour \`a partir d'octobre 2020, vous 
prenez le risque de ne plus pouvoir utiliser ndless donc de ne plus
pouvoir utiliser $\chi$CAS. {\bf Je vous conseille vivement de ne jamais
faire de mise \`a jour de votre TI Nspire sans vous \^etre bien renseign\'e sur
le site \ahref{https://tiplanet.org}{tiplanet}}.

% https://en.wikibooks.org/wiki/Unofficial_Guide_To_Expanding_Your_TI/Getting_your_development_environment_set_up#Installing_other_needed_software_and_cloning_the_source
\section{Interface "pretty print"}
Cette interface ouvre un \'ecran de calcul similaire \`a celui du Scratchpad de
la TI Nspire (A Calculs du menu principal).
\`A privil\'egier si vous voulez surtout faire des
calculs en profitant de la saisie 2d des expressions.
Si vous n'\^etes pas sur l'\'ecran d'accueil de la Nspire, tapez la touche ON/HOME.
Ensuite tapez 2, puis s\'electionnez \verb|khicaslua|.

Les commandes les plus utilis\'ees de Xcas sont list\'ees depuis la touche menu.
On peut acc\'eder au shell (section \ref{sec:shell}) en tapant \verb|*| sur une ligne vide, et
\`a l'\'editeur de scripts (section \ref{sec:prog}) en tapant \verb|+|
ou \verb|+"nom_de_fichier"| (mettre le nom du script sans l'extension \verb|.py.tns|).

\section{Interface shell: premiers pas} \label{sec:shell}
Si vous n'\^etes pas sur l'\'ecran d'accueil de la Nspire, tapez la touche ON/HOME.
Ensuite tapez 2, puis s\'electionnez \verb|khicas|
et tapez sur enter (vous pouvez aussi aller dans le r\'epertoire
Xcas et s\'electionner un exemple puis touche enter pour ouvrir un exemple).
Ceci ouvre apr\`es une dizaine de secondes un ``shell'' dans lequel vous pourrez
taper les commandes de calcul formel de Xcas. Lors de la
premi\`ere ex\'ecution vous devrez choisir entre l'interpr\'eteur Xcas
et l'interpr\'eteur MicroPython. Taper enter pour choisir Xcas (sauf
si vous \^etes principalement int\'eress\'e par l'environnement
Python, cf. la section \ref{sec:micropy}).
\\
Pour quitter $\chi$CAS et revenir \`a l'explorateur de la Nspire, il
faut taper la touche doc (doc signifie documents) 
plusieurs fois (deux fois depuis le shell).

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

Vous pouvez utiliser le r\'esultat de la derni\`ere commande
avec la touche Ctrl-\verb|Ans| de la calculatrice (ans en couleur au-dessus
de la touche \verb|(-)|).
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 (Ctrl puis \verb|var|),
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 doc, choisissez une cat\'egorie avec le curseur, 
par exemple \verb|Algebre|, tapez enter,
puis choisissez une commande avec le curseur, par exemple \verb|factor|.
Un deuxi\`eme appui sur la
touche doc vous affiche une courte description de la commande,
en g\'en\'eral avec un exemple. En tapant sur tab (ou enter), vous recopiez
l'exemple en ligne de commande. Vous pouvez alors valider (enter) ou
modifier la commande et valider (enter) 
pour factoriser un autre polyn\^ome que celui
donn\'e en exemple.

Lorsqu'une commande 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 esc pour revenir au shell.

Maintenant essayez de taper la commande \verb|plot(sin(x))|.
Indication: taper doc, puis s\'electionner 
\verb|Courbes|, ou 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 esc pour revenir au shell.

Vous pouvez effacer l'historique des calculs et les variables
pour commencer un nouvel exercice~: depuis le menu \verb|doc|
s\'electionnez \verb|9 Effacer historique|.
Vous avez ensuite le choix entre
effacer l'\'ecran en conservant les variables
(touche de validation \`a droite de la touche U)
ou en les effa\c{c}ant (esc). 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, appuyez sur la touche \verb|doc| 2 fois.
Lorsque vous lancez
une autre application, les variables et l'historique des calculs
sont sauvegard\'es (dans le fichier \verb|session.xw.tns| du
r\'epertoire Xcas de la Nspire), 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|.|,
  \verb|(| et \verb|)|
  pr\'ec\'ed\'ees de shift 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 tab ou enter\\
  Modifiez l'expression \`a int\'egrer selon vos besoin puis tapez enter
%% \item Lorsque la m\'emoire est presque satur\'ee, les calculs
%%   sont automatiquement
%%   interrompus et un message d'avertissement apparait. Il faut alors
%%   effacer des variables avec la commande \verb|purge|
%%   (accessible depuis la touche \verb|var|).
\end{itemize}

\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 TI
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 (doc), 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|'| (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
  \ifhevea
  \giacinputmath{tabvar(x^3-7x+5)}
  \else
  \verb|tabvar(x^3-7x+5)|
  \fi
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|
(doc 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|
(doc 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
(jusque 128 bits environ).
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 \verb|doc 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|
(menu 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|
(menu 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| (doc \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 F1). 
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 F2).

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|
(menu 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}
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|doc 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 enter|
(ou \verb|doc 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 enter.

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}
Depuis le catalogue, s\'electionner le sous-menu \verb|Courbes|
(acc\`es rapide par doc 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|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 doc , 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|.
\end{itemize}
On peut tracer simultan\'ement plusieurs graphiques, il suffit de s\'eparer
les commandes de trac\'e par \verb|;|

Le menu \verb|Options| (menu ,)
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, utiliser la touche OPTN,
s\'electionner \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 \mathbb{R}$
ou \verb|plot((x+i*y)^2-9)| pour représenter
la fonction de $\mathbb{C} \rightarrow \mathbb{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.}
Les versions récentes de $\chi$CAS proposent une application
de géométrie interactive 2d et 3d.
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).

{\bf Modes, vue graphique et symbolique.}\\
Taper doc 1  pour afficher la liste des
applications additionnelles, puis enter 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 doc 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 menu, pour passer en vue symbolique et vice-versa taper enter.
Par exemple tapez menu 3 pour passer en mode point
qui permet de construire des points en déplaçant
le pointeur et en tapant enter ou tapez menu 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 enter
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 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 ret pour passer à la ligne. Tapez enter
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.

{\bf Exemple~: cercle circonscrit.}\\
Depuis le shell, taper doc 1 sélectionner nouvelle figure 2d et valider enter.
Puis menu 5 Triangle, enter pour créer le premier sommet du triangle
puis déplacer le pointeur avec les touches de déplacement, enter pour créer
le 2ème sommet du triangle, déplacer le pointeur à nouveau et enter
pour créer le triangle.

Version longue en construisant le centre~:
Taper menu 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 enter pour créer la médiatrice du segment, déplacer le curseur
sur une autre arête du triangle et enter pour créer la 2ème médiatrice,
optionnellement sur le 3ème segment pour avoir les 3 médiatrices.
Puis menu 6 et 4 Intersection unique. Déplacer le curseur vers
une des médiatrices, taper enter puis vers une autre médiatrice, taper enter,
ceci crée le centre du cercle circonscrit. Pour tracer le cercle,
taper menu 4, déplacer le curseur au centre du cercle (vous pouvez
utiliser les touches de déplacement ou juste taper
H ou la bonne lettre si le centre du cercle s'appelle autrement),
puis enter puis sur un des sommets et enter.

Version courte avec la commande \verb|circonscrit|~:
taper menu 9 puis circonscrit puis sélectionner chaque
sommet avec enter (A enter B enter C enter, remplacez
si nécessaire 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 ret s'il
faut en créer une), taper\\
\verb|c:=circonscrit(A,B,C)| enter

{\bf Exemple 3d: bac septembre 2019~}\\
Taper doc enter pour lancer l'application de géométrie puis nouvelle figure 3d.
Puis Back ou enter pour passer en vue symbolique. Puis c shift =
puis menu flèche haut deux fois pour sélectionner 3D puis enter puis 5 pour cube
puis doc (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 enter pour voir le cube puis + plusieurs fois pour zoomer et enter
pour revenir à la vue symbolique.
Vous pouvez sauvegarder à tout moment la construction au format
texte depuis
le menu doc.
On passe à la ligne en tapant shift enter. Puis on définit les sommets
du cube en tapant \verb|A,B,C,D,E,F,G,H:=|
(taper A , B etc.),
puis menu 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| enter et mettre c en argument \verb|sommets(c)|.
Taper enter pour visualiser puis enter à nouveau pour revenir en vue
symbolique. Passer à la ligne avec ret puis créer le plan ABG
en tapant 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 enter enter.
On passe à la ligne (ret) et on crée le segment DE
S = shift 2 sélectionner la commande segment avec enter
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).
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 enter pour la visualiser et utiliser les flèches de
déplacement pour changer de point de vue. Taper enter ou Back pour revenir
en vue symbolique. Pour quitter l'application taper Back. Taper F1 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
menu Géométrie) vous donnera
l'équation cartésienne du plan $P$ ou \verb|is_orthogonal(P,S)|
(menu Géométrie)
vous confirmera que le plan $P$ est orthogonal au segment $S$.

\section{Unit\'es et constantes physiques.}
Le menu menu, constantes physiques (raccourci \verb|menu pi|)
et unit\'es physiques (raccourci \verb|doc sqrt|) affiche
\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~:\\
\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 sur la touche enter
pour quitter l'\'editeur 2d et copier l'expression en ligne de
commande, taper esc pour quitter sans recopier l'expression.

Exemple 1~: nous allons saisir 
$$ \lim_{x \rightarrow 0} \frac{\sin(x)}{x}$$
Depuis une ligne de commande vide, taper shift-5 (2d), vous devez voir 0 
s\'electionn\'e. Tapez sur la touche x et enter, maintenant c'est x qui
est en surbrillance. Tapez sur la touche trig (trig renvoie sin, shift trig
cos et ctrl trig tan), c'est $\sin(x)$ qui
est en surbrillance. Tapez sur la touche de division (au-dessus de -), 
vous devez voir $\frac{\sin(x)}{0}$ avec 0 en surbrillance, tapez
x puis enter, vous devez voir $\frac{\sin(x)}{x}$ avec
x au d\'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
enter
pour la recopier en ligne de commande et enter \`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) enter.

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)| enter, puis curseur vers
la gauche shift-1 7 enter. Taper sur enter
pour recopier vers la ligne
de commande puis enter  pour effectuer le calcul, le r\'esultat s'affiche
dans l'\'editeur 2d, enter 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)| enter puis enter pour
recopier en ligne de commande puis enter 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 enter (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 
ctrl 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, taper shift-1 2 enter
(factor), puis
descendez la s\'election sur la somme ou diff\'erence de logarithmes,
allez dans le menu \verb|menu| 
puis enter (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 enter (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 ctrl 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 esc pour annuler les modifications ou enter 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 \verb|doc|,
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 enter pour
la recopier en ligne de commande, DEL copie en ligne de commande
la commande d'effacement de la variable (confirmez ensuite avec enter).
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)| (pour saisir \verb|>|,
taper ctrl +)

\subsection{Sauvegarde et compatibilit\'e}
Vous pouvez sauvegarder une session en tapant sur ctrl save ou doc 2.
Vous pouvez ouvrir une session en tapant sur shift save ou doc 4.
Les sessions sont sauvegard\'ees avec un nom de fichier terminant
par \verb|.xw.tns|. Vous pouvez les ouvrir sur votre ordinateur avec Xcas
ou Xcas pour Firefox. R\'eciproquement, doc Fich, Exporter comme
permet de sauvegarder une session dans ce format, ou dans un autre
format pour utiliser votre session sur une calculatrice
$\chi$CAS-compatible. 
Dans Xcas pour Firefox, il faut s\'electionner
dans les param\`etres Nspire CX comme calculatrice puis exporter.

N.B.: vous pouvez sauvegarder le contenu de l'\'editeur de script
ind\'ependamment de la session, les scripts ont un nom de fichier
terminant par \verb|.py.tns|. Il suffit de renommer le script
en enlevant le \verb|.tns| pour utiliser ce script avec n'importe
quel interpr\'eteur compatible Python, par exemple une calculatrice
d'un autre constructeur proposant un interpr\'eteur MicroPython.
R\'eciproquement, vous pouvez importer un script Python en faisant
une copie du fichier en ajoutant \verb|.tns| au nom de fichier
et en le transf\'erant sur le TI Nspire CX. Vous pouvez alors l'ouvrir
dans l'\'editeur de script.

%% \subsection{Sauvegarde et \'echange de sessions avec Xcas.}
%% Depuis l'historique des calculs, avec le menu \verb|menu|, 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} \label{sec:prog}
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. Ce m\^eme environnement peut
utiliser l'interpr\'eteur MicroPython au lieu de Xcas (cf. section \ref{sec:micropy}).

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.

Des programmes sont install\'es dans le r\'epertoire Xcas.
Vous pouvez les visualiser depuis le shell en tapant
\verb|doc| 4 (Charger), et les
ex\'ecuter depuis le shell en tapant ctrl r.

\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}
(pour taper \verb|:|, faire ctrl puis \verb|,|)
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 \verb|menu|, par le raccourci doc $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 esc 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 (menu 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 enter, 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 esc pour passer du shell \`a l'\'editeur de programmes.
Si on vous demande programme ou Tortue faites enter.
Ceci ouvre l'\'editeur avec une maquette de fonction
\verb|def f(x):|
V\'erifiez que la syntaxe Python
est activ\'ee (menu \verb|doc|), sinon activez-la (8).
Remplacez \verb|x| par \verb|n|, puis 
d\'eplacez le curseur en fin de ligne et passez \`a la
ligne (touche \`a la droite de la touche U).
Tapez Shift-2 puis enter (\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 (enter), puis tapez \verb|j,j^2)|. Vous devriez avoir le 
texte source 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 enter.
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 \verb|doc|. Pour l'ex\'ecuter, revenez \`a la
ligne de commande en tapant la touche esc, tapez par
exemple \verb|f(10)|, vous devriez voir s'afficher
les carr\'es de 1 \`a 10.

{\bf Attention} dans l'\'editeur de programmes, l'appui sur la touche
enter interpr\`ete le contenu de l'\'editeur. Pour passer \`a
la ligne suivante, il faut taper sur la touche de validation (\`a
droite de la touche u).

{\bf 3i\`eme exemple~: Calcul de l'intervalle de confiance de terminale}\\
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 doc 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 \verb|doc| 5 (Effacer).
Puis shift-4 \verb|efface|.
Ajouter 4 fois \verb|avance; tourne_gauche;|.
Appuyer sur enter
pour tester. Sauvegardez (\verb|doc| 3 Sauvegarder comme).

Effacer \`a nouveau (\verb|doc| 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 enter.
Ensuite faire \verb|doc| 3 (Sauvegardez comme).

{\bf Un exemple de fonction non alg\'ebrique~: le calcul du PGCD de 2 entiers.}\\
Utiliser enter 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}
On v\'erifie \giacinput{pgcd(12345,3425)}.
Le m\^eme en syntaxe Python 
\begin{giacprog}
def pgcd(a,b):
  while b!=0:
    a,b=b,a % b
  return a
\end{giacprog}

{\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|Xcas| de l'archive 
contient quelques exemples de programmes (avec fr\'equemment
une repr\'esentation graphique) dont~:
\begin{itemize}
\item fr\'equence dans un \'echantillon, intervalle de fluctuations (freq.xw)
\item le paradoxe du duc de Toscane (toscane.xw)
\item r\'esolution d'\'equation du second degr\'e (deg2.xw)
\item dichotomie (dicho.xw)
\item m\'ethode des rectangles (integr.xw),
\item fractale de Mandelbrot (mandel.py)
\item un benchmark utilis\'e par tiplanet pour mesurer la vitesse
de l'interpr\'eteur (qcc.xw)
\end{itemize}

\subsection{Commandes utilisables}
Contrairement aux adaptations de MicroPython propos\'ees par
les constructeurs (dont
celui de la TI Nspire), 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
(touche 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 standard~: 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.
On peut taper \verb|halp('modules')|
pour voir la liste des modules disponibles. Cf
\ahref{https://docs.micropython.org/}{l'aide en ligne de MicroPython}.

\subsection{Le module cas}
Il donne acc\`es depuis MicroPython aux commandes natives de Xcas.
Il contient une seule commande \verb|caseval|, qui prend en argument
soit une chaine de caract\`eres qui sera \'evalu\'ee par
l'interpr\'eteur de Xcas, soit une chaine de caract\`eres (contenant
le nom de commande \`a ex\'ecuter) puis des arguments de type
quelconque (repr\'esentant les arguments). Le r\'esultat est
une chaine de caract\`eres. On peut bien sur appeler \verb|eval|
pour transformer la valeur de retour en objet Python.
Exemples~:
\begin{verbatim}
caseval("sin",0)
caseval("sin(0)")
caseval("integrate","1/x","x")
caseval("integrate","1/x","x",2,3)
a=[1,2,3]
caseval("a:=",a)
caseval("a")
\end{verbatim}
Note: \verb|caseval| poss\`ede deux synonymes \verb|xcas| et \verb|eval_expr|.

\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 \verb|.| 
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 0.

\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.}
Accessibles par le menu \verb|doc| 1 ou le raccourci clavier shift-ANS.
Il y a actuellement la géométrie, le tableur,
le tableau p\'eriodique des \'el\'ements
(d'apr\`es Maxime Friess),
et des exemples d'addin (dont le code source peut servir de mod\`ele aux
programmeurs exp\'eriment\'es souhaitant programmer
des addins pour $\chi$CAS)~: une application finance,
la suite de Syracuse (tr\`es simple), la
fractale de Mandelbrot, un jeu
de mastermind (qui peut aussi servir de patience), 

\section{Raccourcis claviers.} \label{sec:clavier}
\begin{itemize}
\item la touche de validation \`a droite de la touche u n'a pas
  toujours la m\^eme signification que la touche enter, en particulier
  dans l'\'editeur de programmes elle permet de passer \`a la ligne
  et dans l'\'editeur d'expressions elle \'evalue la s\'election
\item la touche \verb|trig| et ses shift/ctrl donnent acc\`es
  aux fonctions \verb|sin, cos, tan|
\item on peut taper ctrl-\verb|*| pour saisir \verb|"| et
  shift-\verb|*| pour saisir \verb|'|
\item le caract\`ere \verb|\| est accessible via ctrl-\verb|/|,
  \verb|%| par shift-\verb|/|.
  \item \verb|;| et \verb|:| sont en shift/ctrl de \verb|,|
  \item shift-1 \`a shift-6: selon le mode (Xcas ou Python)
    voir les l\'egendes
\item mode Xcas~: shift-7 matrices, 8 complexes, 9 arithm\'etique,
  \verb|0| proba et autres, \verb|.| r\'eels,
  \verb|(-)| polynomes, 
 \verb|(| listes, \verb|)| programmation
  %, \verb|)|
\item mode Python~: shift-7 et 8 matrices, 9 arithm\'etique,
0 graphes rep\'er\'es, \verb|.| graphes pixelis\'es, \verb|(-)| couleurs,
 \verb|(| listes, \verb|)| programmation
\item changement d'interpr\'eteur~: shift \verb|)| 8
\item \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,\\
\item  \verb|16=>=>| \'ecrit les entiers qui suivent en base 16,
  \verb|10=>=>| en base 10, \verb|8=>=>| en base 8
\item ctrl puis \verb|p| programmation,
  \item ctrl puis o donne acc\`es au menu d'options
\item ctrl suivi de R dans le shell permet de r\'e-ex\'ecuter
  la session actuelle (run)
\item ctrl suivi de S dans le shell
  permet d'acc\'eder \`a la configuration (setup)
\item ctrl suivi de Z permet en g\'en\'eral
  d'annuler la derni\`ere modification
\end{itemize}

Dans l'\'editeur de programmes~:
\begin{itemize}
\item touches curseur shift\'ees: d\'eplacement en d\'ebut/fin de ligne/fichier.
\item
  ctrl suivi de C permet de d\'ebuter une s\'election, refaire ctrl puis
  C pour copier, ctrl puis X ou del pour couper, ctrl puis V pour coller
%Taper sur DEL pour annuler.
\item enter: si une recherche/remplacement
de mot est active (apr\`es avoir fait doc 6),
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 AC/ON: annule la s\'election ou annule la recherche, sinon
%efface la ligne courante et la copie dans le presse-papier
\item ans (shift (-)) : bascule entre l'\'editeur et la figure tortue
\item esc: quitte l'\'editeur et revient en ligne de commandes. On
peut revenir ensuite \`a l'\'editeur en tapant \`a nouveau esc.
\end{itemize}

\section{Extinction, reset, horloge.}
Comme tout logiciel, $\chi$CAS n'est pas exempt de bugs.
Si un calcul bloque, commencez par essayer de l'interrompre en appuyant sur
la touche ON. Si cela ne suffit pas, il faut se r\'esoudre \`a appuyer
sur le bouton RESET \`a l'arri\`ere de la calculatrice. Pour pouvoir
relancer $\chi$CAS, il faut au pr\'ealable r\'eactiver ndless (depuis
\verb|2. Mes documents| puis dans le r\'epertoire \verb|ndless|).

Pour remettre \`a l'heure l'horloge interne de la calculatrice qui
est affich\'ee dans le shell, connectez votre calculatrice avec
votre ordinateur ou tapez une commande du type \verb|hh,mm=>,|
par exemple \verb|16,05=>,| pour 16h05.

Sur les mod\`eles CX uniquement, le r\'etro-\'eclairage de la calculatrice s'\'eteint
automatiquement au bout de quelques dizaines de secondes si on
ne fait rien, il suffit de taper sur ON pour rallumer. On peut aussi
faire ctrl ON pour forcer l'extinction du
r\'etro-\'eclairage. Attention, il ne s'agit pas d'une vraie
extinction de la calculatrice (il n'y a pas assez d'informations
disponibles sur le mat\'eriel de Texas Instruments pour le faire).
Si vous voulez vraiment \'eteindre la calculatrice, il faut quitter
$\chi$CAS
en tapant autant de fois que n\'ecessaire la touche doc (entre 2 et 4
fois). Pour \'eviter une d\'echarge trop rapide de la batterie, sur
les nspire CX, $\chi$CAS se quitte de lui-m\^eme au bout de 2 heures
d'inactivit\'e (en sauvegardant la session courante sous le nom
habituel \verb|session.xw.tns|). La calculatrice se rallume alors
bri\`evement avant de s'\'eteindre r\'eellement.

En cas d'inactivit\'e prolong\'ee de plusieurs jours, la calculatrice
reboote quand on la rallume, il faut alors reactiver ndless avant
de pouvoir utiliser $\chi$CAS.

\section{Copyright, licences et remerciements}
\begin{itemize}
  \item Giac et $\chi$CAS, noyau de calcul (c) B. Parisse et R. De Graeve, 2019.
    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.ujf-grenoble.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
  Remerciements \`a Fabian Vogt pour firebird-emu, ndless. Remerciements
  \`a toute l'\'equipe de ndless.
  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).
\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 TI France pour le pr\^et d'une
%calculatrice et une licence d'utilisation de l'\'emulateur.
\end{itemize}

\section{D\'eveloppement en C++ avec $\chi$CAS et
  Ndless} \label{sec:dev}
Il faut tout d'abord installer le 
\ahref{https://hackspire.org/index.php/C_and_assembly_development_introduction}{SDK
  de ndless},
sous linux par la commande\\
\verb|git clone --recursive https://github.com/ndless-nspire/Ndless.git|\\
Puis il faut le compiler, ce qui prend une \`a plusieurs heures selon
la puissance de l'ordinateur~:
\begin{verbatim}
cd Ndless/ndless-sdk/toolchain/
./build_toolchain.sh
\end{verbatim}
Ensuite il faut installer le code source de \ahref{https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac_fr.html}{Giac/Xcas}. 
\begin{verbatim}
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac/giac_stable.tgz
tar xvfa giac_stable.tgz
cd giac-1.6.0/micropython-1.12/nspire
\end{verbatim}
ouvrir le fichier \verb|mklib| et ajuster le chemin pour recopier la
librairie \verb|libmicropy.a|, puis
\begin{verbatim}
sh mklib
cd ../../src
cp config.h.nspire config.h
cp Makefile.nspire Makefile
\end{verbatim}
ajustez les chemins dans le fichier \verb|Makefile| puis tapez \verb|make|.

\`A compl\'eter.

\end{giacjshere}
\end{document}
