Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.

com/gbl08ma/eigenmath/wiki/Usage-instructions

Explore Features Enterprise Blog Sign up Sign in

gbl08ma / eigenmath Watch 1 Star 7 Fork 2

Usage instructions
Gabriel edited this page on 19 Aug 2014 · 2 revisions

Note that this kind-of-tutorial focuses on how to use the user interface and features
specific to this port, and not Eigenmath in general. For detailed instructions on how to
input commands, what functions do and how results are presented, the Eigenmath manual
will serve you better.

The first time you select Eigenmath from the calculator's Main Menu, you'll see a screen
with the text "Welcome to Eigenmath", "To see more options, press Shift then Menu", with
a blue arrow below, a vertical line after it and a otherwise empty line. Clone this wiki locally

Clone in Desktop

The blue arrow is meant to indicate a command entry line (where you'll type what you
want Eigenmath to do), and the vertical black line is the cursor (it doesn't blink). To type,
do as you normally would: press the keys on the keyboard, use [Shift] and [Alpha] to
modify the key meaning, and use [F5] to switch between upper and lower-case alpha
mode.

Basic Operation
If this is your first time using Eigenmath, you should see the Eigenmath manual.
Everything except instructions related to the user interface (which is considerably different
in the desktop versions) will apply to this port. Because of this, you should give it a quick
read.

You can use Eigenmath as a simple calculator - type 2+3 then press [EXE], the result will
appear along with another line for command entry:

1 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

The output will be pretty-printed whenever applicable, however, command input takes
place in a single line, not pretty-printed. If you want to calculate the square root of 7, you
can either type sqrt(7) character by character, or use the square root key as a shortcut
for typing sqrt( , after which you'll only need to press [7], [)] and [EXE]:

What's different in Eigenmath, is that you can also use variables to do symbolic
computation with them, unlike with Casio's non-symbolic system where variables always
correspond to a number:

As you probably understood from reading the Eigenmath manual, you can use a set of
commands to manipulate the symbolic expressions. Most commands will treat x as the
main variable, unless otherwise specified. Variables and commands are case-sensitive,
which means typing "simplify" is different from "SIMPLIFY", and "x" means a different
variable than "X".

So, to calculate the derivative of the last expression with regards to x, use d(last) . last
is a special variable that always holds the result of the last successful computation.

(as you see, when expressions do not fit on screen they will not be pretty-printed, but
rather shown linearly)

When certain keys, like [+], [-], [*], [^] and [/], are pressed right after a result is displayed,
last will be automatically inserted before them, because the software understands you
are trying to operate on the last result.

2 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

Therefore, a key sequence like this...

[1], [2], [+], [4], [EXE], [+], [5], [EXE], [*], [7], [EXE], [x^2], [EXE]

...results in this:

(you can insert last at any time by pressing the same keys you'd press to type Ans on
Run-Matrix)

If you don't want to insert "last" automatically, start by pressing some key other than the
"magic" ones, such as [DEL] or [AC/ON], before typing.

Also note that, by default, Eigenmath does not operate with scientific notation or decimal
numbers; converting a number to scientific notation or decimal form results in an internal
loss of precision for Eigenmath (the conversion is one-way and lossy). Similarly, numbers
entered in decimal form will not and can not be converted to a fraction representation, so
for better results, use fractions if possible.

The float command (insert it with the [F<>D] key) can be used to convert a number into
its decimal/scientific notation form.

The ! symbol is used to express the factorial (n! = n(n-1)(n-2)..., 5!=5432*1) of an integer;
you can insert this symbol with the [->] key above [AC/ON] - this key was chosen because
it had no utility in Eigenmath, otherwise.

3 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

Operating with variables and custom functions (user

symbols)
Variables and custom functions are generally called user symbols. They don't need to be
single-letter: most combinations of letters and numbers that start with a number, are
interpreted as a single symbol. Be careful: if you type "ab", it doesn't mean a*b, but a
variable (or function) called "ab"! Additionally, as explained before, symbols (user-defined
and built-in) are case-sensitive.

Before, we said that variables are interpreted symbolically, but you can still assign a value
to a variable, and reset the variable to its empty meaning later:

In the example above, we start by assigning a value of 34 to the variable a , then

calculate using that value. The quote command returns the unevaluated meaning of a
variable, and can be used for more than clearing symbols:

As you see, in this case the quote command makes the value of C be retrieved whenever
CplusFive is evaluated. Had we just said that CplusFive = C + 5 , CplusFive wouldn't
have changed value when C changed.

You can also define custom functions, that return values and take a number of arguments.
Custom functions can be chained and mixed with built-in functions.

Of course, after some usage, variables and functions start to get into strange states,
because you'll certainly forget to reset them to the "empty" state when you no longer need

4 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

them. Furthermore, after using a handful of custom symbols it's a pain to clear them all,
one by one. The "clear" command clears all user symbols, plus console scrollback, in one
go.

Using the console

The console is the black-text-on-white-background screen you see when you open
Eigenmath, and where commands are typed and their result is displayed. Now you ask:
but that's what I've been seeing all this time?! Indeed you have been using the console,
but there's more to it than you know.

By now, we have already done a lot of things on the console, haven't we? (If not, execute
something like 235! or 5123^342 just to fill the console so we can proceed.)

The text on the console scrolls up and goes out of sight as more things are displayed. But
a big part of it can be displayed again if you wish. First press the [Shift] key, then press the
Up "replay" key. You should see a screen similar to the following:

See that message at the top? Press the Up or Down "replay" keys (and no other keys) to
scroll up and down. The little rectangle to the right is the scroll bar, indicating what part of
the console you are seeing relative to the current bottom.

To exit scrolling mode, press any key other than the Up or Down keys, like [EXIT] or the
Left or Right key. The console will jump to the current command input.

There's more past to bring back! Remember that long command you just typed, but was a
bit off and had a syntax error? Or that long command that took ages to type? There's a
good chance you can bring it back to edit and execute it again! Just press the Up key (this
time, without [Shift]), to recall the last command. Keep pressing for older commands. You
can also press the Down key to recall a more recent command, until you are in the newest
(not yet executed) line.

5 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

Also, you probably already figured this by now, but you can move the cursor to edit the
command at any position, using the Left and Right keys. When the command is too long
to fit on the screen, pink arrows will be shown in the direction of the text that's hidden.

There's also an advanced console feature, which allows for entering long commands in
multiple steps:

To use it:

Enter part of the command you want to execute;

Press [Shift] then [EXE] - a new line with a different blue arrow will appear;
Type the part of the command that follows;
Repeat the two previous steps as needed;
When done, press [EXE], without [Shift], to execute the concatenation of all the partial
commands.

Using the clipboard

You can paste from the calculator clipboard into the console, by pressing [Shift] then [9] as
usual.

To copy the last result into the clipboard, press [Shift] then [8], select "Last result", and a
confirmation message will appear on the status area.

To copy or cut things in the current command entry, press [Shift] then [8] and select

6 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

"Current command". A traditional text entry will appear, containing the current command -
just use [Shift] then [8] again to copy or cut, as usual. Any changes you make to this entry,
including text deletion and cutting, will be reflected on the console entry. When you're
done copying, cutting or editing what you want, press [EXIT] to return to the console.

Function catalog
This port features a function catalog organized by categories, with a short description for
each command. You can access it by pressing [Shift] then [Menu] and selecting the
appropriate option, or directly from the console, as you'd normally access the OS function
catalog: by pressing [Shift] then [4]. A list of categories will appear:

You can choose to see all commands, or a specific category. After selecting an option,
press [EXE] or [F1] for it to be inserted at the current cursor position, or press [F6] to see
its help text:

Press [EXIT] to close this screen and go back to the command list. To switch categories,
press [EXIT] once, and then again to exit without inserting a function.

Note: menus on Eigenmath, including the catalog menus, don't support jumping to a
certain letter by pressing the respective keyboard key. There's, however, other way to
quickly navigate menus: the keys [1] through [0] select options 1 to 10, and the keys
above, from [xOt] to [->], select options 11 to 22. If you want to quickly insert, for example,
rationalize( , press, from the console, the following key sequence:

[Shift], [4], [9], [a b/c]

...in the end, you should be back in the console with rationalize( inserted at the cursor
position. Pressing just four keys, you inserted text that would otherwise require over a
dozen of presses!

Graph plotting
If you have used Eigenmath before, telling you that the draw command is supported
should be enough to get you going. If not, then you should read the relevant Eigenmath

7 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

manual section.

To demonstrate the feature, start by executing draw(x^2-2) . After a waiting period, the
graph for the expression y=x^2-2 should appear:

You can use the "replay" directional keys to move the graph in any direction, as you would
do on the built-in "Graph" mode. Use the [+] and [-] keys to zoom in and out (again, as on
the "Graph" mode).

As explained in the Eigenmath manual, the view window can be adjusted numerically by
setting the symbols xrange , yrange and trange , but you can also choose from three
presets by pressing, on the graph screen, [F3] followed by [F1], [F2] or [F3].

To exit the graph screen, just press [EXIT], and you should be back in the console.

In conformity with most commands, executing draw with no arguments draws the
previous result. If the previous result is not drawable in the real plane (for example, if it
contains complex numbers or is otherwise hard to map to a real plot), the graph screen
will still display, but nothing will be drawn on it.

Feel free to try the more complex draw examples from the Eigenmath manual!

You can draw multiple graphs at once, using the do command, like this:
do(draw(x),draw(exp(x)),draw(sin(x)))

Each expression will be drawn in a different color.

Aborting execution
Certain expressions and scripts (which we'll explain later) can take a long time to execute.
If a computation is taking more time than what we're willing to wait, press [AC/ON] to
break execution.

Stopping may not be instant, but after some time you'll see something like this:

8 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

Stop: esc key and Stop: escape key stop are two messages that mean the same thing:
execution was aborted by the user. Which one appears depends on what Eigenmath is
doing at the time.

The [AC/ON] key can also be used to stop the drawing of graphs, with the advantage that
the graph still gets displayed, in an incomplete form (usually a low-density points cloud):

This can be useful for quickly changing the view window, without having to wait for each
change to be completely drawn.

Script running and recording

Because it's easier to explain the scripting feature when we actually have some script to
execute, let's start by explaining how to create a script.

On the console, start by pressing [Shift] then [Menu] and selecting "Record Script", or type
record (in lower-case) and press [EXE].

Now every command typed will be recorded, including those with syntax errors, up to a
maximum of 200 commands. Commands are executed as usually.

To demonstrate the feature, let's type the following three commands:

print("This is a script.")
a=2+34

9 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

a*3

Finally, execute record again or press [Shift] then [Menu] and select "Stop Recording".
You will be asked for a name for the script, let's just call it "test":

Don't forget to press [EXE]. The script will be created in the storage memory with the
name "test.txt".

To better demonstrate the scripting feature, you should execute clear now. Press [Shift]
then [Menu] and select "Load Script". A file browser for the storage memory will appear,
select test.txt - this is the script we just created. This is what you'll see:

See how every command we typed when recording got executed? Also note how the
commands we entered don't get displayed. This allows for fine control of what is to be
displayed. Any symbols set by the script are still available. Our script set the variable a ,
so let's check it:

You can rename and organize your scripts in the Storage Memory by connecting the
calculator to the computer via USB, or by using an add-in with a file manager, such as
Utilities. Scripts can also be written and edited on a computer, and some of the Eigenmath
scripts you find on the Internet will run just fine (the problems with those that don't, will be
slowness or lack of memory).

Startup script and key customization

10 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

You can specify a script to be run whenever Eigenmath is open and there's no session
saved, or when clear is executed. This is good for specifying custom functions and
constants.

Let's say you want to have a custom function always available, that returns the logarithm
of a number in a certain base. You'd normally define such a function by executing
something along these lines:

logab(a,b)=log(b)/log(a)

Now, how can we make logab always available, even after clear ing? It's simple, just put
it in the startup script:

Connect the calculator to the computer (or use an add-in like Utilities) and create the
folder "@EIGEN" (without the quotes), if it doesn't exist already.
Create, or copy into that folder, a file called "eigensup.txt" (without the quotes). For
the purposes of this demonstration, that text file should contain
logab(a,b)=log(b)/log(a) .
Save the file, safely disconnect the calculator (or leave the add-in you used to create
the folder) and open Eigenmath.
Execute logab(20,4) . Your logab function should work as expected!

Add more things to the startup script, by putting the expressions you'd like to execute
automatically each in their line, as with a normal script.

You can also set actions for keys which usually do nothing, so that they directly execute
some Eigenmath expression. Look at the suggested eigensup.txt script to see how it's
done. Basically, the following must be done (you can execute this step by step on the
console, and see things change):

The variable prizmUIhandleKeys must be set to 1;

The function prizmUIkeyHandler(k,s) must be defined. k will receive a code for the
key pressed, and s will receive the keyboard modifier code (Shift, Alpha, etc.). You
can see the codes by defining this function to print the codes, or by not defining it
(and whenever the UI executes it, it will be printed on the screen together with the
codes).
Optionally, you can set labels for the function keys (except [F5]), by setting the
variables prizmUIfkey1label , prizmUIfkey2label , prizmUIfkey3label ,
prizmUIfkey4label and prizmUIfkey6label to the code of the label you want to show
(a positive integer). You can find the codes by trial-and-error, or by using an add-in
like INSIGHT.

The suggested eigensup.txt assigns, for example, the [F3] key to the "clear" command
and the [F6] key to the "draw" command.

Usage as a eActivity strip

Eigenmath can be launched from the Main Menu, or as an eActivity strip. Strips are things
you can insert into eActivity documents and which allow for launching functions external to
eActivity, including some add-ins.

You can insert strips into a eActivity document by pressing [F2] - STRIP - when editing the
document. To open a strip, press [EXE] while it is selected. To switch between the
eActivity document and the open strip, press [Shift] and then the [->] key above [AC/ON].

11 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

When you open a Eigenmath strip, you'll be presented the same screen as when running
the add-in for the first time, or when session persistence is disabled. This is because
session persistence doesn't work on strips.

You can use Eigenmath as usual, but once you leave the add-in (by selecting another
strip, or by closing the eActivity) everything you do will be forgotten. The only persistent
thing in the Eigenmath strip is the "strip script", which is a script that can be linked with the
strip and will run every time it is opened.

Let's say we want to run the script we created in the previous section, test.txt, every time
the strip is open. Open the Eigenmath strip, press Shift then Menu, select "Set Strip
Script", read the message and select the script we created.

If all went well, the message "Script set successfully" will be displayed.

Now, let's test our setup. Press [Shift] and the arrow key above [AC/ON], select our
Eigenmath strip, and press [EXE] - this will restart the strip:

And there it is, our script ran. You can now use Eigenmath as usual and play around with
the script result through any symbols it may have set, as if you had run the script
manually.

As explained on the screen that appears when selecting a strip script, the script is stored
inside the eActivity (more precisely, inside the strip), which means that it will work on any
calculator, even if the script is not present in the storage memory. You should keep this in

12 de 13 22/05/2015 15:26
Usage instructions · gbl08ma/eigenmath Wiki · GitHub https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions

mind, because if you edit the script in the storage memory, changes will not apply to the
scripts inside the strips! You'll need to update them individually on a per-strip basis, doing
as you normally would to select a strip script.

Disabling session persistence

Press [Shift] then [Menu], and uncheck the "Save Session" option. You can enable it back
at any point in the future.

Session persistence (or its setting) is not available when running as a eActivity strip.

© 2015 GitHub, Inc. Terms Privacy Security Contact Status API Training Shop Blog About

13 de 13 22/05/2015 15:26