% 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}
\author{Bernard.Parisse@ujf-grenoble.fr}
\date{2020}

\begin{giacjshere}

\maketitle

\tableofcontents

%\printindex

\section{Introduction}
Ce document explique comment prendre en main et utiliser efficacement
sur calculatrices TI Nspire
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.
$\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~: plus grande varit\'et\'e de
repr\'esentations graphiques (champ de tangentes et solution
d'une \'equation diff\'erentielle, lignes de niveau...),
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}
{\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.

Avant d'installer $\chi$CAS, vous devrez installer \verb|ndless|.
Attention, ceci est actuellement impossible sur les mod\`eles Nspire CX II
et sur les mod\`eles Nspire CX, il ne faut surtout pas installer
la derni\`ere version de l'OS (4.5.1), par contre la version 4.5.0 de
l'OS convient, suivez ce
\ahref{https://tiplanet.org/forum/viewtopic.php?t=20446}{tutoriel}.

Ensuite, ouvrez le logiciel de communication de la TI Nspire et transf\'erez
\verb|khicas.tns| et le r\'epertoire d'exemples \verb|Xcas|.

% 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{Premiers pas}
Si vous n'\^etes pas sur l'\'ecran d'accueil, tapez la touche ON/HOME
puis sur 2 puis la touche Enter, puis s\'electionnez \verb|khicas|
et tapez sur Enter.
Ceci ouvre apr\`es environ 15 secondes un ``shell'' dans lequel vous pouvez
taper la plupart des commandes de calcul formel de Xcas.
Pour revenir au menu principal il faut taper menu plusieurs fois.

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 bleu 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 Ans (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|menu|
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|menu| 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
  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 Ans 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 \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|
(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
(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 \verb|menu 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|
(doc 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|
(doc 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 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|
(doc 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| (doc ,)
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}

\section{G\'eom\'etrie analytique.}
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 doc, constantes physiques (raccourci \verb|doc 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 de validation (\`a droite de la touche u)
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
la touche validation (\`a droite de U)
pour la recopier en ligne de commande et validation \`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) validation.

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 validation (\`a droite de la touche U)
pour recopier vers la ligne
de commande puis validation pour effectuer le calcul, le r\'esultat s'affiche
dans l'\'editeur 2d, validation 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 validation pour
recopier en ligne de commande puis validation 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, menu shift-1 2 enter
(factor), puis
descendez la s\'election sur la somme ou diff\'erence de logarithmes,
allez dans le menu doc 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|menu|,
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)| (\verb|>| se trouve
dans le menu shift-PRGM).


%% \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}
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.

Des programmes sont install\'es dans le r\'epertoire Xcas.
Vous pouvez les visualiser depuis le shell en tapant
\verb|menu| 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 doc, 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 (doc 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|menu|), sinon activez-la (8).
Remplacez \verb|x| par \verb|n|, puis 
d\'eplacez le curseur en fin de ligne et passez \`a la
ligne (enter).
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 
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 validation (la touche \`a droite de U).
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|menu|. 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 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 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|menu| 5 (Effacer).
Puis shift-4 \verb|efface|.
Ajouter 4 fois \verb|avance; tourne_gauche;|.
Appuyer sur validation (\`a droite de la touche U)
pour tester. Sauvegardez (\verb|menu| 3 Sauvegarder comme).

Effacer \`a nouveau (\verb|menu| 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 validation (\`a droite de U).
Ensuite faire \verb|menu| 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.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 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{Applications autres}
Accessibles par le menu \verb|menu| 1 ou le raccourci clavier shift-ANS.
Il y a actuellement le tableau p\'eriodique des \'el\'ements
(d'apr\`es Maxime Friess),
et trois exemples d'addin pour servir de mod\`ele aux
programmeurs~: la suite de Syracuse (tr\`es simple), la
fractale de Mandelbrot et un jeu
de mastermind (qui peut aussi servir de jeu).

\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 o\`u elle ex\'ecute le contenu.
\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 shift-7 (M) matrice, 8 listes, 9 arithm\'etique,
  \verb|(| (P) polynomes, \verb|)| proba et autres,
  \verb|0| complexes, \verb|.| r\'eels,
   %, \verb|)|
\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 menu 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 var: 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{Remarques}
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.

\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}
\`A \'ecrire.

\end{giacjshere}
\end{document}
