χ\chiCAS for Numworks calculators

Bernard.Parisse@univ-grenoble-alpes.fr

2024

Abstract: This document explains how to run efficiently χ\chiCAS on Numworks calculators (N0110, N0115, N0120). χ\chiCAS is a port of the Giac/Xcas computer algebra system (CAS) for these calculators. Main features are: CAS, spreadsheet, 2d/3d interactive/analytic geometry, like on high-end CAS calculators, and more in some areas.

This document is interactive, you can modify and run commands by clicking in the ok button or by hitting Enter.

Contents

1  Introduction and installation

χ\chiCAS is a port of the Giac/Xcas computer algebra system (CAS) for the following Numworks calculators (N0110, N0115, N0120).

The following versions of χ\chiCAS are available for the Numworks :

Refer to the developer section 13 for technical information.

1.1  Calculator

If you have a “locked” Numworks with Epsilon version 16 or above, it is most probably required that you update your Epsilon version. To do that, press the 6 button, hold it down, press RESET, release the 6 button and go on Numworks site to update, then close the Numworks site tab/window.

To install or update χ\chiCAS, connect the USB cable of the calculator, and open a web-usb compatible browser on this link click on Install on the top bar and follow instructions.

1.2  Simulator

χ\chiCAS can be installed inside the Numworks simulator, but the current Epsilon license ("All rights reserved”) does currently not allow redistribution of binaries. You can either run Upsilon (based on Epsilon 15.5)+Xcas or compile the simulator yourself. Run Upsilon+Xcas:

  1. Version without installation, runs inside a browser like Firefox, Chrome,....
    Shortcut to run Xcas from Numworks main menu: press the Back key.
    With this version, you can share a session by displaying a QR code: press Power (on a real calculator, you can display the QR code by saving the session: press shift EXE then 2 or 3). Press Back to return to the shell.
  2. Windows: download upsilon.zip, open the archive and run upsilon.exe
  3. Mac, stable version (checked on OS 12.7.1 and 14.4): download Upsilon.dmg, open the disk image Upsilon.dmg
    Many thanks to Adrien Bertrand who helped me doing the port and build the signed package.
  4. Linux or compile from sources : 
    wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/upsilon.tar.bz2
tar xfj upsilon.tar.bz2
cd Upsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/upsilon_cas_full.tgz
tar xfz upsilon_cas_full.tgz
    then run mksimu (Linux) or mkmac (Mac) or mkwin (Windows). Target javascript can be compiled with emscripten 1.40 and script mkw, it requires versions of GMP, MPFR and MPFI libraries compiled with -fPIC, these libraries can be found in emgiac3, this directory contains a copy of an install of emscripten 1.40.1 on Ubuntu 20 x86_64 architecture.

Short procedure to compile Epsilon 22+Xcas, for more details, refer to 13)

  1. Windows
    1. Install msys2/mingw64
    2. Open a terminal mingw64 from Windows main menu, submenu msys2. In the option menu of the windows (up left corner) select Keys, then check Ctrl-shift-letter shortcut, this enables paste with Ctrl-shift-V.
    3. copy-paste the following commands (ctrl-c then ctrl-shift-v)
      pacman -S wget
      wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwwin
      ./nwwin
      Wait some time. If everything went well, the simulator epsilon.exe will open. The simulator executable is c:\msys64\home\username\epsilon\epsilon.exe where username is your Windows username. You can move it to another folder or copy it on another PC.
      Beware that software licenses do not allow public redistribution.
  2. Mac :
    1. From launchpad, type Terminal in the research field, then Enter, this will open a Terminal.
    2. Download nwmac, check that it is in your Downloads folder.
    3. Copy-paste (command-c and command-v) the command
      ~/Downloads/nwmac
      Wait some time. If everything went well, the simulator will open. It has been copied to /Applications and may be opened like any other application.
    4. Optionnal, if you want to copy the simulator on another Mac
      A package Khicasnw.pkg has been created in your Download directory. Open the Mac disk utility, in the File menu select New image, create a disk image. Copy the package to the disk image, eject the disk image from Finder. Now you can copy the disk image (by net or USB key) on another Mac. On the other Mac, open the disk image from Finder then click on the package while pushing the Control key and install.
      Beware that software licenses do not allow public redistribution.
  3. Linux : see 13

Simulator info
Run upsilon.exe (Windows), or upsilon.app in Applications (Mac), or ./simu from epsilon directory (Linux). Press Esc to run KhiCAS (or move to KhiCAS at the end of the Numworks main menu and press Enter). Note that the shift calculator key does not link to the shift key of the calculator, so that you can enter a shifted keystroke from the PC keyboard. Click on the shift key of the simulator or type the PC left alt key (or Mac left opt key) to simulate a shift key. Type Ctrl-P to save a screenshot, note that Linux screenshot is saved in /tmp/epsilon.png, rename it before doing another screenshot. Shift-Ctrl-P will copy the screen to the clipboard on Mac only.

The simulator can emulate user flash with a tar file named scripts.tar. You can create this file with the standard tar program, archiving several Python scripts and/or Xcas sessions (saved with Xcas in the File, Export, HP Prime/Casio). The file khi92.tar may be used as an example, it is proposed when installing KhiCAS on the Numworks hardware calculator, just rename it as scripts.tar and copy to Documents folder on a Mac or in the current directory. The files in the tarfile will be listed in the file menu and may be modified from inside KhiCAS in the simulator.

If you want to have debug support, edit build/defaults.mak and exchange the # at line 22 and 23, and recompile. Note that Python support will not work on x86 if compiled with debug enabled, the nlr* object files should be compiled without -g, this can be achieved by compiling everything in debug mode, then modify defaults.mak, then touch python/port/mpconfigport.h, recompile.

2  First steps

From the main menu (HOME), move the cursor to the χ\chiCAS icon and hit EXE. This opens the “shell” (or history) where you can write most Xcas commands. The Toolbox key will open a menu of important CAS commands, the most commonly CAS commands may be retrieved with fast menus obtained by pressing shift followed by a key of the lower part of the Numworks keyboard (keys without a yellow legend). The application menu (save/restore sessions, ...) is assigned to shift EXE.

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

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

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 1/6 by 1/3 and hit EXE.

The last result is stored in ans(), hit the Ans calculator key to get it. It is recommended to store the result in a variable if you want to reuse it later. There are two ways to store a value in a variable

The most popular Xcas commands are available from shift-1 (algebra) shift-2 (calculus) and shift-3 (plot), from various shortcuts (cf. section 9), or from the cmds (Toolbox), where they is a short online help with an example. Hit Toolbox (cmds), choose a submenu, for example Algebra, hit EXE, move the selection to a command, for example factor. Now Toolbox will display a short help with an example. Hit EXE or Ans 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-5 to modify the fontsize. Type Back 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 plot(sin(x)). Hint: type shift-3 (plot), then EXE.

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, / (orthonormalisation of the frame), * (autoscale). Type Toolbox to modify the graphic window settings Xmin, Xmax, Ymin, Ymax. Type Back to go back to the shell.

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

Hit HOME to leave χ\chiCAS. Variables and history are saved each time you run a command with EXE, they will be restored if you come back to χ\chiCAS.

3  Common CAS commands

3.1  Expand and factor

From Toolbox commands catalog, select Algebra, or type shift-1.

3.2  Calculus

From Toolbox commands catalog, select Calculus, or type shift-2

3.3  Solvers

From Toolbox commands catalog, select Solve.

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\C). Some commands work for integers and polynomials, like gcd and lcm.

3.4.1  Integers

From Toolbox catalog, select Arithmetic, Crypto. Shortcut shift S↔\leftrightarrowD

3.4.2  Polynomials

From Toolbox catalog, select Polynomials.

The default variable is xx, 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.

Polynomials may have coefficients in the rationals (example 2/3*x+1), or floats (example 0.5*x+1), or in ℤ/pℤ\mathbb{Z}/p\mathbb{Z} (example 3*x+5 mod 7) or in a Galois fields (example, call once GF(2,4) to define the finite field with 16 elements with generator g by default, then g^2*x+g+1)

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 vv and ww, then dot will compute the scalar product of vv and ww:

A matrix is a list of lists of the same size. You can enter a matrix element by element using the matrix editor (shift-7 EXE or shift-EXE i). Enter a new variable name to create a new matrix or the name of an existing variable to edit a matrix. The , key may be used to insert a line or column, and the Del key erases the line or column of the selection. Type shift-3 if you want to undo one edition step. For small matrices, it is also convenient to enter them directly in the commandline, for example to define A=(1 2 3 4)A=\left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \end{array}\right) type 

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

onload
or

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 (shift-7 EXE Back), for example:

returns the matrix where coefficient line jj and column kk is 1j+k+1\frac{1}{j+k+1} (beware, indices begin at 0).

Run idn(n) to get the identity matrix of order nn and ranm(n,m,law,[parameter]) to get a matrix with random coefficients with dimensions n,mn,m. for example



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

4  Probabilities and statistics

4.1  Random numbers

From Toolbox catalog, select Probabilities then
(real in [0,1)[0,1)) or
(integer between 1 and nn). 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,pn,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


4.2  Probabilities

From Toolbox catalog, select Probabilities (8). There you will find a few distribution laws: binomial, normald, exponentiald and uniformd. Other distribution must be keyed in or entered with the help of the main catalog (Toolbox EXE): 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 shift-1). Inverse cumulated distribution function follows the same principle with _icdf suffix (shortcut: select cdf in the catalog and press shift-2).

Example : find the centered interval II for the normal law of mean 5000, standard deviation 200, such that the probability to be outside II is 5%

4.3  1-d statistics

The statistic functions are taking lists as arguments, for example 

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

onload
From Toolbox catalog, select Statistics:

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 Toolbox catalog, select Statistics:

5  Graphics

From Toolbox catalog, select Graphics (or type the plot fast menu shortcut shift-3) and choose a graphic command. If you want to have more than one curve on the same graphic, enter several commands with ; as separator.

If a command returns an arc of curve, the trace mode is active by default. 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 shift-2 to get info on the active curve, then EXE to see a table of value.

Press Toolbox to get the curve study menu. From the curve study menu, you can move the pointer to a location, or to a remarkable point: root, horizontal or vertical tangent, inflexion point, intersection with another curve arc. You can also compute an arc length or the area under the curve between pointer and mark.

When a curve is active, the variables x0,x1,x2,y0,y1,y2 are set with the expressions of position, speed and acceleration of x(t)x(t) and y(t)y(t) (for a function curve x=tx=t). When you search a root, horizontal tangent, inflexion, arc length or area under curve, variables are set with the last value.

Press shift-1 for short help on the plotter. There you will learn that you can add/remove a normal vector pointing to the center of curvature (shift-4), and/or the osculating circle and radius of curvature (shift-5) or get the curve study menu by pressing the x,n,θx,n,\theta key.

For display options, you can enter an optional argument at the end of the plot command,

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 pp in a sample of size NN, type from the shell commandline


Test with

Second example : more precise confidence interval for a frequency pp in a sample of size NN:

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 Toolbox, select Script Editor, clear the editor if it is not empty (shift-EXE Clear) and type with the help of test (shift-1), loop (shift-2) for programming structures the following program, in Xcas syntax:

or in Python syntax: 

def f(P,N):
  D=1.96*sqrt(P*(1-P)/N)
  return [P-D,P+D]


Type OK to check the syntax. Once the program is correct, save it (shift-EXE 2), then type Back. 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 nn in Python syntax. Enable Python syntax with shift-EXE 8. Open the Script Editor (shift EXE or Esc from the shell), if there is some old script source, clear it (shift-EXE Clear). Select f(x):= from shift-2 (or from Toolbox, Program, function def), you should get def f(x):. Replace x by n move to the end of the line and press EXE to input a newline. Type Shift-2 then EXE, then j space, then Shift-2 then 3. Type 1,n+1) then shift-4 select :. Type EXE to insert a newline then Alpha SPACE, Toolbox, EXE (1 All), P, R select print with the cursor then type 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 OK. 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 shift-EXE menu (save or save as). You can run it from the commandline by pressing Back 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 shift-EXE, Script Editor, then shift-EXE Clear. Type shift-6 select efface which means clear the screen. You can access to the turtle commands using shift-6 or Toolbox ). For example try avance (forward). Checking the syntax (OK) will display the turtle window moves. You can enter several moves in your script, and organize them inside tests, loops and 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 EXE to insert a newline. ! is in the submenu Programmation_cmds (11, shortcut X,θ,TX,\theta,T) or in the test shift-4 menu. 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

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 Numworks), 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, giacpy. 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 χ\chiCAS (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  The 2d editor.

If a computation returns an expression, it will be displayed in the 2d expression editor. This also happens if you press shift-5 or left arrow key when the selected level is an expression, or if you press shift-5 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→0sin(x)x\lim_{x \rightarrow 0} \frac{\sin(x)}{x} From an empty commandline, type shift-5 (view), you should see 0 selected. Type x then EXE, this will replace 0 by x selected. Type sin, now sin(x)\sin(x) should be selected. Type the division key (above -), you should see sin(x)0\frac{\sin(x)}{0} with 0 selected, type x then EXE, you should now see sin(x)x\frac{\sin(x)}{x} with x (below the fraction) selected. Type the up arrow key, now sin(x)x\frac{\sin(x)}{x} should be selected. Now type shift-2 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 shift-1 8 (oo) EXE.

Example 2 : ∫ 0 +∞1x 4+1dx\int_0^{+\infty} \frac{1}{x^4+1} \ dx From an empty commandline, type shift-5 (view), then shift-2 3 (integrate), you should see: ∫ 0 10dx\int_0^1 0 \ dx with xx selected. We must modify the 1 (upper bound) and the 0 (integrand). Press left arrow key, this will select the integrand 0, type 1/(x^4+1) EXE, then left arrow key shift-1 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 ∫1x 4+1dx\int \frac{1}{x^4+1} \ dx From an empty commandline, type shift-5 (view), then shift-2 3 (integrate), you should see ∫ 0 10dx\int_0^1 0 \ dx Move the selection to the lower bound 0 (right arrow key), type Del, you should see ∫0dx\int 0 \ dx selected. With the down arrow key, select 0, type 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 shift-1 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 shift-left or right arrow key 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 shift-1 2 EXE (factor), decrease the selection to the numerator, type Toolbox EXE (All), type the letters l, n, c, this moves in the catalog to the first command beginning with lnc, select lncollect, EXE and shift-6 (eval).

8  Managing sessions

8.1  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 left shift or right shift. With left shift, the 2d editor is called if the level is an expression, with right shift the level is edited in the text (program) editor. Type Back if you want to cancel modifications, or OK 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 A:=1, all levels below that depend on the value of A will be up to date. If you want to do that several times, it is best to introduce a parameter with the Toolbox Parameter wizzard. Then pressing + or - on the assume(...) or parameter level will modify the value of the parameter (press * or / for faster move).

8.2  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). restart will purge all variables at once (press shift EXE 0 to clear the history and start a fresh new session). assume is a command to make assumptions on a variable, like assume(x>5).

8.3  Archiving and exchanging with Xcas

On the calculator, go back to the history (type Back if you are in the programming editor or the 2d expression editor). From the shift-EXE menu, you can save/restore sessions in the calculator scriptstore. If you save a session that is not too long, a QR code is displayed that can be used to clone the session inside Xcas for Firefox. Session filenames have the _xw.py suffix, they are not real Python scripts, that’s just a trick to be recognized if you want to publish them on Numworks servers. They can be copied to your computer using the connectivity kit from this link, They may be opened with Xcas or Xcas for Firefox. From Xcas, choose the File menu then Numworks From 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).

Python scripts may be saved to the Numworks RAM scriptstore, using the shift-EXE menu. They are shared with the builtin Python application of the Numworks. In addition, you can archive them to the user flash on the Numworks, using shift-EXE 1 0. Scripts stored in the user flash can be accessed readonly from KhiCAS even if they are not copied to the RAM scriptstore.

9  Keyboard shortcuts.

These shortcuts are valid inside the shell and text programming editor. With default configuration:

You can modify fast menus shortcuts by editing the file FMENU.py. Delete the file to reset to default configuration.

In programming editor

10  Remarks

If KhiCAS is inside a long computation, you should be able to interrupt it by pressing Back. If it does not interrupt, try the HOME key. If that does not work, you may have to press the reset button, but beware that this will disable χ\chiCAS on locked Numworks calculators, which means you will have to connect to a computer and reinstall the small launcher application/

The memory available for computations is about 128K with an empty session, it is displayed in the statusline. You can defragment memory (keeping variables and history) by pressing HOME then restarting χ\chiCAS. For a fresh restart, press vars, select restart then EXE, then shift-EXE Clear history, then HOME.

11  χ\chiCAS applications

11.1  MicroPython

You can select the shell interpreter by shift-EXE ln or switch interpreter with shift-) 8. The menu background color of the shell reflects the active interpreter (yellow=MicroPython, magenta or cyan for Xcas native or Xcas Python compatible).

This MicroPython implementation has the following modules: turtle, graphic (both with filled objects), matplotl, arit (integer arithmetic), linalg/numpy (linear algebra, matrices), ulab (scipy compatibility), cas (CAS from Python).

11.2  3d and 4d graphs

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

For fonctions plots from ℂ\mathbb{C} to ℂ\mathbb{C}, run the plot command with argument a complex valued expression of 2 variables (real and imaginary parts) like for example plot((x+i*y)^2-9). For expression depending directly on the complex variable (without requiring real/imaginary part), run the plot3d command, for example plot3d(x^2-9) (the 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 OzOz 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 plotfunc command, for example
plotfunc((x+i*y)^3-1,[x=-2..2,y=-2..2],nstep=500)
will plot z→z 3−1z \rightarrow z^3-1 from a square in the complex plane centered at origin, size 4 with a 500 small reectangles discretization.

Beware, 3d plots require much memory, you should avoid simultaneous plots (polyhedrons, lines, planes or spheres do not require much memory, only plots and objects handled by a plot like cones). You can modify the rendering precision with shift-2 (faster, less precise) or shift-3 (slower, more precise).

If you just want one time a higher precision rendering, type ^ and be patient. If you want to interrupt this rendering, press Back. Use the cursor keys to change the viewpoint, 5 to reset to default viewpoint, and - or + 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.

11.3  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. here for a more complete documentation of the geometry application, with a few screenshots.

11.3.1  Modes, graphical and symbolic view

Type shift-Ans or Toolbox 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 plot(sin(x))) by typing shift-EXE 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 Toolbox to change mode. Type OK to switch to symbolic view or back. For example, type Toolbox 3 to enter point mode, move the pointer and press EXE where you want to create a point. Or type Toolbox 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 OzOz vertical (therefore change viewpoint only with the right and left cursor keys that make a rotation of axis OzOz).

Dynamic geometry howto: switch to pointer mode (Toolbox 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 Back 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 shift-EXE menu, note that the file generated will have a .py extension despite the fact that it is not a Python script. Type Back 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.

Example : circumcircle.
From KhiCAS shell, type shift-EXE 1 then select new figure 2d EXE. Type Toolbox 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 Toolbox 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 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 Toolbox 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 Toolbox 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 circumcircle command: Type Toolbox 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 Back to move to the symbolic view. Move to the script end and add a newline if required (shift EXE). Enter
c:=circonscrit(A,B,C) EXE

3d Example
Type shift-EXE 1 from the shell, then select new 3d figure. Then Back or OK to switch to the symbolic view. Then alpha c shift = Toolbox uparrow twice, select 3D, EXE 5 for cube, Toolbox for help on the cube command, press shift-2 to copy+paste the first example in the symbolic view. You should see
c=cube([0,0,0],[1,0,0],[0,1,0])
Type OK, this display a small cube, type + a few times to zoom in. Then OK to switch back to symbolic view. Type EXE to begin a new commandline. Now we define the vertices of the cube with A,B,C,D,E,F,G,H:= (type alpha shift A , alpha shift B etc.). Then type Toolbox and uparrow 3 times to select Geometry then uparrow 4 times to select sommets EXE, put c as argument to get sommets(c). Type OK to display the cube and the vertices with their names. Type OK again to go back to symbolic view. Then EXE to enter a new commandline, that will define the plane ABC. Type ALPHA P = then shift-2 to open the fast menu lines and 8, this will copy plane(. This command takes 3 points as argument (or a cartesian equation), here A, B, G, P=plan(A,B,G,. We now add a color to the plane with the shift-3 disp fast menu display=filled+green. Check by OK OK. Go to the next line (EXE) and create segment DE ALPHA S = shift-2 select segment command with EXE, type D, E, and give a color
S=segment(D,E,color=cyan) The whole construction should be 

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)

Type OK to display it and use the keypad to change the viewpoint. Type OK or Back to go back to symbolic view and Back to leave the geometry application. Type shift-1 to save the figure if you did not save it from the shift-EXE menu. You can access analytic geometry information from KhiCAS shell, for example equation(P) (Toolbox select Geometry submenu) will return the cartesian equation of the plane PP, or is_orthogonal(P,S) (Toolbox Geometry) will confirm that the plane PP is orthogonal to the segment SS (this should be apparent from 3d rendering).

11.3.2  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 element command in the symbolic view or from Toolbox menu in the graphical view.

Example : quadratic explorer
This example demonstrates how the curve of the parabola of equation y=ax 2+bx+cy=ax^2+bx+c depends on the value of a,b,ca,b,c. Create 3 cursors from Toolbox menu while you are inside the graphical view (for each cursor Toolbox uparrow 4 times EXE EXE). In the symbolic view you should have something like 

a:=element(-1..1)
b:=element(0..1,0.5)
c:=element(-1..1)

then add the parabole graph, from graphical view, type Toolbox 0 (for 10 Curves) and select plot, or from the symbolic view shift 6 5 select plot fill inside the parenthesis with a*x^2+b*x+c (beware, do not forget the *), then EXE. From the graphical view, you should see 3 cursors a, b and c and the corresponding graph. You can now modify the value of a,b,ca,b,c and see how it affects the shape of the parabola. Type Toolbox 2 (pointer mode), then a (or b or c) EXE to select aa (or (bb or cc). 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 line(y=a*x+b) or a trigonometic explorer with plot(sin(a*x+b)).

11.3.3  Measures and legends

From the graphical view, type Toolbox 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 Toolbox 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 legend() command. The first argument 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...)
r:=legend([20,40],"2")
homothety(A,extract_measure(r),B)

11.3.4  Traces

The trace() command lets you keep track of all the positions of a geometric object when the figure is recomputed while moving a point

Example Enveloppe of the normals to a parametric curve (here an ellipse) 

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)

If you change the value of aa (Toolbox 2 for pointer mode, 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
evolute(E,color=red)
You can remove the traces in the graphical view from the shift-EXE menu (last item).

11.4  CAS spreadsheet

The spreadsheet is launched from the application menu (shift-EXE EXE or shift-Ans shortcut).

Unlike pure numeric 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...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 shift-1 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 =, and enter an expression that may contain cell references (characters : and $ are available from shift-3 menu, : 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-arrow key 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 Toolbox menu, or fast menus (shift-1 etc.). 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 shift-6 to display the graphic corresponding to the graphical output of the whole spreadsheet.

12  Copyright and Thanks to.

13  Developer infos.

The simulator installation for the impatient is described in 1.2. The detailled installation procedure follows :

  1. Windows users :
    First method : install WSL or a Linux distribution inside a virtualization software like VirtualBox, and follow Linux instructions.
    Second method : First install Msys2/mingw64 then open from Msys2 menu a mingw64 terminal. In the Options menu of the windows, click keys, check Ctrl-shift-letter shortcut, this way you can paste in the terminal with Ctrl-shift-V. Run : 
    pacman -S git wget mingw-w64-x86_64-gcc mingw-w64-x86_64-freetype mingw-w64-x86_64-pkg-config mingw-w64-x86_64-libusb make mingw-w64-x86_64-python3 mingw-w64-x86_64-libjpeg-turbo mingw-w64-x86_64-libpng mingw-w64-x86_64-imagemagick mingw-w64-x86_64-librsvg mingw-w64-x86_64-inkscape mingw-w64-x86_64-python3-pip mingw-w64-x86_64-python-lz4 mingw-w64-x86_64-libpng gmp mpfr
echo "export PATH=/mingw64/bin:$PATH" >> .bashrc
pip3 install pypng stringcase
    Check that you can compile Epsilon without KhiCAS 
    git clone https://github.com/parisseb/epsilon
cd epsilon
make PLATFORM=simulator
    If everything is ok, run 
    wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfz nwsimu.tgz
    Now
    • either download MPFI unarchive it tar xfj /chemin/vers/mpfi-1.5.4.tar.bz2 configure with ./configure --prefix=/usr run make and make install,
    • or remove -lmpfi in the mkwin script
    run the script
    ./mkwin
    (instead of mk).

    If everything went well, type ./epsilon.exe from epsilon directory. The simulator should display.

  2. Native MacOS compilation is more complicated because we will build a universal binary for 2 architectures arm64 and x86. The first step is to install homebrew and dependencies for both, on a recent Mac (arm64), open a Terminal (type Terminal in launchpad) and copy-paste (with command-C command-V) 
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install numworks/tap/epsilon-sdk
brew install libpng gmp mpfr mpfi
arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
arch -x86_64 /usr/local/bin/brew install libpng gmp mpfr mpfi
    Then 
    git clone https://github.com/parisseb/epsilon
cd epsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfz nwsimu.tgz
./mkmac
ln -sf output/release/simulator/macos/epsilon.app
epsilon.app/Contents/MacOS/Epsilon

    Note that Mac OS Intel users can also install UTM then install a Debian distribution, but Epsilon 22 does not compile on an ARM Mac with UTM.
  3. Now assuming we are on a Debian based Linux, install Epsilon dependencies from a Terminal or Konsole, copy-paste (select commands, press Ctrl-C, then in the Terminal press shift-Ctrl-V simultaneously) the following commands: 
    sudo apt-get install wget build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config python3 python3-pip
sudo apt-get install gcc g++ libgmp-dev libmpfr-dev libmpfi-dev libpari-dev libgsl0-dev libxext-dev libpng-dev libjpeg-dev libreadline-dev libncurses5-dev mesa-common-dev libx11-dev libxt-dev libxft-dev libntl-dev libgl1-mesa-dev libgl-dev libao-dev hevea debhelper libecm1-dev libnauty2-dev libcliquer-dev libresample1-dev libxinerama-dev libsamplerate0-dev libfltk1.3-dev
pip3 install lz4 pypng stringcase
    then copy-paste from a Terminal (or Konsole) 
    git clone https://github.com/parisseb/epsilon
cd epsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfz nwsimu.tgz
./mk
ln -sf output/release/simulator/linux/epsilon.bin simu
    Note that compilation with mk is done in two steps: first a normal compilation of Epsilon that will error (because it does not link to Xcas libraries) then a link step with Xcas libraries, this final step should not error.

    If everything went well, type ./simu from epsilon directory. The simulator should display.

Once the simulator is compiled, you can modify Xcas source code in the src directory, and you can debug the simulator with gdb.

We describe here the external app build process for Epsilon 22/23. χ\chiCAS is a large application (size 4M or 5M), it can not be handled like a “normal” external app as supported by Numworks (upper limit 2.6M because they must be in one of the 2 “slots” of 4M of the Numworks). Moreover, the current protection mechanism of the Numworks erase all external apps at each reset or crash and we do not want to reflash a large app each time this happens. Therefore, χ\chiCAS is divided in 2 files (short version) or 3 files (large version), with a launcher Numworks external app (of size a few K) that will start χ\chiCAS code in the second slot of the Numworks, overwriting one of the two copies of Epsilon firmware. The long version is compiled with data located at the end of slot A, the short version has data located in slot B together with the code.

Source code for the hardware calc is available in the two archives launcher and KhiCAS.

The launcher should not need recompilation. If you really want to modify it, install Numworks EADK then compile by make, this will generates a standard Numworks external app in output/khicas.nwa, this app will install from Numworks external app site. It is linked to Numworks EADK with a few additions for missing functions in order to match the same API as the old External unlocked N0110 API 

  extern "C" void (* const apiPointers[])(void) = {
    (void (*)(void)) extapp_millis,
    (void (*)(void)) extapp_msleep,
    (void (*)(void)) extapp_scanKeyboard,
    (void (*)(void)) extapp_pushRect,
    (void (*)(void)) extapp_pushRectUniform, // 4
    (void (*)(void)) extapp_pullRect,
    (void (*)(void)) extapp_drawTextLarge,
    (void (*)(void)) extapp_drawTextSmall,
    (void (*)(void)) extapp_waitForVBlank, // 8
    (void (*)(void)) extapp_clipboardStore,
    (void (*)(void)) extapp_clipboardText,
    (void (*)(void)) extapp_fileListWithExtension,
    (void (*)(void)) extapp_fileExists, // 12
    (void (*)(void)) extapp_fileErase,
    (void (*)(void)) extapp_fileRead,
    (void (*)(void)) extapp_fileWrite,
    (void (*)(void)) extapp_lockAlpha, // 16
    (void (*)(void)) extapp_resetKeyboard,
    (void (*)(void)) extapp_getKey,
    (void (*)(void)) extapp_restorebackup,
    (void (*)(void)) extapp_erasesector, // 20
    (void (*)(void)) extapp_writememory,
    (void (*)(void)) extapp_inexammode,
    (void (*)(void)) extapp_isalphaactive, 
    (void (*)(void)) extapp_kbdstatus,  // 24
    (void (*)(void)) nullptr,
  };

This array address is passed as a parameter to extapp_start in khib/startup.c
uint32_t _extapp_start(const uint32_t api_version, const void * api_base, void * heap, const uint32_t heap_size);
this function is responsible for copying these parameters, including the apiPointers array, used by KhiCAS C-SDK in khib/api.c, initialize static RAM, and call extapp_main in khib/main.c, this function calls ext_main that calls caseval("*") which is a convention in Giac/Xcas library to start the interactive shell.

KhiCAS can be compiled in 2 versions : the short version without full online help will fit in Numworks 2nd slot starting at 0x90400000, and the long version that generates two binary files, the first one starting at 0x90260000 ending at 0x903f0000 (read-only data), and the second one starting at 0x90400000 (code). Binaries are stored in a tar archive file, where script files can be added, that will be accessible readonly on the calculator. Run ./mkb or ./mkab. An additionnal tarfile can be sent to the calc at 0x90200000 with data/scripts that can be read or modified from the calculator. There are 4 ld scriptfiles (2 versions and 2 calculator models, where N0110 and N0115 are identical) n01?0.ld, n01?0ab.ld. Compilation is done by pair, with target khi110b.tar khi120b.tar or khi110ab.tar khi120ab.tar with compile commandline g++ define -DNUMWORKS_SLOTB or -DNUMWORKS_SLOTAB. Static RAM is located 16K before the end of RAM for external apps (13K are used now), and the launcher allocates 128K for KhiCAS malloc heap.

Memory modem

Local dfu command to flash without Internet access 

dfu-util -i 0 -a 0 -s 0x90400000 -D khi120b.tar
    (short) or (long)
dfu-util -i 0 -a 0 -s 0x90400000 -D khi120ab.tar
dfu-util -i 0 -a 0 -s 0x90260000 -D khia
    script exemples:
dfu-util -i 0 -a 0 -s 0x90200000 -D khi92

In order to reflash the launcher app locally, get it once, when KhiCAS is visible in the Numorks home menu, on a N0120: 

#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90190000:0x10000:force -U sector19

on a N0110/N0115: 

#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90180000:0x10000:force -U sector18

then reflash a N0120 with: 

#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90190000 -D sector19

and a N0110/N0115 

#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90180000 -D sector18

Remarks :

  

Back to Giac/Xcas homepage.