\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}{Theorem}
\newtheorem{prop}[thm]{Proposition}
\newtheorem{defn}[thm]{Definition}
\makeindex

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

\begin{document}
\title{$\chi$CAS(io)}
\author{Bernard.Parisse@univ-grenoble-alpes.fr}
\date{2018, 2024}

\begin{giacjshere}

{\bf Ask Casio to keep 3rd party addins for the FXCG50 successor :}
\ahref{https://form.jotform.com/casio_edu/contact}{US contact form},
\ahref{https://edu.casio.com/links/index.php}{worldwide links}\\
Casio is introducing in 2024 a new color calculator in France, 
the Graph Math+, and it's international equivalent (FXCG100) is expected
to be released in 2025 as the successor of the FXCG50.
{\bf The current OS (version 1) does not support addins, therefore
KhiCAS and other addins are not available on the Graph Math+ now, 
and will therefore probably not be available on the FXCG100}.
Casio announced that version 2 of their
OS will be released in 2025, but did not clarify it's position with
respect to 3rd party addins. Maybe the final decision is not taken,
and it's not too late to get addins in version 2. If you like to have
KhiCAS and other addins on your Casio calculator, 
{\bf contact Casio (see links above)
and tell them your opinion. Do it now!} If sufficiently
many people reading this act now, we may win because we are many~: 
this document was read
by more than 13,000 people since January 2024, I expect
it will be read by more than 20,000 this year.\\
B. Parisse, 2024 July 3th.

\maketitle

\tableofcontents

%\printindex

\begin{abstract}
This document explains how to run efficiently $\chi$CAS
on some Casio calculators (CG10, CG20, CG50 and Fx-9750GIII, Fx-9860GIII). 
$\chi$CAS is a port of
the \ahref{https://www-fourier.univ-grenoble-alpes.fr.fr/\home{parisse}/giac.html}{Giac/Xcas} computer algebra system (CAS) for these calculators.

This document is interactive, you can modify and run commands by clicking
in the \framebox{ok} button or by hitting Enter.
\end{abstract}

\section{Introduction and installation} \label{sec:install}
$\chi$CAS is a port of the
\ahref{https://www-fourier.univ-grenoble-alpes.fr.fr/\home{parisse}/giac.html}{Giac/Xcas}
computer algebra system (CAS) for the following Casio calculators~:
CG10, CG20, CG50 and Fx-9750GIII, Fx-9860GIII. Beware:
\begin{itemize}
\item
{\bf CAS are not allowed during exams in some countries,
it is the user responsability to check the rules before running $\chi$CAS
in an exam. The authors shall not be held responsible for misuse
of $\chi$CAS in exam conditions.}
\item
{\bf $\chi$CAS is not compatible with exam mode}. In countries where
CAS calculators are allowed, there is no reason to forbid $\chi$CAS. If
many teachers send a mail to Casio asking for $\chi$CAS compatibility,
we increase the chances that Casio sign the addin and make it
compatible with exam mode.
\end{itemize}

Two versions are available for the CG50, a light version that is
the same as on CG10 and CG20 (in one file), and a more complete version in two
files. The more complete version has more Xcas commands (like geometry
commands), a 3d rendering engine, some additional apps (like a
formal spreadsheet or a financial application) and a port
of MicroPython 1.12 with more modules than the Casio port of
MicroPython 1.09, cf. section \ref{sec:2}.

\subsection{Calculator}
To install or update  $\chi$CAS, get on your computer
\begin{itemize}
\item for the FXCG50
 the files 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/khicas50.ac2}{khicas50.ac2}
and 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/khicas50.g3a}{khicas50.g3a}.
\item for the FXCG10 and 20 (works also on the FXCG50 but is less complete)
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/khicasen.g3a}{khicasen.g3a}
\item for the FX-9750GIII, Fx-9860GIII, the file
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/khicasen.g1a}{khicasen.g1a}
\end{itemize}

Connect the USB cable of the calculator, type F1 for USB key connection
and copy the file(s) \verb|khicas50.g3a| and \verb|khicas50.ac2|
or \verb|khicasen.g3a| or \verb|khicasen.g1a|) 
on the calculator USB-``key''
then disconnect the calculator-key from your computer and wait a few seconds.


{\bf Beware}, some users have reported crashes with addin support on
OS 3.8.
If you have upgraded your calculator, you should downgrade to
\ahref{https://tiplanet.org/forum/archives_list.php?cat=OS+cprizm}{version 3.7}.
Downgrading is normally not allowed, you will have to do the following
(thanks to critor, TI-Planet)~:
\begin{enumerate}
     \item keep pressed the restart button and the keys
    F2,   4 and    AC
\item
 release the restart button while keeping F2 4 AC pressed
  \item
    release keys F2 and 4
\item wait one second
  \item release the AC key
  \item
    press key 9, wait one second, release key 9
\item
    keep key * pressed
  \item
    the calculator should start on an ``OS ERROR'' screen,
    release the * key
    \item run the 3.7 install software
\end{enumerate}



\subsection{Emulator}
If you test on the emulator,
(\ahref{https://tiplanet.org/forum/archives_voir.php?id=1209556}{PC},
\ahref{https://tiplanet.org/forum/archives_voir.php?id=1352720}{Mac}), 
from the main menu of the calculator (MENU), go to Memory
then F3 (Import/Export), then F1 (Import files),
select the file \verb|khicasen.g3a| (or \verb|khicasen.g1a|), 
type F1 to save to
the calculator root directory, confirm with F1 if you upgrade.

Be patient, the transfert will take several minutes.
Once the transfert is finished, you should see the icon
of Xcas in the main menu (a snowflake on the CG10/20/50).

If you want to run the complete version for the CG50, replace the file
above by these 2 files
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/khicas50.882}{khicas50.882}
and
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/emucas50.g3a}{emucas50.g3a}.


Note that $\chi$CAS is not compatible with the simulator distributed
by Casio on USB keys in some countries, you must run the emulator.
Once installed, the Windows version of the emulator can be run under Linux with wine
by the following command\\
\verb|wine "C:\Program Files (x86)\CASIO\fx-CG Manager PLUS Subscription for fx-CG50series\fx-CG_Manager_PLUS_Subscription_for_fx-CG50series.exe" /n"fx-CG Manager PLUS Subscription for fx-CG50series" &|


\section{First steps}
From the main menu (MENU), move the cursor to the Xcas icon
and hit EXE. This opens the ``shell'' (or history) where you can write
most Xcas commands.

If you are running the 2 files version and see the message ``Unable to
load ram part'', upgrade your calculator OS (version 3.30 or greater).

For example, type
\verb|1/2+1/6|
then EXE, you should see the result \verb|2/3| 
displayed below.

Hint~: If you can not find a character on the calculator keyboard, press
shift INS.

You can copy a level from the history of commands by hitting the
up and down arrow keys (once or more) and EXE. Then you can
modify the command and run it with EXE. For example, up arrow twice,
EXE, replace \verb|1/6| by \verb|1/3| and hit EXE.

The last result is stored in \verb|ans()|, hit the \verb|Ans|
calculator key (shift \verb|(-)|) to get it.
It is recommended to store the result in a variable if you want
to reuse a result later. There are two ways to store a value in a
variable
\begin{itemize}
\item right-store with \verb|=>| using the
$\rightarrow$ key, for example \verb|2=>A| stores 2 in variable A.
Now, every time you write \verb|A| in a computation, it
will be replaced by 2.
\item left-store with \verb|:=| (shift $\rightarrow$), 
for example \verb|A:=2| does the same as \verb|2=>A|.
\end{itemize}
%If you begin a commandline by hitting $\rightarrow$,
%the system will automatically insert \verb|Ans=>|, 
%it is therefore easy to store a result in a variable.

The most popular Xcas commands are available from F1 (algebra)
and F2 (calculus), from various shortcuts (cf. section
\ref{sec:shortcuts}), 
or from the cmds (F4) or shift CATALOG, where
they are shortly explained with an example.
Hit F4 (cmds), choose a submenu, 
for example \verb|Algebra|, hit EXE,
move the selection to a command,  for example \verb|factor|.
Now F6 will display a short help with an example. Hit F2
to copy the example in the commandline.
You can run it as is (EXE) or modify it and run it (EXE) if
you want to factor another polynomial.

When a command returns an expression, it is displayed in 2d mode.
You can move with the pad if the expression is larger than the display.
Type shift-F3 or ALPHA-F3 to modify the fontsize. 
Type EXIT to go back to the shell.
The 2d view is in fact a 2d editor that will be explained later.

Now, try to type the command \verb|plot(sin(x))|.
Hint: type F4 (cmd), then select
\verb|Graphs|.

When a command returns a graph, it will be displayed in a 2d frame.
You can modify the displayed area with \verb|+| or \verb|-| 
(zoom in or out, \verb|(-)| does a partial zoomout along $Oy$),
the cursor keys, \verb|/| (orthonormalisation of the frame),
\verb|*| (autoscale), VAR or OPTN is a switch to display or hide axis.
Type F1 (menu) to modify the graphic window settings Xmin, Xmax, Ymin, Ymax.
Type EXIT to go back to the shell.

The KhiCAS File menu (F6) has an item \verb|Clear| that will erase
the display. This will not clear the variables, to achieve that
type \verb|VARS|, select the last item (\verb|restart|)
and confirm with EXE.

Hit MENU to leave $\chi$CAS.
If you launch another application, the variables and history will
be saved, they will be restored if you come back to $\chi$CAS.
First time save is sometimes slow (10 to 20 seconds),
next save will run faster.


\section{Common CAS commands}
\subsection{Expand and factor}
From F4 commands catalog, select \verb|Algebra|, or type F1.
\begin{itemize}
\item \verb|factor|~: factorization. Shortcut \verb|=>*|
($\rightarrow$ key then *),
for example \giacinputmath{x^4-1=>*}.
Run \verb|cfactor| to factor over $\C$.
\item \verb|partfrac|~: expands a polynomial or
performs partial fraction expansion over a fraction.
Shortcut \verb|=>+| ($\rightarrow$ then + key), 
for example \giacinputmath{ (x+1)^4=>+} 
or \giacinputmath{1/(x^4-1)=>+}.
\item \verb|simplify|~: tries to simplify an expression.
Shortcut \verb|=>/| ($\rightarrow$ key then /), 
for example \giacinputmath{sin(3x)/sin(x)=>/}
\item \verb|ratnormal|~: rewrite as an irreducible fraction.
\end{itemize}

\subsection{Calculus}
From F4 commands catalog, select \verb|Calculus|, or type F2
\begin{itemize}
\item \verb|diff|~: derivative. 
Shortcut \verb|'| for derivative with respect to $x$, example
\giacinputmath{diff(sin(x),x)} and \giacinputmath{sin(x)'} are equivalent.
For $n$th-derivative, add $n$,
for example 3rd derivative \giacinputmath{diff(sin(x^2),x,3)}.
\item \verb|integrate|~: antiderivative (1 or 2 or 4 arguments)
for example 
\giacinputmath{integrate(sin(x))} or \giacinputmath{integrate(1/(t^4-1),t)}
for $\int \frac{1}{t^4-1} \ dt $\\
Defined integration with  4 arguments, for
example \giacinputmath{integrate(sin(x)^4,x,0,pi)}
computes $\int_0^\pi \sin(x)^4 \ dx$.
For an approximate computation, enter one boundary as
an approx number, for example
\giacinputmath{integrate(sin(x)^4,x,0.0,pi)}
\item \verb|limit|~: limit of an expression.
Example \giacinputmath{limit((cos(x)-1)/x^2,x=0)}
\item \verb|tabvar|~: table of variations of an expression.
for example \giacinputmath{tabvar(x^3-7x+5)}
one can check with the graph \giacinput{plot(x^3-7x+5,x,-4,4)}
\item \verb|taylor| and \verb|series|~: Taylor expansion
or asymptotic serie expansion, for example
\giacinput{taylor(sin(x),x=0,5)}\\
Add \verb|polynomial| if you do not want to have the remainder term.
\item \verb|sum|~: discrete summation, for example
\giacinputmath{sum(k^2,k,1,n)} computes $\sum_{k=1}^n k^2$,
\giacinputmath{sum(k^2,k,1,n)=>*} computes the sum and 
rewrites it factored.
\end{itemize}

\subsection{Solvers}
From F4 commands catalog, select \verb|Solve|.
\begin{itemize}
\item \verb|solve| solves an equation exactly. Takes the variable
to solve for as second argument, unless it is \verb|x|, for
example \giacinputmath{solve(t^2-1=0,t)}.\\
If exact solving fails, run \verb|fsolve|
for approx solving, either with an iterative method
starting with a guess \giacinputmath{fsolve(cos(x)=x,x=0.0)},
or by dichotomy \giacinputmath{fsolve(cos(x)=x,x=0..1)}.\\
For complex solutions, run \verb|csolve|.\\
It is possible to restrict solutions using assumptions on the variable,
for example \giacinputmath{assume(m>1)} then \giacinputmath{solve(m^2-4=0,m)}.
\item \verb|solve| can also solve (simple) polynomial systems,
enter a list of equations as 1st argument and a list of variables
as 2nd argument, for example intersection of a circle and a line:
\giacinputmath{solve([x^2+y^2+2y=3,x+y=1],[x,y])}
\item Run \verb|linsolve| to solve linear systems.
enter a list of equations as 1st argument and a list of variables
as 2nd argument, example:
\giacinputmath{linsolve([x+2y=3,x-y=7],[x,y])}
\item Run \verb|desolve| to solve exactly a differential equation.
for example, to solve $y'=2y$, type \verb|desolve(y'=2y)|.\\
Another example with an initial condition:\\
\verb|desolve([y'=2y,y(0)=1],x,y)|\\
Run \verb|odesolve| for approx solving or \verb|plotode| 
for a graphic representation of the approx. solution. 
\item \verb|rsolve| solves some recurrence relations
 $u_{n+1}=f(u_n,...)$,
for example to solve the arithmetico-geometric recurrence
 $u_{n+1}=2u_n+3, u_0=1$, type:
\giacinputmath{rsolve(u(n+1)=2*u(n)+3,u(n),u(0)=1)}
\end{itemize}

\subsection{Arithmetic}
When required, the distinction between integer arithmetic 
and polynomial arithmetic is done by a prefix \verb|i| for
integer commands. For example \verb|ifactor| for integer factorization
and  \verb|factor| for polynomial factorization
(or \verb|cfactor| for polynomial factorization over $\C$).
Some commands work for integers and polynomials, like
\verb|gcd| and \verb|lcm|.

\subsubsection{Integers}
From F4 catalog, select \verb|Arithmetic, Crypto|. Shortcut 
shift S$\leftrightarrow$D
\begin{itemize}
\item \verb|iquo(a,b)|, 
\verb|irem(a,b)| quotient and remainder of euclidean division
of two integers.\\
\giacinputmath{iquo(23,13),irem(23,13)}
\item \verb|isprime(n)| checks whether $n$ is prime.
This is a probabilisitic test for large values of $n$.
\giacinputmath{isprime(2^64+1)}
\item \verb|ifactor(n)| factorizes an integer
(not too large, since algorithms used are trial division and
Pollard-$\rho$, there is no space left in memory for quadratic sieve),
for example
\giacinputmath{ifactor(2^64+1)}\\
Shortcut $\rightarrow$ then * (\verb|=>*|)
\item \verb|gcd(a,b)|, \verb|lcm(a,b)| GCD and LCM
of two integers or polynomials.\\
\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)| returns 3 integers  $u,v,d$ such that
$au+bv=d$ where $d$ is the GCD of $a$ et $b$, $|u|<|b|$ and
$|v|<|a|$.\\
\giacinputmath{u,v,d:=iegcd(23,13); 23u+13v}
\item \verb|ichinrem([a,m],[b,n])| returns (if possible)
$c$ such that $c=a \pmod m$ and $c=b \pmod n$ (if $m$ are $n$
coprime, $c$ exists).
\giacinputmath{c,n:=ichinrem([1,23],[2,13]); irem(c,23); irem(c,13)}
\item \verb|powmod(a,n,m)| returns $a^n \pmod m$ 
computed by the fast modular powering algorithm\\
\giacinputmath{powmod(7,22,23)}
\item \verb|asc|  converts a string to a list of
ASCII code, \verb|char| converts back a list to a string.
These commands may be used to easily write cryptographic algorithms
with string messages.
\end{itemize}

\subsubsection{Polynomials}
From F4 catalog, select \verb|Polynomials|.
The default variable is $x$, otherwise you can specify it as last 
optional argument. For example \verb|degree(x^2*y)|
or \verb|degree(x^2*y,x)| return 2, 
\verb|degree(x^2*y,y)| returns 1.
\begin{itemize}
\item \verb|coeff(P,n)| coefficient of $x^n$ in $P$, \verb|lcoeff(P)|
leading coefficient of $P$, for example
\giacinputmath{P:=x^3+3x; coeff(P,1); lcoeff(P)}
\item \verb|degre(P)| degree of polynomial $P$
\giacinput{degree(x^3)}
\item \verb|quo(P,Q)|, \verb|rem(P,Q)| quotient and remainder
of euclidean division of \verb|P| by \verb|Q|
\giacinputmath{P:=x^3+7x-5; Q:=x^2+x; quo(P,Q); rem(P,Q)}
\item \verb|proot(P)|~: approx. roots of $P$
(all roots, real and complex)\\
\giacinput{proot(x^5+x+1)}
Graphic representation\\
\giacinput{point(proot(x^5+x+1))}
\item \verb|interp(X,Y)|~: for two lists of the same size,
returns the interpolating polynomial $P$ such that $P(X_i)=Y_i$. \\
\giacinputmath{X,Y:=[0,1,2,3],[1,-3,-2,0]; P:=interp(X,Y)=>+}
Graphic representation\\
\giacinput{scatterplot(X,Y); plot(P,x,-1,4)}
\item \verb|resultant(P,Q)|~: resultant of polynomials
$P$ and $Q$
\giacinput{P:=x^3+7x-5; Q:=x^2+x; resultant(P,Q)}
\item \verb|hermite(x,n)|~: $n$-th Hermite polynomial 
(orthogonal for the density $e^{-x^2}dx$ on $\R$)
\item \verb|laguerre(x,n,a)|~: $n$-th Laguerre polynomial 
\item \verb|legendre(x,n)|~: $n$-th Legendre polynomial 
(orthogonal for the density $dx$ on $[-1,1]$)
\item \verb|tchebyshev1(n)| and \verb|tchebyshev2(n)|
Tchebyshev polynomials of 1st and 2nd kind
defined by~:
$$T_n(\cos(x))=\cos(nx), \quad U_n(\cos(x))\sin(x)=\sin((n+1)x)$$
%\item \verb|bernoulli(n,x)| polynomial de Bernoulli
\end{itemize}

\subsection{Linear algebra, vectors, matrices}
Xcas does not make distinction between vectors and lists. For
example,
\begin{giaconload}v:=[1,2]; w:=[3,4]\end{giaconload}
defines 2 vectors $v$ and $w$, then \verb|dot| will compute
the scalar product of $v$ and $w$:
\giacinput{dot(v,w)}

A matrix is a list of lists of the same size.
You can enter a matrix element by element using the
matrix editor (shift-MATR EXE or F6 0). Enter a new variable
name to create a new matrix 
or the name of an existing variable to edit a matrix.
The \verb|,| key may be used to insert a line or column, and
the \verb|DEL| key erases the line or column of the selection
(press \verb|UNDO| if you want to go one step back).
For small matrices, it is also convenient to enter them directly in the
commandline, for example to define
$$ A=\left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \end{array}\right)$$
type \begin{giaconload}A:=[[1,2],[3,4]]\end{giaconload} 
or \giacinputmath{[[1,2],[3,4]]=>A}
It is recommended to store matrices in variables!

If a matrix is defined by a formula, then it's better to use the
\verb|matrix| command (shift-MATR EXE AC), for example:
\giacinputmath{matrix(2,2,(j,k)->1/(j+k+1))} 
returns the matrix where coefficient line $j$ and column $k$
is $\frac{1}{j+k+1}$ (beware, indices begin at 0).

Run \verb|idn(n)| to get the identity matrix of order $n$
and  \verb|ranm(n,m,law,[parameter])| to
get a matrix with random coefficients with dimensions $n,m$.
for example 
\giacinputmath{U:=ranm(4,4,uniformd,0,1)}
\giacinputmath{N:=ranm(4,4,normald,0,1)}

For basic arithmetic on matrices, use keyboard operators
(\verb|+ - *|, inverse). Otherwise, open catalog and
select \verb|Matrices|
\begin{itemize}
\item \giacinputmath{eigenvals(A)}
\giacinputmath{eigenvects(A)} 
eigenvalues and eigenvectors of matrix $A$.
\item \giacinputmath{P,D:=jordan(A)} 
finds the Jordan normal form of matrix $A$, returns
matrices $P$ and $D$ such that
$P^{-1}AP=D$, with $D$ upper triangular (diagonal if $A$ is
diagonalizable)
\item \giacinputmath{Ak:=matpow(A,k)} computes
matrix $A$ to the $k$-th power, where $k$ is symbolic.
\item \verb|rref|: row reduction to echelon form
\item \verb|lu|: $LU$ factorization of matrix $A$,
returns a permutation $P$ and two matrices $L$ (lower)
and $U$ (upper) such that
$PA=LU$. The result of
\giacinput{P,L,U:=lu(A)} 
may be passed as an argument to the command \giacinput{linsolve(P,L,U,v)}
to solve a system $Ax=b$ by solving two triangular systems
(in $O(n^2)$ instead of $O(n^3)$).
\item \verb|qr| $QR$ factorization of matrix $A$,
$Q$ is orthogonal and $R$ upper triangular, $A=QR$.
\item \verb|svd(A)| singular value decomposition of matrix $A$
returns $U$ orthogonal, $S$ vector of singular values, $Q$
orthogonal such that \verb|A=U*diag(S)*tran(Q)|. \\
The ratio of the largest and the smallest singular value of $S$
is the condition number of $A$ relative to the Euclidean norm.
\end{itemize}


\section{Probabilities and statistics}

\subsection{Random numbers}
From F4 catalog, select \verb|Probabilities|
then \giacinput{rand()} (real in $[0,1)$) or 
\giacinput{n:=6:; randint(n)} 
(integer between 1 and $n$). 
Other commands with prefix \verb|rand| are available, followed
by the name of the law, for example \verb|randbinomial(n,p)| 
returns a random integer according to binomial law of parameters $n,p$.
For a random vector or matrix, run
\verb|ranv| or \verb|ranm| (from \verb|Alglin, Matrice| submenu), 
for example for a vector with 10 random
reals according to normal law (mean 0, stddev 1), type\\
\giacinputmath{ranv(10,normald,0,1)}

\subsection{Probabilities}
From F4 catalog, select \verb|Probabilities| (8).
There you will find a few distribution laws: 
\verb|binomial|, \verb|normald|, \verb|exponentiald|
and \verb|uniformd|. Other distribution must be keyed in:
\verb|chisquared|, \verb|geometric|, \verb|multinomial|,
\verb|studentd|, \verb|fisherd|, \verb|poisson|.

To get the cumulated distribution function, enter the law name then
the \verb|_cdf| suffix (shortcut: select 
\verb|cdf| in the catalog at the end and press F1).
Inverse cumulated distribution function follows the same principle
with \verb|_icdf| suffix (shortcut:
select \verb|cdf| in the catalog and press F2).

Example~: find the centered interval $I$ for the normal law of
mean 5000, standard deviation 200, such that the probability
to be outside $I$ is 5\%
\giacinput{M:=5000; S:=200; normald_icdf(M,S,0.025);normald_icdf(M,S,0.975)}

\subsection{1-d statistics}
The statistic functions are taking lists as arguments,
for example \begin{giaconload}l:=[9,11,6,13,17,10]\end{giaconload}
From F4 catalog, select \verb|Statistics|:
\begin{itemize}
\item \giacinput{mean(l)}~: arithmetic mean of a list
\item \giacinput{stddev(l)}~: standard deviation of a list.\\
Run
\giacinput{stddevp(l)} to get an unbiaised estimate of the standard
deviation of a population from a sample \verb|l|
\item \giacinput{median(l)}, \giacinput{quartile1(l)}, 
\giacinput{quartile3(l)}
returns respectivly the median, first and third quartile
of a list.
\end{itemize}
For 1-d statistics with frequencies, replace \verb|l|
by two lists of the same length, the first list being the
values of the serie, the second list the frequencies.
For graphic representations, open catalog, \verb|Graphic| 
and select \verb|histogram| or \verb|barplot|.

\subsection{2-d statistics}
From F4 catalog, select \verb|Statistics|:
\begin{itemize}
\item \verb|correlation(X,Y)|: correlation of two 
lists $X$ and $Y$ of the same length.
\item \verb|covariance(X,Y)|:: covariance of two 
lists $X$ and $Y$ of the same length.
\item regression computations:
run commands with suffix \verb|_regression(X,Y)|,
for example \verb|linear_regression(X,Y)| returns
coefficients $m,p$ of the linear regression line
$y=mx+p$.
\item \verb|linear_regression_plot(X,Y)| 
and all commands
of suffix \verb|_regression_plot|
will display the line (or curve) of the regression.
These commands will also print the $R^2$ coefficient
that give information on the quality of adjustment
($R^2$ near 1 is good).
\end{itemize}

\section{Graphics}
From F4 catalog, select \verb|Graphics| (or type the plot shortcut F3)
and choose a graphic command. If you want to have more than one curve
on the same graphic, enter several commands with \verb|;| as separator.
\begin{itemize}
\item \verb|plot(f(x),x=a..b)| plot expression $f(x)$ for $x\in [a,b]$.
Discretization option: \verb|xstep=|,
for example \giacinput{plot(x^2,x=-4..4,xstep=1)}
Default is 384 evaluations per plot (one per horizontal pixel).
\item \verb|plotseq(f(x),x=[u0,a,b])| webplot for a recurrent
sequence $u_{n+1}=f(u_n)$ of first term $u_0$,
for example if $u_{n+1}=\sqrt{2+u_n}, u_0=6$, with a plot
on $[0,7]$
\giacinput{plotseq(sqrt(2+x),x=[6,0,7])}
\item \verb|plotparam([x(t),y(t)],t=tm..tM)| parametric plot
$(x(t),y(t))$ for $t\in [t_m,t_M]$. Discretization option: \verb|tstep=|.
Example
\giacinput{plotparam([sin(2t),cos(3t)],t,0,2*pi)}
\item \verb|plotpolar(r(theta),theta=a..b)| polar plot
of $r(\theta)$ for $\theta \in [a,b]$,
for example
\giacinput{plotpolar(sin(3*theta),theta,0,2*pi)}
\item \verb|plotlist(l)|: plot a list \verb|l|,
i.e. draws a polygonal line 
with vertices $(i,l_i)$ (index $i$ starts at 0).\\
\verb|plotlist([X1,Y1],[X2,Y2],...)| 
polygonal line with vertices the points of coordinates $(X_i,Y_i)$ 
\item \verb|scatterplot(X,Y)|, \verb|polygonscatterplot(X,Y)|
for two lists \verb|X,Y| of the same size,
draws the points or a polygonal line of vertices $(X_i,Y_i)$ 
\item \verb|histogram(l,class_min,class_size)|
plots the histogram of data in \verb|l|, class size
\verb|class_size|, first class starts at
\verb|class_min|. Example: check the random generator quality\\
\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,...])|
plot implicit curves $f(x,y)=l_0, f(x,y)=l_1,...$.
\item \verb|plotfield(f(t,y),[t=tmin..tmax,y=ymin..ymax])|
plot the field of tangents for the differential equation
$y'=f(t,y)$. Add the optional last parameter \verb|,plotode=[t0,y0]|
to plot simultaneously the solution with initial condition
 $y(t_0)=y_0$. Example $y'=\sin(ty)$ for $t \in [-3,3]$
and $y \in [-2,2]$\\
\giacinput{plotfield(sin(t*y),[t=-3..3,y=-3..3],plotode=[0,1])}
N.B.: \verb|plotode| may be used outside of \verb|plotfield|.
\item For simultaneous plots, write commands separated by \verb|;|
\end{itemize}
If a command returns an arc of curve, the trace mode is active by
default on the addin in 2 parts for the FXCG50 or on the addin
for the monochrom model. In this mode, typing the left or right key will move a
pointer on the active arc of curve, and display the pointer
coordinates (and the parameter value for parametric curves), and
a tangent vector (speed). If there are several curves, press up or
down to change active curve. Type F2 to get info on the active curve,
then EXE to see a table of value.

From F1 menu, if you select the curve study item (shortcut
$x,\theta,t$ key), you can add a normal vector pointing to the
center of curvature (F4), and/or the osculating circle and radius
of curvature. From the curve study menu, you can also move
the pointer to a location, or to a remarkable point: root, horizontal
or vertical tangent, inflexion point, intersection with another curve
arc (limited to intersection of function graphs on monochrom Casio). 
You can also compute an arc length or
the area under the curve between pointer and mark.

When a curve is active, the variables \verb|X0,X1,X2,Y0,Y1,Y2|
are set with the expressions of position, speed and acceleration. When
you search a root, horizontal tangent, inflexion, arc length or area
under curve, variables are set with the last value.

For display options, press the OPTN key:
\begin{itemize}
\item \verb|display=color| color option: 
select a color then press F2, for example
\giacinput{plot(sin(x),display=red)}
\item \verb|display=line_width_2| to \verb|display=line_width_8|:
change segments width (including inside polygonal line used to
plot a curve).
Simultaneous display options should be added with \verb|+|.
For example \verb|display=red+line_width_2|
\item Circles and rectangles with edges parallel to the coordinate
axis may be filled with 
\verb|display=filled| (this attribute might be added to other attributes)
\item If you want to define the display window (overwriting
the autoscale computation), select \verb|gl_x| or/and \verb|gl_y| 
and add an $x$ or $y$ interval, for example 
\giacinput{gl_x=-2..2;gl_y=-1..4;plot(exp(x))}
Note that \verb|gl_| commands must preced the plotting command.
\item
If you want to remove axes, select  \verb|axes| and press F2
(\verb|axes=0|). Like \verb|gl_| commands, \verb|axes=0|
must preced the plotting command. Axes can be removed interactively
when the graph screen is displayed by pressing SIN.
\end{itemize}

\section{Programs}
You can program either with Xcas-like syntax (English or French) 
or with Python-like syntax.

Example~: function defined by an algebraic expression
\verb|nom_fonction(parametres):=expression|
for example simple confidence interval for a frequency $p$ in a sample
of size $N$\\
\giacinput{F(P,N):=[P-1/sqrt(N),P+1/sqrt(N)]}\\
Test \giacinput{F(0.4,30)}

Second example~: more precise confidence interval for a frequency $p$
in a sample of size $N$:\\
\giacinput{f(P,N):=[P-1.96*sqrt(P*(1-P)/N),P+1.96*sqrt(P*(1-P)/N)]}
To avoid computing twice the same quantity, one can insert
a local variable. 
The commandline is not well adapted to write these kinds
of functions. For non algebraic functions, it is best to run the 
program editor. Press F6, select Script Editor, clear the editor if it
is not empty (F6 Clear) and 
type with the help of test (F1), loop (F2)
for programming structures
the following program, in Xcas syntax:
\giacinput{function f(P,N) 
  local D; 
  D:=1.96*sqrt(P*(1-P)/N); 
  return [P-D,P+D]; 
ffunction;}\\
or in Python syntax:
\giacinput{
def f(P,N):
  D=1.96*sqrt(P*(1-P)/N)
  return [P-D,P+D]
}
Type EXE to check the syntax. Once
the program is correct, save it (F6 2), then type EXIT. Now you
can call your program from the commandline like this\\
\verb|f(0.5,30)|

Third example~: a loop printing integer squares
from 1 to $n$ in Python syntax.
Check that Python syntax is enabled in the F6 or shift-SETUP menu, 
if it is not checked, check it.
Open F6 Script Editor, if there is some old script source,
clear it (F6 Clear).
Select \verb|f(x):=| from F2 (or from F4, Program, function def), 
you should get \verb|def f(x):|.
Replace \verb|x| by \verb|n| 
(press F5 to lock the keyboard in alpha lowercase), move to the end of
the line and press shift-EXE to input a newline.
Type Shift-PRGM then \verb|3 for|, then F5 J space alpha, then
Shift-PRGM then \verb|6 in range(a,b)|. Type \verb|1,n+1)| 
then F1 (\verb|:|). Type shift-EXE to insert a newline
then Alpha SPACE,
F4 (Cmds), EXE (\verb|1 All|), P, R select \verb|print| with the cursor 
then type EXE, type \verb|j,j^2)| then EXE.
\begin{giacprog}
def f(n):
  for j in range(1,n+1):
    print(j,j^2)
\end{giacprog}
Inside Xcas \verb|^| means power, \verb|**| is also accepted like in
Python.

Now, type EXE (or F6, select \verb|1. Check syntax|). If syntax is correct,
you will see \verb|Success| in the status line. Otherwise, the
first error line number and token will be displayed and cursor will
be positionned at the line where the error was detected. Note that
the error may be before this line but it was only detected later. Note
also that if you are using Python syntax compatibility, programming
structures are translated into Xcas, errors are displayed after
translation, therefore you might see token errors like \verb|end|
that were added by the translator.

If the program is correct, you can save it with the F6 menu (save or save as).
You can run it from the commandline by pressing EXIT then for
example \verb|f(10)| should display all squares from 1 to 10.

The turtle is a nice way to learn programming. The turtle is a small
robot that you can move, it handles a pen that marks its path.
Type F6, Script Editor, then F6 Clear. Type shift-QUIT select
\verb|efface| which means clear the screen. You can
access to the turtle commands using shift-QUIT (move the cursor to
a command and press F6 for help). For example try \verb|avance|
(forward). Checking the syntax (EXE) 
will display the turtle window moves.
You can enter several moves in your script, and organize them 
inside tests, loops and functions.
For example:
\begin{verbatim}
function square(n)
  repete(4,avance n,tourne_gauche);
ffunction:;
  
efface;
for n from 1 to 10 do
  square(10*n);
od;
\end{verbatim}

Another example of non algebraic function: the euclidean algorithm
to compute the GCD of two integers. 
Press shift-EXE to insert a newline. \verb|!| is in the
submenu \verb|Programmation_cmds| (11, shortcut $X,\theta,T$)
or in the test F1 menu.
Xcas syntax
\begin{giacprog}
function pgcd(a,b)
  while b!=0 do
    a,b:=b,irem(a,b);
  od;
  return a;
ffunction
\end{giacprog}
Python syntax
\begin{giacprog}
def pgcd(a,b):
  while b!=0:
    a,b=b,a % b
  return a
\end{giacprog}
Check with \giacinput{pgcd(12345,3425)}

If your program has runtime errors or if you want
to see it run step by step, run \verb|debug| on it,
for example\\
\verb|debug(pgcd(12345,3425))|

Unlike adaptations of Micro-Python by calculator manufacturers (including
Casio), the Python syntax in Xcas is fully integrated.
You can therefore use all Xcas commands and data types in your programs.
This corresponds approximatively to importing Python modules
\verb|math|, \verb|cmath|, \verb|random|,
\verb|scipy|, \verb|numpy|, \verb|turtle|, \verb|giacpy|.
There is also a small
pixelised graphic commands set
(\verb|set_pixel(x,y,c)|, \verb|set_pixel()| to synchronize
display, \verb|clearscreen()|, \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)|,
the color+width+filled \verb|c| parameter is optional,
\verb|draw_arc(x,y,rx,ry,t1,t2,c)| draws an ellipsis arc).
And you can somewhat replace \verb|matplotlib| 
with graphic commands of  $\chi$CAS
(\verb|point|, \verb|line|, \verb|segment|, \verb|circle|,
\verb|barplot|, \verb|histogram| and all \verb|...plot...|
commands). Plus you have natural access to data types
like rationnals or expressions, and you can run CAS commands on them.
The complete list of commands available on the calculator
is given in appendix. For documentation on commands not listed
in the catalog categories, please refer to Xcas documentation.

\section{The 2d editor.}
If a computation returns an expression, it will be displayed in the 2d 
expression editor. This also happens if you press F3 when the selected
level is an expression, or if you press F3 from the commandline if the line
is empty or contains a syntaxically correct expression.

Once the 2d editor is open, the expression is displayed in full screen and
all or part of the expression is selected. One can run a command
on the selection (from the menus or from the keyboard), or edit 
(in 1d mode) the selection. This is an efficient way to rewrite
expressions or edit them.

Example 1~: enter
$$ \lim_{x \rightarrow 0} \frac{\sin(x)}{x}$$
From an empty commandline, type F3 (view), you should see 0 selected.
Type x then EXE, this will replace 0 by x selected. Type SIN, now
$\sin(x)$ should be selected. Type the division key (above -), you
should see $\frac{\sin(x)}{0}$ with 0 selected, type x then EXE,
you should now see $\frac{\sin(x)}{x}$ with x (below the fraction)
selected. Type the up arrow key, now $\frac{\sin(x)}{x}$
should be selected. Now type F2 4 (for limit). The expression
is ready to eval, type EXE to copy it to the commandline and EXE
again to eval it. For the same limit at $+\infty$, before leaving
the 2d editor with EXE,
move the selection with the right arrow key, then type F1 8 (oo) EXE.

Example 2~: 
$$ \int_0^{+\infty} \frac{1}{x^4+1} \ dx $$
From an empty commandline, type F3 (view), then F2 3 (integrate),
you should see:
$$ \int_0^1 0 \ dx$$
with $x$ selected. We must modify the 1 (upper bound) and
the 0 (integrand). Press left arrow key, this will select the
integrand 0, type \verb|1/(x^4+1)| EXE, then left arrow key F1 8 EXE.
Type again EXE to copy to commandline, EXE again to run the computation,
the result will be displayed in the 2d editor, EXE will leave the 2d
editor, with the integral and its value in the history.

Example 3~: compute and simplify
$$ \int \frac{1}{x^4+1} \ dx $$
From an empty commandline, type F3 (view), then F2 3 (integrate),
you should see
$$ \int_0^1 0 \ dx$$
Move the selection to the lower bound 0 (right arrow key), 
type DEL, you should see
$$ \int 0 \ dx$$
selected. With the down arrow key, select 0, type \verb|1/(x^4+1)| EXE,
EXE copy to the commandline, EXE to run the compuation, the result
is now displayed in the 2d editor.\\
With the arrow key, select one of the arctangent, type F1 EXE (simplify),
this will make a partial simplification, do the same on the second
arctangent.\\
For a more complete simplification, we will collect the logarithms.
The first step is to exchange two terms of the main sum so that the
logarithms are grouped. Select one of the logarithm with the arrow keys,
then type
\begin{itemize}
\item CG10,20,50 : shift-left or right arrow key
\item fx-9860GIII: F5 left or right arrow key, then ALPHA
\end{itemize}
this will exchange the selection with the right or left sibling.
Now type ALPHA right or left arrow key to extend the selection adding
the right or left sibling. Once the two logarithm terms are selected,
press F1 2 EXE (factor), decrease the selection to the numerator,
type F4 EXE (All), type the letters l, n, c, this moves in the
catalog to the first command beginning with \verb|lnc|, select
\verb|lncollect|, EXE and F6 (eval).

\section{Managing sessions}
\subsection{Modifying a session}
With the up/down cursor keys, you can move in the history, the current
level is printed with reverse colors.

You can move one level in another position with ALPHA-up and ALPHA-down.
You can delete a level with the DEL key (the level is copied into 
the clipboad).

You can modify an existing level with F3 or ALPHA-F3. With F3, the 2d
editor is called if the level is an expression, with ALPHA-F3 the level
is edited in the text (program) editor. Type EXIT if you want to cancel
modifications, or EXE if you confirm the modifications. If you confirm
the modifications, the commandlines below the current level will 
automatically be re-evaled. This way, if you modify for example
a level like \verb|A:=1|, all levels below that depend on the value
of \verb|A| will be up to date. If you want to do that several times,
it is best to introduce a parameter with the F6 Parameter wizzard. Then
pressing + or - on the \verb|assume(...)| or \verb|parameter| level
will modify the value of the parameter (press * or / for faster move).

\subsection{Variables}
Press VARS to see which variables are assigned to a value. Select a variable
name, press EXE to copy it to the commandline, DEL will input the command
that erases the variable (confirm with EXE). \verb|restart| will
purge all variables at once (press \verb|AC/ON| to clear the history
and start a fresh new session). \verb|assume| is a command to 
make assumptions on a variable, like \verb|assume(x>5)| (\verb|>| 
can be accessed from the shift-PRGM menu).

\subsection{Archiving and exchanging with Xcas}
On the calculator, go back to the history (type EXIT if you are in the
programming editor or the 2d expression editor). 
From the F6 menu, you can save/restore sessions in the
calculator flash memory. Files have the \verb|xw| extensions. They
can be copied to your computer (connect the calc, choose F1 USB key),
and there they may be opened with Xcas or Xcas for Firefox.
From Xcas, choose the File menu then Open file, then select 
all type of files and open the session file.
From 
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/xcasfr.html}{Xcas for Firefox}, press the Load button.

Conversely you can save a session from Xcas (choose File, Export to Khicas)
or from Xcas for Firefox (choose Export at the right of the session name).

\section{Keyboard shortcuts.} \label{sec:shortcuts}

\subsection{KhiCAS 50 and 90 versions (2 files)}
These shortcuts are valid inside the shell and text programming
editor. With default configuration:
\begin{itemize}
\item shift INS: table of ASCII characters
\item F1-F6, shift-F1 to shift-F6, alpha-F1 to alpha-F6: see legend at screen bottom
\item OPTN: fast menu for color options
\item shift-OPTN: programming commands
\item VARS: variables list
\item shift-PRGM: fast menu for programming
\item MENU: back to main Casio menu 
\item shift-SETUP: setup
\item EXIT: switch from shell to editor
\item shift-EXIT: display logo turtle screen
\item ALPHA-EXIT: if alpha is not locked, displays last 2d or 3d graph
\item shift angle: fast menu for geometry
\item fraction: \verb| % | inside shell, indentation in editor, force
  sheet reeval in spreadsheet
\item shift-fraction: fast menu for poynomial arithmetic in shell,
  completion in editor
\item touche S$\leftrightarrow$D: additional apps
  (spreadsheet, finance, ...). Inside spreadsheet, display sheet graphs.
\item shift \verb|,|: \verb|;|
\item shift $\rightarrow$: \verb|:=| or \verb|:| depends on active interpreter
  Xcas or Python
\item AC/ON: cancel selection or cancel search/replace
\item shift CAPTURE: save session or file
\item shift CLIP: begin selection or copy selection to clipboard
\item shift PASTE: paste clipboard
\item shift CATALOG: list of all Xcas commands
\item shift FORMAT: programming commands
\item shift 6: fast menu with \verb|<>_!| and \verb|comb, rand, binomial,
  normald|
\item shift List: fast list menu 
\item shift Mat: fast matrix menu
\item shift 3: menu rapide alg\`ebre lin\'eaire
\item shift EXE: next line in editor
\end{itemize}
You can modify fast menus shortcuts by editing the file
\verb|FMENU.py|. Delete the file from Memory Casio application
to reset to default configuration.

\subsection{KhiCAS short version (1 file))}
\begin{itemize}
\item F1 to F3~: depends on mode (Python/Xcas) and shift/alpha state,
see labels 
\item F4: commands catalog.
\item F5: uppercase to lowercase switch.
If alpha mode is not active, locks the keyboard in alpha lowercase.
\item F6: File menu
\item cursor down from shell or shift fraction key from program editor
(G key): completion/online help
\item \verb|(-)| in the text editor: returns the \verb|_| character. 
\item shift PRGM: programming commands or characters
\item OPTN: all options
\item shift-QUIT: turtle commands
\item shift-List: create or edit a list, list commands
\item shift-Mat: create or edit a matrix, matrix commands
\item S$\leftrightarrow$D key: real number commands
\item yellow shifted S$\leftrightarrow$D key: integer commands
\item angle key: complex commands
\item yellow shifted fraction: plot commands
\item fraction key: special characters/proba in history, indentation in
text editor
\item red r key: \verb|abs|
\item red $\theta$ key: \verb|arg|
\end{itemize}

In programming editor
\begin{itemize}
\item shift-cursor key: move to begin/end of line or file
\item shift CLIP: begin selection. 
Move the cursor to the selection end, type DEL to remove the selection
(it will be copied to clipboard) or again shift-CLIP to copy selection
to clipboard without removal.
Type AC/ON to cancel selection.
\item EXE: if a search/replace is currently active (F6 6)
find next word occurence. Otherwise parse/execute.
\item shift EXE: add a newline.
\item DEL: remove selection or previous character if no selection active
\item shift PASTE: copy clipboard
\item Shift-INS (touche DEL): 
remove current line and copy to clipboard
\item AC/ON: cancel selection or cancel search/replace
or check syntax (like F6 1)
\item EXIT: leave text editor to the commandline.
Type EXIT again to come back to the text editor.
\end{itemize}

\section{Remarks}
On color models, you must first press MENU before shutting down 
the calculator with shift ON. When you press ON again, press MENU to
go back in KhiCAS.

If you connect a color model to your PC as a USB disk, 
you will have to press a key after you have pressed F1, otherwise
nothing happens.

If KhiCAS is inside a long computation, you should be able to interrupt
it by pressing AC/ON. If it does not interrupt, you may have to press
the reset button.

If KhiCAS crashes, you will see a message SYSTEM ERROR etc.. Try to
press the MENU key and open any other application. If you are lucky,
this will save your session and you can go back and reopen KhiCAS
without having to reinitialize the calculator.

The memory available for computations is about 500K with the color g3a addin
on the CG50, and 58K on the monochrom g1a addin. On the CG50, it is
recommended to check periodically the remaining free memory by
pressing the VAR key. If it is less than 100K, press MENU, open
any other app, press MENU again and reopen KhiCAS with your session
and a fresh unfragmented memory.

\section{More complete version for the CG50} \label{sec:2}
The light version in one file is not a full version of Xcas because the maximal size
for a Casio add-in is too small (2 Mo). A more complete version of
$\chi$CAS for the FXCG50 is distributed in 2 files (one of them is run from a section
of the RAM of the FXCG50 that is currently not used by Casio).

This more complete version has more Xcas commands (like geometry
commands), a 3d rendering engine, some additional apps (like a
formal spreadsheet or a financial application) and a port
of MicroPython 1.12 with more modules than the Casio port of
MicroPython 1.09.

See section \ref{sec:install} to install.

\subsection{MicroPython 1.12}
You can select the shell interpreter by typing shift SETUP. The menu
background color of the shell reflects the active interpreter
(yellow=MicroPython, magenta or cyan for Xcas native or Xcas Python
compatible).

Available modules: turtle (more complete version, with filled objects),
graphic (more complete than casioplot), matplotl, arit (integer
arithmetic), linalg/numpy (linear algebra, matrices), ulab (scipy
compatibility), cas (CAS from Python).

\subsection{3d and 4d graphs}

One can plot
2 variables function or parametric plots, cones, solids, planes, ...
For example type \verb|F4 * 5 F2 EXE| to draw a cube or \verb|shift F4
1| to select the plot command, and enter \verb|x^2-y^2|.

For fonctions plots from $\mathbb{C}$  to
$\mathbb{C}$, run the \verb|plot| command with argument
a complex valued expression of 2 variables (real and imaginary parts)
like for example \verb|plot((x+i*y)^2-9)|. For
expression depending directly on the complex variable
(without requiring real/imaginary part), one can use the
\verb|plot3d| command, for example
\verb|plot3d(x^2-9)| (the \verb|plot(x^2-9)| command would not
work, because it is already used for a graph from $\mathbb{R}$ to
$\mathbb{R}$). The modulus is represented along the $Oz$ axis and
the argument using raimbow colors: from  $-\pi$
in blue magenta to 0 in green (through yellow orange)  and from
0 to $\pi$ via cyan.

If you need precise options, run the  \verb|plotfunc| command, for example\\
\verb|plotfunc((x+i*y)^3-1,[x=-2..2,y=-2..2],nstep=500)|\\
will plot $z \rightarrow z^3-1$ from a square in the complex plane
centered at origin, size 4 with a 500 small reectangles discretization.

Beware, the 3d rendering engine is slow on the calculator, therefore the
drawing precision is set to a medium value by default (this impacts
mostly objects with angles, like polyhedrons). You can modify
the rendering precision with F2 (faster, less precise) or F3 (slower, more
precise). 
Tip~: you can increase the CPU speed by running the
\ahref{https://www.planet-casio.com/Fr/programmes/dl.php?id=3710&num=1}{Ptune3}
addin.

If you just want one time a higher
precision rendering, type \verb|^| and be patient. If you want to
interrupt this rendering, press DEL. Use the cursor keys to change the
viewpoint, 5 to reset to default viewpoint, and \verb|-| or \verb|+|
to zoom in/out. 
While a cursor key is
kept pressed, the precision is lower, when the key is released the
last position is redrawn with the default precision.
Type F4 to show/hide a second hidden objet, F5 to show/hide
intermediate points, F6 to show/hide polyhedron edges.



\subsection{Interactive geometry application}
The geometry application lets you construct figures in the 2d plane or
in 3d space. It is possible to move one point of the figure and
observe how the construction evolves, illustrating some properties
(dynamic geometry). Pure geometric constructions may be mixed 
with function graphs and other analytic constructions.
This application has two view: the graphic view where the
figure is rendered and the symbolic view where you see
the Xcas instructions to construct the figure. The philosophy
is similar to Geogebra, but with Xcas commands instead.

You will find here a short description of this application,
cf. \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/geoen.html}{here} for
 a more complete documentation of the geometry application, with a few
screenshots.


\subsubsection{Modes, graphical and symbolic view}
Type F6 1 (or S$\leftrightarrow$D) to display the list
of additional applications, then EXE then select an existing figure
or create a new 2d or 3d figure. You may also open the
geometry application from an existing graph displayed from the shell
(for example after running \verb|plot(sin(x))|)
by typing F6 then Save figure.

At startup, you are in graphical view in frame mode. The cursor key
will modify the viewpoint (move the frame in 2d, rotate viewpoint in 3d).
Press F4 to change mode. Type EXE to switch to symbolic view or back.
For example, type F4 3 to enter point mode, move the pointer and press
EXE where you want to create a point. Or type F4 5 to enter triangle mode
move the pointer to each vertex and press EXE on each vertex.
You can move the pointer with the keypad (use shift cursor key for a fast move),
or if there is an existing
point, type the name (e.g. type ALPHA A to move the pointer to the point A
if it has already been defined).

In a 3d figure, objects will be created in the yellow plane. Press 4 or 6 to
move this plane. It is recommended to keep a viewpoint with $Oz$ vertical
(therefore change viewpoint only with the right and left cursor keys
that make a rotation of axis $Oz$).

Dynamic geometry howto:
switch to pointer mode (F4 2), move near an exising point and select
it with EXE, then move the point with the cursor keys, you will see
how the whole figure depends on that point, this helps conjectures
or illustration of some
geometric properties, like the fact that 3 lines of a triangle have
a common intersection.

If you type EXIT in the graphical view, it will reset mode to frame mode
if you were not in frame mode, or it will switch to symbolic view if
you were in frame mode. In the symbolic view, you can modifiy existing
commands or create new geometric objects with new commandlines (one line
per object). You can save the construction in text format from F6 menu, note
that the file generated will have a \verb|.py| extension
despite the fact that
it is not a Python script.
Type EXIT again to leave the geometry application.

When leaving the geometry application, the figure is saved in
an Xcas variable that has the same identifier than the filename
displayed in the symbolic view. You can erase this Xcas variable
if you want to clear the figure.

{\bf Example~: circumcircle.}\\
From KhiCAS shell, type F6 1 then select new figure 2d EXE.
Type F4  5 Triangle, EXE to create the first vertex, move the pointer
with cursor keys and type EXE for the second vertex, move the pointer
again and type EXE to create the 3rd vertex and the triangle.

Long version, construction of the center:
Type F4 7, select 8 Perpen bisector, move the pointer so that
only one edge of the triangle is selected (this is displayed
at the bottom right, something like \verb|perpen_bisector D5,D|,
type EXE will create the perpendicular bisector. Move the pointer
to another edge of the triangle, type EXE to create the 2nd bisector.
You may optionnaly create the 3rd bisector.
Then type F4 6, select 4 Single intersection. Move the pointer
to a perpen bisector, type EXE, move the pointer to another perpen
bisector and type EXE. This will create the circumcircle center.
Type F4 4, move the pointer to the center (with the cursor keys
or by typing ALPHA H or the center name if it is not H), then EXE,
move to one of the triangle vertex and press EXE.

Short version with the \verb|circumcircle| command:
Type F4 9, select circumcircle, select each vertex with
pointer move + EXE ((ALPHA A EXE ALPHA B EXE ALPHA C EXE, replace
A, B, C with the vertices names).

Symbolic view version:
If you are in the graphical view, type EXIT to move to the symbolic view.
Move to the script end and add a newline if required (shift EXE).
Enter\\
\verb|c:=circonscrit(A,B,C)| EXE

{\bf 3d Example}\\
Type F6 1 from the shell, then select new 3d figure.
Then EXIT or EXE to switch to the symbolic view. Then F5 c ALPHA shift =
F4 uparrow twice, select 3D, EXE 5 for cube, F6 for help on the cube
command, press F2 to copy+paste the first example in the symbolic
view. You should see\\
\verb|c=cube([0,0,0],[1,0,0],[0,1,0])|\\
Type EXE, this display a small cube, type + a few times to zoom in. Then
EXE to switch back to symbolic view.
Type shift EXE to begin a new commandline.
Now we define the vertices of the cube with
\verb|A,B,C,D,E,F,G,H=|
(type ALPHA A , ALPHA B etc.). Then type F4 and uparrow 3 times
to select Geometry then uparrow 4 times to select
\verb|sommets| EXE, put c as argument to get \verb|sommets(c)|.
Type EXE to display the cube and the vertices with their names.
Type EXE again to go back to symbolic view. Then shift EXE to
enter a new commandline, that will define the plane ABC.
Type ALPHA P = then F2 to open the fast menu lines and 8, this will
copy \verb|plane(|.
This command takes 3 points as argument (or a cartesian equation), here
A, B, G, \verb|P=plan(A,B,G,|. We now add a color to the plane
with the F3 disp fast menu
\verb|display=filled+green|. Check by EXE EXE.
Go to the next line (shift EXE) and create segment DE
ALPHA S = F2 select segment command with EXE, type D, E, then F3
and give a color\\
\verb|S=segment(D,E,color=cyan)|
The whole construction should be
\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}
Type EXE to display it and use the keypad to change the viewpoint.
Type EXE or EXIT to go back to symbolic view and EXIT to leave the
geometry application. Type F1 to save the figure if you did not
save it from the F6 menu.
You can access analytic geometry information from KhiCAS shell, for
example \verb|equation(P)| (F4 select Geometry submenu) will
return the cartesian equation of the plane $P$, or
\verb|is_orthogonal(P,S)| (F4 Geometry)
will confirm that the plane $P$
is orthogonal to the segment $S$ (this  should be apparent from
3d rendering).

\subsubsection{Cursors}
Cursors are parametric values that live in a given inteval and may be
moved by 1\% steps from the graphical view. They are created
with the \verb|element| command in the symbolic view or from F4
menu in the graphical view.

{\bf Example~: quadratic explorer}\\
This example demonstrates how the curve of the parabola of equation
$y=ax^2+bx+c$ depends on the value of $a,b,c$.
Create 3 cursors from F4 menu of the graphical view
(for each cursor F4 uparrow 4 times EXE EXE). In the symbolic view
you should have something like
\begin{verbatim}
a:=element(-1..1)
b:=element(0..1,0.5)
c:=element(-1..1)
\end{verbatim}
then add the parabole graph, from graphical view, type F4 0 (for 10 Curves)
and select plot, or from the symbolic view shift EXE shift F6 and select plot
fill inside the parenthesis with \verb|a*x^2+b*x+c| (beware,
do not forget the \verb|*|), then EXE.
From the graphical view, you should see 3 cursors
\verb|a|, \verb|b| and \verb|c| and the corresponding graph.
You can now modify the value of $a,b,c$ and see how it affects the shape
of the parabola. Type F4 2 (pointer mode), then F5 a (or b or c) EXE
to select $a$ (or ($b$ or $c$). Type EXE then the right and left arrow keys,
EXE again to stop moving the cursor.

A lot of variations may be done, some of them simpler with one or two cursors
and a curve depending on one or two parameters. For example a line equation
explorer with \verb|line(y=a*x+b)| or a trigonometic explorer with
\verb|plot(sin(a*x+b))|.

\subsubsection{Measures and legends}
From the graphical view, type F4 and select 13 Measure.
You can compute and display a measure at some point of the figure.
For example after creating a triangle, one can display the
perimeter of the triangle or its area. Type F4 then uparrow twice EXE.
Move the pointer near the triangle, type EXE, move the pointer
where you want to display the measure and type EXE.

From the symbolic view, you can display a legend with the
\verb|legende()| command.
The first argyment of legend may be a point of the figure, or
a vector of 2 integers giving the absolute position in pixels
(measured from the top left corner). The second argument
is the legend, it may be a string or any expression.

If the legend is a numeric value, it can be used as a numeric parameter
for commands that require such an argument, like transformations
(angle of rotation, homothety ratio...)\\
\verb|r:=legend([20,40],"2")|\\
\verb|homothety(A,extract_measure(r),B)| 

\subsubsection{Traces}
The \verb|trace()| command lets you keep track of all the positions of
a geometric object when the figure is recomputed while moving a point


{\bf Example} Enveloppe of the normals to a parametric curve (here an ellipse)
\begin{verbatim}
E:=plotparam([cos(t),2*sin(t)],t=-pi..pi)
a:=element(-pi..pi)
M:=element(E,a)
T:=tangent(M)
N:=perpendiculaire(M,T)
trace(N)
\end{verbatim}
If you change the value of $a$ (F4 2 for pointer mode, F5 a),
you will see a curve that separates the area of normals to the curve
and a free area, this is the enveloppe of normals, it is also
the evolute of the ellipse\\
\verb|evolute(E,color=red)|\\
You can remove the traces in the graphical view from the F6 menu (last item).


\subsection{CAS spreadsheet...}
The file menu has an application item that lets you select
additional applications: a formal spreadsheet,
a finance app, a periodic table, .... Shortcut: type S$\leftrightarrow$D from
the shell or programming editor.

Unlike Casio spreadsheet, the CAS spreadsheet can handle exact or
symbolic values. You can compute cells whose values are
fractions, square roots or expressions containing variables like
$x,y...$.

A cell can contain any valid Xcas value, numbers, strings, etc.
If you enter a list of values, or an Xcas command returning a list
of values, the list will fill consecutives cells (downwards or to the
right, according to the setup). For example type F1 \verb|range(|
10 EXE, this will fill 10 cells with numbers from 0 to 9.

Defining a cell content with reference to other cells
is similar to other spreadsheet, begin with
\verb|=|, and enter an expression that may contain cell references 
(characters \verb|:| and \verb|$| are available from F3 menu,
\verb|:| is also accessible with shift $\rightarrow$). While editing
the cell content, you can select another cell by pressing the up or
down cursor key followed by any other cursor key. To select a range,
move to the begin of selection cell, 
press shift-CLIP then move to the end of selection and type EXE.

While defining a cell, any Xcas commands may be used (you can get
them from F4 menu, or fast menus (F1, F2, shift F1-shift F6, alpha
F1-alpha F6 or shift CATALOG). Programming Xcas structures may also be used as well
as Xcas functions that you have defined. Beware that MicroPython functions
are not supported.
 
A cell can be defined with a command returning a graphic result. Type
the S$\leftrightarrow$D key to display the graphic corresponding to
the graphical output of the whole spreadsheet.

\section{Copyright and Thanks to.}
\begin{itemize}
\item Giac and $\chi$CAS, computing kernel (c) B. Parisse et R. De Graeve, 2022.
\item $\chi$CAS interface adapted by B. Parisse from
Eigenmath source code by Gabrial Maia and from Xcas source code.
\item
$\chi$CAS license GPL2. See details in
the \verb|LICENSE.GPL2| file, inside 
\ahref{https://www-fourier.univ-grenoble-alpes.fr.fr/\home{parisse}/casio/khicasio.zip}{khicasio.zip}
or
\ahref{https://www.gnu.org/licenses/old-licenses/gpl-2.0.html}{GPL2}
on the Free Software Foundation website.
The source code of $\chi$CAS and of the required libraries
libtommath and USTL are available in the
\ahref{https://www-fourier.univ-grenoble-alpes.fr.fr/\home{parisse}/casio/}{Casio section} of my webpage (see section \ref{sec:dev}).
\item Thanks to the active members
of tiplanet and Planete Casio for answering questions and testing
during the time I developed  $\chi$CAS. Special thanks to LePhenixNoir 
(Prizm/35+eii help), Nemhardy (Prizm), and to critor
for articles, tests and advertising.
Thanks to all contributors of
\ahref{http://prizm.cemetech.net/index.php/Prizm_Programming_Portal#Native_OS_reference}{the Prizm programming portal}.
Thanks to Pavel Demin for compilation tricks that spared
about 135K.
\item Thanks to Camille Margot for her interest in this ports,
and to Casio France for sending me calculators and
an emulator license.
\end{itemize}

\section{Developer infos.} \label{sec:dev}
\subsection{Debugger}
Install the cross-gdb tool for the Casio like this
\begin{enumerate}
\item install wine 
\item install Casio emulator (available from Casio site)
  with a command like this\\
\verb|wine /path_to/fx-CG_Manager_PLUS_Subscription_for_fx-CG50series_Ver.3.40.exe|
\item
install gdb-server equivalent
\begin{verbatim}
cd .wine/drive_c/Program\ Files\ \(x86\)/CASIO/fx-CG\ Manager\ PLUS\ Subscription\ for\ fx-CG50series/
mv CPU73050.dll CPU73050.real.dll
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/casio/CPU73050.dll
cp CPU73050.dll CPU73050.dbg.dll
\end{verbatim}
source and other releases for the dll~:
\verb|https://github.com/redoste/fx-CG50_Manager_PLUS-gdbserver|).

\item compile gdb for sh3:
\begin{verbatim}
wget https://ftp.gnu.org/gnu/gdb/gdb-11.1.tar.gz
cd casio (ou autre repertoire de build)
tar xvfz ../gdb-11.1.tar.gz
mkdir sh3eb-gdb
cd sh3eb-gdb
../gdb-11.1/configure --srcdir=../gdb-11.1 --target=sh3eb-elf
\end{verbatim}
(add --prefix=path if you do not have write access to /usr/local/bin).
Then
\begin{verbatim}
make
sudo make install
\end{verbatim}

Create two scripts, \verb|casioemu| for normal emulation
\begin{verbatim}
#! /bin/bash
cd ~/.wine/drive_c/Program\ Files\ \(x86\)/CASIO/fx-CG\ Manager\ PLUS\ Subscription\ for\ fx-CG50series
/bin/cp CPU73050.real.dll CPU73050.dll
cd
wine "C:\Program Files (x86)\CASIO\fx-CG Manager PLUS Subscription for fx-CG50series\fx-CG_Manager_PLUS_Subscription_for_fx-CG50series.exe" /n"fx-CG Manager PLUS Subscription for fx-CG50series" > /dev/null &
\end{verbatim}
and \verb|casiodbg| for debug mode
\begin{verbatim}
#! /bin/bash
cd ~/.wine/drive_c/Program\ Files\ \(x86\)/CASIO/fx-CG\ Manager\ PLUS\ Subscription\ for\ fx-CG50series
/bin/cp CPU73050.dbg.dll CPU73050.dll
cd
wine "C:\Program Files (x86)\CASIO\fx-CG Manager PLUS Subscription for fx-CG50series\fx-CG_Manager_PLUS_Subscription_for_fx-CG50series.exe" /n"fx-CG Manager PLUS Subscription for fx-CG50series" > /dev/null &
\end{verbatim}

\item For normal emulation run \verb|casioemu|, for debug emulation run
\begin{verbatim}
casiodbg
sh3eb-elf-gdb
target remote localhost:31188
\end{verbatim}
Or in one command if your debug infos are in emucas.elf\\
\verb|sh3eb-elf-gdb -i=mi -ex "target remote localhost:31188" emucas.elf|

You can set a breakpoint with \verb|b| or \verb|hb| (\verb|hbreak|
(hardware break, this is required for the first breakpoint).
\end{enumerate}


\subsection{Giac}
Quick linux install~:  get
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/libmpfr.so.4}{libmpfr.so.4}
and copy it to \verb|/usr/local/lib|, check that \verb|/usr/local/lib| is in the paths listed in
\verb|/etc/ld.so.conf| and run \verb|sudo ldconfig|.
Now unarchive
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/casiolocal.tgz}{casiolocal.tgz}, 
this is a working cross-gcc for Casio calculators with additional
libraries (libc, ustl, tommath).
You will also need to install
\ahref{https://www-fourier.univ-grenoble-alpes.fr/~parisse/casio/mkg3a.tgz}{mkg3a}
to build addins for the FXCG.
Then get \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/giac2.tgz}{giac2.tgz}
or
\ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/giacbf.tgz}{giacbf.tgz}, 
unarchive and run \verb|make|. For the light version get \ahref{https://www-fourier.univ-grenoble-alpes.fr/\home{parisse}/casio/giac90.tgz}{giac90.tgz}

If something goes wrong, here are some details. 
You must install the gcc cross-compiler
for sh3eb CPU,  following this
\ahref{https://www.planet-casio.com/Fr/forums/topic12970-1-Tutoriel_Compiler_sous_Linux_avec_un_cross-compilateur_gcc.html}{tutorial (French)}.
I have configured gcc like this\\
\verb|../gcc-5.3.0/configure --target=sh3eb-elf --prefix="$HOME/opt/sh3eb-elf" --disable-nls --disable-shared --disable-multilib --enable-languages=c,c++ --without-headers|\\
Unfortunately, there is no support for sh3eb in the \verb|newlib|
(C librairy) of gcc, nor for \verb|libstdc++|.

The libc is replaced by
\ahref{https://www-fourier.univ-grenoble-alpes.fr/~parisse/casio/libfxcg90.tgz}{libfxcg
  (for CG50)} (it comes from the original SDK with a few modifications,
corrections of small bugs, added missing functions like qsort, ...), 
In the same 
\ahref{https://www-fourier.univ-grenoble-alpes.fr.fr/\home{parisse}/casio/}
{folder}, you will also find  \verb|tommath.tgz| (big integer
support) and \verb|ustl.tar.gz| (standard template library) 
that I also had to modify to make it work with sh3eb-elf-g++, 
with partial success, i.e. enough support to build Giac 
(vector/string/map supported, I/O on files are not supported,
there is a custom iostream file for cin/cout minimal support).
Unarchive and compile with make.

For the monochrom Fx-9860GIII, get 
\ahref{https://www-fourier.univ-grenoble-alpes.fr.fr/\home{parisse}/casio/giac35.tar.bz2}{giac35.tar.bz2} and
run \verb|make| in the \verb|giac35/src0| directory.


\end{giacjshere}
\end{document}

\appendix
\section{Command list.}
You can test a command in the commandline at the bottom of the document.
To get short help on a command, click on \verb|+| to increase
the document console size, then type \verb|?| followed
by the commandname.
\begin{itemize}
\item \verb|a2q|
\item \verb|abcuv|
\item \verb|about|
\item \verb|abs|
\item \verb|acos|
\item \verb|acos2asin|
\item \verb|acos2atan|
\item \verb|acosh|
\item \verb|acot|
\item \verb|acsc|
\item \verb|add|
\item \verb|add_autosimplify|
\item \verb|additionally|
\item \verb|adjoint_matrix|
\item \verb|alg|
\item \verb|algsubs|
\item \verb|algvar|
\item \verb|alog10|
\item \verb|and|
\item \verb|ans|
\item \verb|append|
\item \verb|apply|
\item \verb|approx|
\item \verb|arclen|
\item \verb|arg|
\item \verb|array_sto|
\item \verb|asc|
\item \verb|asec|
\item \verb|asin|
\item \verb|asin2acos|
\item \verb|asin2atan|
\item \verb|asinh|
\item \verb|assert|
\item \verb|assume|
\item \verb|atan|
\item \verb|atan2|
\item \verb|atan2acos|
\item \verb|atan2asin|
\item \verb|atanh|
\item \verb|atrig2ln|
\item \verb|augment|
\item \verb|autosimplify|
\item \verb|barplot|
\item \verb|basis|
\item \verb|bernoulli|
\item \verb|betad|
\item \verb|betad_cdf|
\item \verb|betad_icdf|
\item \verb|bin|
\item \verb|binomial|
\item \verb|binomial_cdf|
\item \verb|binomial_icdf|
\item \verb|blockmatrix|
\item \verb|border|
\item \verb|bounded_function|
\item \verb|break|
\item \verb|breakpoint|
\item \verb|canonical_form|
\item \verb|cas_setup|
\item \verb|cat|
\item \verb|cauchyd|
\item \verb|cauchyd_cdf|
\item \verb|cauchyd_icdf|
\item \verb|ceil|
\item \verb|ceiling|
\item \verb|cfactor|
\item \verb|cfsolve|
\item \verb|changebase|
\item \verb|char|
\item \verb|charpoly|
\item \verb|chinrem|
\item \verb|chisquared|
\item \verb|chisquared_cdf|
\item \verb|chisquared_icdf|
\item \verb|choice|
\item \verb|cholesky|
\item \verb|chr|
\item \verb|chrem|
\item \verb|circle|
\item \verb|clear|
\item \verb|clearscreen|
\item \verb|click|
\item \verb|coeff|
\item \verb|coeffs|
\item \verb|col|
\item \verb|coldim|
\item \verb|collect|
\item \verb|colnorm|
\item \verb|color|
\item \verb|comDenom|
\item \verb|comb|
\item \verb|combine|
\item \verb|comment|
\item \verb|companion|
\item \verb|compare|
\item \verb|complex|
\item \verb|concat|
\item \verb|{|
\item \verb|conj|
\item \verb|cont|
\item \verb|contains|
\item \verb|content|
\item \verb|convert|
\item \verb|coordinates|
\item \verb|copy|
\item \verb|correlation|
\item \verb|cos|
\item \verb|cos2sintan|
\item \verb|cosh|
\item \verb|count|
\item \verb|count_eq|
\item \verb|count_inf|
\item \verb|count_sup|
\item \verb|covariance|
\item \verb|cpartfrac|
\item \verb|cross|
\item \verb|crossproduct|
\item \verb|csolve|
\item \verb|curl|
\item \verb|curve|
\item \verb|cyclotomic|
\item \verb|cylinder|
\item \verb|czeros|
\item \verb|debug|
\item \verb|debug_infolevel|
\item \verb|decrement|
\item \verb|degree|
\item \verb|del|
\item \verb|delcols|
\item \verb|delrows|
\item \verb|denom|
\item \verb|deriver|
\item \verb|desolve|
\item \verb|det|
\item \verb|dfc|
\item \verb|dfc2f|
\item \verb|diag|
\item \verb|diff|
\item \verb|dim|
\item \verb|display|
\item \verb|div|
\item \verb|divcrement|
\item \verb|divergence|
\item \verb|divis|
\item \verb|divisors|
\item \verb|divmod|
\item \verb|divpc|
\item \verb|domain|
\item \verb|dot|
\item \verb|draw_circle|
\item \verb|draw_line|
\item \verb|draw_rectangle|
\item \verb|draw_string|
\item \verb|dtype|
\item \verb|e2r|
\item \verb|egcd|
\item \verb|egv|
\item \verb|egvl|
\item \verb|eigenvals|
\item \verb|eigenvalues|
\item \verb|eigenvectors|
\item \verb|eigenvects|
\item \verb|eliminate|
\item \verb|epsilon2zero|
\item \verb|equal2diff|
\item \verb|equal2list|
\item \verb|equation|
\item \verb|erf|
\item \verb|erfc|
\item \verb|erfs|
\item \verb|euler|
\item \verb|euler_mac_laurin|
\item \verb|eval|
\item \verb|eval_level|
\item \verb|evalb|
\item \verb|evalc|
\item \verb|evalf|
\item \verb|evalm|
\item \verb|even|
\item \verb|exact|
\item \verb|execute|
\item \verb|exp|
\item \verb|exp2pow|
\item \verb|exp2trig|
\item \verb|expexpand|
\item \verb|expln2trig|
\item \verb|exponential_regression|
\item \verb|exponential_regression_plot|
\item \verb|exponentiald|
\item \verb|exponentiald_cdf|
\item \verb|exponentiald_icdf|
\item \verb|expr|
\item \verb|extend|
\item \verb|f2nd|
\item \verb|fMax|
\item \verb|fMin|
\item \verb|factor|
\item \verb|factor_xn|
\item \verb|factorial|
\item \verb|factors|
\item \verb|fclose|
\item \verb|fcoeff|
\item \verb|fft|
\item \verb|fft_mult_size|
\item \verb|filter|
\item \verb|find|
\item \verb|findhelp|
\item \verb|fisher|
\item \verb|fisher_cdf|
\item \verb|fisher_icdf|
\item \verb|fisherd|
\item \verb|fisherd_cdf|
\item \verb|fisherd_icdf|
\item \verb|flatten|
\item \verb|flatten1|
\item \verb|float|
\item \verb|float2rational|
\item \verb|floor|
\item \verb|fopen|
\item \verb|format|
\item \verb|fourier_an|
\item \verb|fourier_bn|
\item \verb|fourier_cn|
\item \verb|fprint|
\item \verb|frac|
\item \verb|fracmod|
\item \verb|frobenius_norm|
\item \verb|froot|
\item \verb|fsolve|
\item \verb|function_diff|
\item \verb|fxnd|
\item \verb|galoisconj|
\item \verb|gammad|
\item \verb|gammad_cdf|
\item \verb|gammad_icdf|
\item \verb|gauss|
\item \verb|gaussquad|
\item \verb|gbasis|
\item \verb|gcd|
\item \verb|genpoly|
\item \verb|geometric|
\item \verb|geometric_cdf|
\item \verb|geometric_icdf|
\item \verb|getDenom|
\item \verb|getKey|
\item \verb|getNum|
\item \verb|goto|
\item \verb|grad|
\item \verb|gramschmidt|
\item \verb|greduce|
\item \verb|hadamard|
\item \verb|halftan|
\item \verb|halftan_hyp2exp|
\item \verb|halt|
\item \verb|has|
\item \verb|heapify|
\item \verb|heappop|
\item \verb|heappush|
\item \verb|help|
\item \verb|hermite|
\item \verb|hessenberg|
\item \verb|hessian|
\item \verb|hex|
\item \verb|hilbert|
\item \verb|histogram|
\item \verb|hold|
\item \verb|horner|
\item \verb|hyp2exp|
\item \verb|iabcuv|
\item \verb|ibasis|
\item \verb|ibpdv|
\item \verb|ibpu|
\item \verb|ichinrem|
\item \verb|ichrem|
\item \verb|icontent|
\item \verb|id|
\item \verb|idivis|
\item \verb|idn|
\item \verb|iegcd|
\item \verb|ifactor|
\item \verb|ifactors|
\item \verb|ifft|
\item \verb|igamma_exp|
\item \verb|igcd|
\item \verb|ilaplace|
\item \verb|im|
\item \verb|imag|
\item \verb|image|
\item \verb|in_ideal|
\item \verb|increment|
\item \verb|indets|
\item \verb|index|
\item \verb|inferieur_strict_sort|
\item \verb|input|
\item \verb|insert|
\item \verb|int|
\item \verb|integer_format|
\item \verb|integrate|
\item \verb|interp|
\item \verb|inv|
\item \verb|inverse|
\item \verb|invlaplace|
\item \verb|iquo|
\item \verb|iquorem|
\item \verb|iquosto|
\item \verb|iratrecon|
\item \verb|irem|
\item \verb|iremsto|
\item \verb|is_prime|
\item \verb|is_pseudoprime|
\item \verb|isfinite|
\item \verb|isinf|
\item \verb|isnan|
\item \verb|isprime|
\item \verb|ithprime|
\item \verb|jacobi_symbol|
\item \verb|join|
\item \verb|jordan|
\item \verb|ker|
\item \verb|kernel|
\item \verb|kill|
\item \verb|l1norm|
\item \verb|l2norm|
\item \verb|label|
\item \verb|lagrange|
\item \verb|laguerre|
\item \verb|laplace|
\item \verb|laplacian|
\item \verb|lcm|
\item \verb|lcoeff|
\item \verb|ldegree|
\item \verb|left|
\item \verb|legend|
\item \verb|legendre|
\item \verb|legendre_symbol|
\item \verb|len|
\item \verb|length|
\item \verb|lgcd|
\item \verb|lhs|
\item \verb|limit|
\item \verb|limite|
\item \verb|lin|
\item \verb|line|
\item \verb|linear_regression|
\item \verb|linear_regression_plot|
\item \verb|linetan|
\item \verb|linfnorm|
\item \verb|linsolve|
\item \verb|linspace|
\item \verb|list2mat|
\item \verb|lll|
\item \verb|ln|
\item \verb|lname|
\item \verb|lncollect|
\item \verb|lnexpand|
\item \verb|log10|
\item \verb|logarithmic_regression|
\item \verb|logarithmic_regression_plot|
\item \verb|logb|
\item \verb|lower|
\item \verb|lu|
\item \verb|lvar|
\item \verb|makelist|
\item \verb|makemat|
\item \verb|makemod|
\item \verb|makesuite|
\item \verb|makevector|
\item \verb|map|
\item \verb|mat2list|
\item \verb|matpow|
\item \verb|matrix|
\item \verb|matrix_norm|
\item \verb|max|
\item \verb|max_algext|
\item \verb|maxnorm|
\item \verb|mean|
\item \verb|member|
\item \verb|mid|
\item \verb|min|
\item \verb|mods|
\item \verb|moyal|
\item \verb|mult_c_conjugate|
\item \verb|mult_conjugate|
\item \verb|multcrement|
\item \verb|multinomial|
\item \verb|multiply|
\item \verb|ncols|
\item \verb|negbinomial|
\item \verb|negbinomial_cdf|
\item \verb|negbinomial_icdf|
\item \verb|newton|
\item \verb|nextprime|
\item \verb|nop|
\item \verb|nops|
\item \verb|norm|
\item \verb|normal|
\item \verb|normald|
\item \verb|normald_cdf|
\item \verb|normald_icdf|
\item \verb|normalize|
\item \verb|nprimes|
\item \verb|nrows|
\item \verb|numer|
\item \verb|oct|
\item \verb|odd|
\item \verb|odesolve|
\item \verb|op|
\item \verb|or|
\item \verb|ord|
\item \verb|order_size|
\item \verb|ou|
\item \verb|part|
\item \verb|partfrac|
\item \verb|pcar|
\item \verb|pcoeff|
\item \verb|periodic|
\item \verb|peval|
\item \verb|piecewise|
\item \verb|plot|
\item \verb|plotfield|
\item \verb|plotfunc|
\item \verb|plotlist|
\item \verb|plotode|
\item \verb|plotparam|
\item \verb|plotpolar|
\item \verb|plotseq|
\item \verb|pmin|
\item \verb|point|
\item \verb|poisson|
\item \verb|poisson_cdf|
\item \verb|poisson_icdf|
\item \verb|polar2rectangular|
\item \verb|poly2symb|
\item \verb|polygamma|
\item \verb|polygon|
\item \verb|polygonplot|
\item \verb|polygonscatterplot|
\item \verb|polynomial_regression|
\item \verb|polynomial_regression_plot|
\item \verb|pop|
\item \verb|potential|
\item \verb|pow2exp|
\item \verb|power_regression|
\item \verb|power_regression_plot|
\item \verb|powermod|
\item \verb|powexpand|
\item \verb|powmod|
\item \verb|prepend|
\item \verb|preval|
\item \verb|prevprime|
\item \verb|primpart|
\item \verb|print|
\item \verb|printf|
\item \verb|printpow|
\item \verb|product|
\item \verb|prog_eval_level|
\item \verb|proot|
\item \verb|propfrac|
\item \verb|ptayl|
\item \verb|python|
\item \verb|python_compat|
\item \verb|python_list|
\item \verb|q2a|
\item \verb|qr|
\item \verb|quo|
\item \verb|quorem|
\item \verb|quote|
\item \verb|r2e|
\item \verb|rand|
\item \verb|randbinomial|
\item \verb|randchisquare|
\item \verb|randchisquared|
\item \verb|randexp|
\item \verb|randfisherd|
\item \verb|randgeometric|
\item \verb|randint|
\item \verb|randmatrix|
\item \verb|randmultinomial|
\item \verb|randnormald|
\item \verb|random|
\item \verb|randpoisson|
\item \verb|randpoly|
\item \verb|randrange|
\item \verb|randstudentd|
\item \verb|randvector|
\item \verb|range|
\item \verb|rank|
\item \verb|ranm|
\item \verb|ranv|
\item \verb|rassembler_trigo|
\item \verb|rat_jordan|
\item \verb|ratnormal|
\item \verb|re|
\item \verb|read|
\item \verb|real|
\item \verb|realproot|
\item \verb|rectangular2polar|
\item \verb|rectangular2spherical|
\item \verb|regroup|
\item \verb|rem|
\item \verb|remove|
\item \verb|reorder|
\item \verb|resultant|
\item \verb|reverse|
\item \verb|reverse_rsolve|
\item \verb|reverse|
\item \verb|revlist|
\item \verb|rhs|
\item \verb|right|
\item \verb|rm_a_z|
\item \verb|rm_all_vars|
\item \verb|rmbreakpoint|
\item \verb|rmwatch|
\item \verb|rootof|
\item \verb|roots|
\item \verb|rotate|
\item \verb|round|
\item \verb|row|
\item \verb|rowdim|
\item \verb|rownorm|
\item \verb|rpn|
\item \verb|rref|
\item \verb|rsolve|
\item \verb|sample|
\item \verb|scatterplot|
\item \verb|sec|
\item \verb|segment|
\item \verb|select|
\item \verb|semi_augment|
\item \verb|seq|
\item \verb|series|
\item \verb|set_pixel|
\item \verb|shift|
\item \verb|shift_phase|
\item \verb|shuffle|
\item \verb|sign|
\item \verb|simp2|
\item \verb|simplify|
\item \verb|sin|
\item \verb|sin2costan|
\item \verb|sincos|
\item \verb|sinh|
\item \verb|size|
\item \verb|sizes|
\item \verb|smod|
\item \verb|snedecord|
\item \verb|snedecord_cdf|
\item \verb|snedecord_icdf|
\item \verb|solve|
\item \verb|solve_zero_extremum|
\item \verb|sommet|
\item \verb|sort|
\item \verb|sorta|
\item \verb|sortd|
\item \verb|sorted|
\item \verb|sphere|
\item \verb|spherical2rectangular|
\item \verb|split|
\item \verb|sq|
\item \verb|sqrfree|
\item \verb|sqrt|
\item \verb|srand|
\item \verb|sst|
\item \verb|sst_in|
\item \verb|stddev|
\item \verb|sto|
\item \verb|str|
\item \verb|string|
\item \verb|strip|
\item \verb|studentd|
\item \verb|studentd_cdf|
\item \verb|studentd_icdf|
\item \verb|sturm|
\item \verb|sturmab|
\item \verb|sturmseq|
\item \verb|subst|
\item \verb|substituer|
\item \verb|subtype|
\item \verb|sum|
\item \verb|suppress|
\item \verb|surd|
\item \verb|svd|
\item \verb|sylvester|
\item \verb|symb2poly|
\item \verb|table|
\item \verb|tabvar|
\item \verb|tan|
\item \verb|tan2cossin2|
\item \verb|tan2sincos|
\item \verb|tan2sincos2|
\item \verb|tanh|
\item \verb|taux_accroissement|
\item \verb|taylor|
\item \verb|tchebyshev1|
\item \verb|tchebyshev2|
\item \verb|tcoeff|
\item \verb|tcollect|
\item \verb|tcollectsin|
\item \verb|texpand|
\item \verb|throw|
\item \verb|time|
\item \verb|tlin|
\item \verb|total_degree|
\item \verb|trace|
\item \verb|tran|
\item \verb|trig2exp|
\item \verb|trigcos|
\item \verb|trigexpand|
\item \verb|trigsimplify|
\item \verb|trigsin|
\item \verb|trigtan|
\item \verb|trn|
\item \verb|trunc|
\item \verb|truncate|
\item \verb|tsimplify|
\item \verb|type|
\item \verb|unapply|
\item \verb|uniform|
\item \verb|uniform_cdf|
\item \verb|uniform_icdf|
\item \verb|uniformd|
\item \verb|uniformd_cdf|
\item \verb|uniformd_icdf|
\item \verb|unquote|
\item \verb|upper|
\item \verb|valuation|
\item \verb|vandermonde|
\item \verb|variance|
\item \verb|vector|
\item \verb|version|
\item \verb|vpotential|
\item \verb|warn_equal_in_prog|
\item \verb|watch|
\item \verb|weibulld|
\item \verb|weibulld_cdf|
\item \verb|weibulld_icdf|
\item \verb|when|
\item \verb|with_sqrt|
\item \verb|write|
\item \verb|wz_certificate|
\item \verb|xcas|
\item \verb|xcas_mode|
\item \verb|zeros|
\item \verb|zip|
\end{itemize}
\end{giacjshere}
\end{document}
