$\chi$ CAS(io)

Bernard.Parisse@univ-grenoble-alpes.fr

2018

Abstract: This document explains how to run efficiently $\chi$ CAS on Casio CG50 calculators. $\chi$ CAS is an adapted version of the Giac/Xcas computer algebra system (CAS) for this calculator.
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.
This document is interactive, you can modify and run commands by clicking in the ok button or by hitting Enter.

1 Installation

To install or update $\chi$ CAS, get on your computer the file khicasen.g3a

Connect the USB cable of the calculator, type F1 for USB key connection and copy the file khicasen.g3a on the calculator-“key” then disconnect the key from your computer.

If you test from the emulator, (PC, Mac), from the main menu of the calculator (MENU), go to Memory then F3 (Import/Export), then F1 (Import files), select the file khicasen.g3a, type F1 to save to the calculator root directory, confirm with F1 if you upgrade. Be patient, the transfert will take several minutes (about 5).

Once the transfert is finished, you should see the snowflake icon of Xcas in the main menu.

2 First steps

From the main menu (MENU), move the cursor to the Xcas icon and hit EXE. This opens a “shell” where you can write most Xcas commands.

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

You can copy a command 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, EXE, replace 1/6 by 1/3 and hit EXE.

The last result is stored in ans(), hit the Ans calculator key to get it (keys: shift then (-)). 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

right-store with => using the $\rightarrow$ key, for example 2=>A stores 2 in variable A. Now, every time you write A in a computation, it will be replaced by 2.
left-store with :=, type shift then F1. for example A:=2 does the same as 2=>A.

If you begin a commandline by hitting $\rightarrow$ , the system will automatically insert Ans=>, it is therefore easy to store a result in a variable.

The most popular Xcas commands are available from the Catalog, where they are shortly explained with an example. Hit F4 (CATALOG), choose a submenu, for example Algebra, hit EXE, move the selection to a command, for example 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 + and - to modify the fontsize. Type EXIT to go back to the shell.

Now, try to type the command plot(sin(x)). Hint: type F4 (CATALOG), then select Graphs.

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

The KhiCAS menu (F6) has an item 5 Clear that will erase the display and optionally erase the variables (in order to start a new exercice with a fresh CAS). You will see the message /* DEL EXE to */ restart?. Type ON to erase the display only (variables are not erased) or DEL then EXE to erase variables.

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 (except if you disable auto-save from KhiCAS F6 menu). On the emulator, auto-save is sometimes slow (10 to 20 seconds), it’s faster on the calculator. This is also true for other computations, the calculator is faster, up to 4 times faster than my computer.

It is recommended to hit MENU before OFF, otherwise when you power on the calculator, a history command may be added to the commandline (press AC/ON or/and EXE to restore normal behavior).

3 Common CAS commands

3.1 Expand and factor

From catalog, select Algebra

factor : factorization. Shortcut =>* ( $\rightarrow$ key then *), for example
x^4-1=>*
. Run cfactor to factor over $\C$ .
partfrac : expands a polynomial or performs partial fraction expansion over a fraction. Shortcut =>+ ( $\rightarrow$ then + key), for example
(x+1)^4=>+
or
1/(x^4-1)=>+
.
simplify : tries to simplify an expression. Shortcut =>/ ( $\rightarrow$ key then /), for example
sin(3x)/sin(x)=>/
ratnormal : rewrite as an irreducible fraction.

3.2 Calculus

From catalog, select Calculus

diff : derivative. Shortcut ' (F3) for derivative with respect to $x$ , example
diff(sin(x),x)
and
sin(x)'
are equivalent. For $n$ th-derivative, add $n$ , for example 3rd derivative
diff(sin(x^2),x,3)
.
integrate : antiderivative (1 or 2 arguments) for example
integrate(sin(x))
or
integrate(1/(t^4-1),t)
for $\int \frac{1}{t^4-1} \ dt$
Defined integration with 4 arguments, for example
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
integrate(sin(x)^4,x,0.0,pi)

Shortcut: shift F3.
limit : limit of an expression. Example
limit((cos(x)-1)/x^2,x=0)
tabvar : table of variations of an expression. for example
tabvar(x^3-7x+5)
one can check with the graph plot(x^3-7x+5,x,-4,4)
taylor and series : Taylor expansion or asymptotic serie expansion, for example taylor(sin(x),x=0,5)

Add polynomial if you do not want to have the remainder term.
sum : discrete summation, for example
sum(k^2,k,1,n)
computes $\sum_{k=1}^n k^2$ ,
sum(k^2,k,1,n)=>*
computes the sum and rewrites it factored.
Shortcut: ALPHA F3.

3.3 Solvers

From catalog, select Solve.

solve solves an equation exactly. Takes the variable to solve for as second argument, unless it is x, for example
solve(t^2-1=0,t)
.
If exact solving fails, run fsolve for approx solving, either with an iterative method starting with a guess
fsolve(cos(x)=x,x=0.0)
, or by dichotomy
fsolve(cos(x)=x,x=0..1)
.
For complex solutions, run csolve.
It is possible to restrict solutions using assumptions on the variable, for example
assume(m>1)
then
solve(m^2-4=0,m)
.
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:
solve([x^2+y^2+2y=3,x+y=1],[x,y])
Run linsolve to solve linear systems. enter a list of equations as 1st argument and a list of variables as 2nd argument, example: linsolve([x+2y=3,x-y=7],[x,y])
Run desolve to solve exactly a differential equation. for example, to solve $y'=2y$ , type desolve(y'=2y).
Another example with an initial condition:
desolve([y'=2y,y(0)=1],x,y)
Run odesolve for approx solving or plotode for a graphic representation of the approx. solution.
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:
rsolve(u(n+1)=2*u(n)+3,u(n),u(0)=1)

3.4 Arithmetic

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

3.4.1 Integer

From catalog, select Arithmetic, Crypto

iquo(a,b), irem(a,b) quotient and remainder of euclidean division of two integers.

iquo(23,13),irem(23,13)
isprime(n) checks whether $n$ is prime. This is a probabilisitic test for large values of $n$ .
isprime(2^64+1)
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
ifactor(2^64+1)

Shortcut $\rightarrow$ then * (=>*)
gcd(a,b), lcm(a,b) GCD and LCM of two integers or polynomials.

gcd(25,15),lcm(25,15)

gcd(x^3-1,x^2-1),lcm(x^3-1,x^2-1)
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|$ .

u,v,d:=iegcd(23,13); 23u+13v
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).
c,n:=ichinrem([1,23],[2,13]); irem(c,23); irem(c,13)
powmod(a,n,m) returns $a^n \pmod m$ computed by the fast modular powering algorithm

powmod(7,22,23)
asc converts a string to a list of ASCII code, char converts back a list to a string. These commands may be used to easily write cryptographic algorithms with string messages.

3.4.2 Polynomials

From catalog, select Polynomials. The default variable is $x$ , otherwise you can specify it as last optional argument. For example degree(x^2*y) or degree(x^2*y,x) return 2, degree(x^2*y,y) returns 1.

coeff(P,n) coefficient of $x^n$ in $P$ , lcoeff(P) leading coefficient of $P$ , for example
P:=x^3+3x; coeff(P,1); lcoeff(P)
degre(P) degree of polynomial $P$ degree(x^3)
quo(P,Q), rem(P,Q) quotient and remainder of euclidean division of P by Q
P:=x^3+7x-5; Q:=x^2+x; quo(P,Q); rem(P,Q)
proot(P) : approx. roots of $P$ (all roots, real and complex)
proot(x^5+x+1)
Graphic representation
point(proot(x^5+x+1))
interp(X,Y) : for two lists of the same size, returns the interpolating polynomial $P$ such that $P(X_i)=Y_i$ .

X,Y:=[0,1,2,3],[1,-3,-2,0]; P:=interp(X,Y)=>+
Graphic representation
scatterplot(X,Y); plot(P,x,-1,4)
resultant(P,Q) : resultant of polynomials $P$ and $Q$ P:=x^3+7x-5; Q:=x^2+x; resultant(P,Q)
hermite(x,n) : $n$ -th Hermite polynomial (orthogonal for the density $e^{-x^2}dx$ on $\R$ )
laguerre(x,n,a) : $n$ -th Laguerre polynomial
legendre(x,n) : $n$ -th Legendre polynomial (orthogonal for the density $dx$ on $[-1,1]$ )
tchebyshev1(n) and 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)$

3.5 Linear algebra, vectors, matrices

Xcas does not make distinction between vectors and lists. For example,

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

onload
defines 2 vectors $v$ and $w$ , then dot will compute the scalar product of $v$ and $w$ : 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 or F6 4). Enter a new variable name to create a new matrix or the name of an existing variable to edit a matrix. 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

A:=[[1,2],[3,4]]

onload
or
[[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 matrix command, for example:
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 idn(n) to get the identity matrix of order $n$ and ranm(n,m,law,[parameter]) to get a matrix with random coefficients with dimensions $n,m$ . for example
U:=ranm(4,4,uniformd,0,1)

N:=ranm(4,4,normald,0,1)

For basic arithmetic on matrices, use keyboard operators (+ - *, inverse). Otherwise, open catalog and select Alglin, Matrices

eigenvals(A)

eigenvects(A)
eigenvalues and eigenvectors of matrix $A$ .
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)
Ak:=matpow(A,k)
computes matrix $A$ to the $k$ -th power, where $k$ is symbolic.
rref: row reduction to echelon form
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 P,L,U:=lu(A)
may be passed as an argument to the command 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)$ ).
qr $QR$ factorization of matrix $A$ , $Q$ is orthogonal and $R$ upper triangular, $A=QR$ .
svd(A) singular value decomposition of matrix $A$ returns $U$ orthogonal, $S$ vector of singular values, $Q$ orthogonal such that 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.

4 Probabilities and statistics

4.1 Random numbers

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

ranv(10,normald,0,1)

4.2 Probabilities

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

To get the cumulated distribution function, enter the law name then the _cdf suffix (shortcut: select cdf in the catalog at the end and press F1). Inverse cumulated distribution function follows the same principle with _icdf suffix (shortcut: select 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% M:=5000; S:=200; normald_icdf(M,S,0.025);normald_icdf(M,S,0.975)

4.3 1-d statistics

The statistic functions are taking lists as arguments, for example

l:=[9,11,6,13,17,10]

onload
From catalog, select Statistics:

mean(l)
: arithmetic mean of a list
stddev(l)
: standard deviation of a list.
Run stddevp(l)
to get an unbiaised estimate of the standard deviation of a population from a sample l
median(l)
, quartile1(l)
, quartile3(l)
returns respectivly the median, first and third quartile of a list.

For 1-d statistics with frequencies, replace 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, Graphic and select histogram or barplot.

4.4 2-d statistics

From catalog, select Statistics:

correlation(X,Y): correlation of two lists $X$ and $Y$ of the same length.
covariance(X,Y):: covariance of two lists $X$ and $Y$ of the same length.
regression computations: run commands with suffix _regression(X,Y), for example linear_regression(X,Y) returns coefficients $m,p$ of the linear regression line $y=mx+p$ .
linear_regression_plot(X,Y) and all commands of suffix _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).

5 Graphics

From catalog, select Graphics (shortcut 7).

plot(f(x),x=a..b) plot expression $f(x)$ for $x\in [a,b]$ . Discretization option: xstep=, for example plot(x^2,x=-4..4,xstep=1)
Default is 384 evaluations per plot (one per horizontal pixel).
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]$ plotseq(sqrt(2+x),x=[6,0,7])
plotparam([x(t),y(t)],t=tm..tM) parametric plot $(x(t),y(t))$ for $t\in [t_m,t_M]$ . Discretization option: tstep=. Example plotparam([sin(2t),cos(3t)],t,0,2*pi)
plotpolar(r(theta),theta=a..b) polar plot of $r(\theta)$ for $\theta \in [a,b]$ , for example plotpolar(sin(3*theta),theta,0,2*pi)
plotlist(l): plot a list l, i.e. draws a polygonal line with vertices $(i,l_i)$ (index $i$ starts at 0).
plotlist([X1,Y1],[X2,Y2],...) polygonal line with vertices the points of coordinates $(X_i,Y_i)$
scatterplot(X,Y), polygonscatterplot(X,Y) for two lists X,Y of the same size, draws the points or a polygonal line of vertices $(X_i,Y_i)$
histogram(l,class_min,class_size) plots the histogram of data in l, class size class_size, first class starts at class_min. Example: check the random generator quality
l:=ranv(500,normald,0,1); histogram(l,-4,0.25); plot(normald(x),x,-4,4)
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,...$ .
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 ,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]$
plotfield(sin(t*y),[t=-3..3,y=-3..3],plotode=[0,1])

N.B.: plotode may be used outside of plotfield.

For simultaneous plots, write commands separated by ;

For display options, press the OPTN key:

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

6 Programs

You can program either with Xcas-like syntax (English or French) or with Python-like syntax.

Example : function defined by an algebraic expression nom_fonction(parametres):=expression for example simple confidence interval for a frequency $p$ in a sample of size $N$
F(P,N):=[P-1/sqrt(N),P+1/sqrt(N)]

Test F(0.4,30)

Second example : more precise confidence interval for a frequency $p$ in a sample of size $N$ :
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. Run shift-PRGM to enter function, local, return and ffunction)
function f(P,N) local D; D:=1.96*sqrt(P*(1-P)/N); return [P-D,P+D]; ffunction;

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 New program, enter a filename like conf, then F6, type the program above with the help of the shift-PRGM shortcut for programming structures. Type F6 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
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 menu, if it is not checked, check it (7). Type F6 New program, enter test for the program name then F6. This should create a file named test.py and open the program editor, you should see the following template for a function definition def f(x):. Replace x by n (press F5 to lock the keyboard in alpha lowercase), move to the end of the line and press EXE to input a newline. Type Shift-PRGM then 3 for, then F5 J space alpha, then Shift-PRGM then 6 in range(a,b). Type 1,n+1) then F1 (:). Type Shift-EXE to insert a newline then Alpha SPACE, F4 (CATALOG), EXE (1 All), P, select print then EXE, type j,j^2) then EXE.

def f(n):
  for j in range(1,n+1):
    print(j,j^2)

Inside Xcas ^ means power, ** is also accepted like in Python.

Now, type F6, select 1. Check syntax. If syntax is correct, you will see 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 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 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, New program, enter logo as filename, then select F1 Turtle. You should see efface which mean clear the screen. You can access to the turtle commands using shift-MENU (move the cursor to a command and press F6 for help). For example try avance (forward). Checking the syntax (F6 1 or ON) will display the turtle window moves. You can enter several moves in your script, and organize them in functions. For example:

function square(n)
  repete(4,avance n,tourne_gauche);
ffunction:;
  
efface;
for n from 1 to 10 do
  square(10*n);
od;

Another example of non algebraic function: the euclidean algorithm to compute the GCD of two integers. Press shift-EXE to insert a newline. ! is in the submenu Programmation_cmds (11, shortcut $X,\theta,T$ ) Xcas syntax

function pgcd(a,b)
  while b!=0 do
    a,b:=b,irem(a,b);
  od;
  return a;
ffunction

Python syntax

def pgcd(a,b):
  while b!=0:
    a,b=b,a % b
  return a

Check with pgcd(12345,3425)

If your program has runtime errors or if you want to see it run step by step, run debug on it, for example
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 math, cmath, random, scipy, numpy, turtle. There is also a small pixelised graphic commands set (set_pixel(x,y,c), set_pixel() to synchronize display, clearscreen(), draw_line(x1,y1,x2,y2,c), draw_polygon([[x1,y1],[x2,y2],...],c), draw_rectangle(x,y,w,h,c), draw_circle(x,y,r,c), the color+width+filled c parameter is optional, draw_arc(x,y,rx,ry,t1,t2,c) draws an ellipsis arc). And you can somewhat replace matplotlib with graphic commands of $\chi$ CAS (point, line, segment, circle, barplot, histogram and all ...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.

7 Keyboard shortcuts.

F1 to F3 : depends on mode (Python/Xcas) and shift/alpha state, see labels
F4: catalog.
F5: uppercase to lowercase switch. If alpha mode is not active, locks the keyboard in alpha lowercase.
F6: File and config menu
(-): returns the _ character.
shift PRGM: programming commands
OPTN: all options
shift-QUIT: turtle commands
shift-List: create or edit a list
shift-Mat: create or edit a matrix
angle key: polar_complex
yellow shifted fraction: limit
red r key: abs
red $\theta$ key: arg
S $\leftrightarrow$ D key: approx
yellow shifted S $\leftrightarrow$ D key: exact

In programming editor

shift-cursor key: move to begin/end of line or file
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.
EXE: if a search/replace is currently active (F6 6) find next word occurence. Otherwise add a newline.
shift EXE: add a newline.
DEL: remove selection or previous character if no selection active
shift PASTE: copy clipboard
Shift-INS (touche DEL): remove current line and copy to clipboard
AC/ON: cancel selection or cancel search/replace or check syntax (like F6 1)
EXIT: leave editor to the commandline. Type EXIT again to come back to the editor.

8 Remarks

This adaptation is not a full version of Xcas because the maximal size for a Casio add-in is too small (2 Mo). There are more complete adaptations of Xcas for calculators, for more informations, refer to Giac/Xcas homepage.

9 Copyright and Thanks to.

Giac and $\chi$ CAS, computing kernel (c) B. Parisse et R. De Graeve, 2018.
$\chi$ CAS interface adapted by B. Parisse from Eigenmath source code by Gabrial Maia and from Xcas source code.
$\chi$ CAS license GPL2. See details in the LICENSE.GPL2 file, inside khicasio.zip or 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 Casio section of my webpage (see section 10).
Thanks to the active members of tiplanet and Planete Casio for answering questions and testing during the time I developed $\chi$ CAS. Thanks to all contributors of the Prizm programming portal. Thanks to Pavel Demin for compilation tricks that spared about 135K.
Thanks to Casio France for sending me a calculator and an emulator license.

10 Developer infos.

To build this add-in, I have installed the gcc cross-compiler for sh3eb CPU following this tutorial (French). I have configured gcc like this
../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 newlib (C librairy) of gcc, nor for libstdc++.

I installed libfxcg.tar.gz with a few modification (corrections of small bugs, added missing functions like qsort, ...), it is available in this folder (unarchive and compile with make). In this folder you will also find tommath.tgz (big integer support) and 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.

The file sh3eb-elf.tar.gz is a binary version of gcc/libraries for GNU/Linux debian 9.

The file khicas.tgz is the source of the port of Giac. Run the mkxcas script to compile Giac.

A 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 + to increase the document console size, then type ? followed by the commandname.

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

χ\chiCAS(io)