Next: Undo Tutorial, Previous: RPN Tutorial, Up: Basic Tutorial [Contents][Index]

If you are not used to RPN notation, you may prefer to operate the
Calculator in Algebraic mode, which is closer to the way
non-RPN calculators work. In Algebraic mode, you enter formulas
in traditional ‘`2+3`’ notation.

**Notice:** Calc gives ‘`/`’ lower precedence than ‘`*`’, so
that ‘`a/b*c`’ is interpreted as ‘`a/(b*c)`’; this is not
standard across all computer languages. See below for details.

You don’t really need any special “mode” to enter algebraic formulas.
You can enter a formula at any time by pressing the apostrophe (`'`)
key. Answer the prompt with the desired formula, then press `RET`.
The formula is evaluated and the result is pushed onto the RPN stack.
If you don’t want to think in RPN at all, you can enter your whole
computation as a formula, read the result from the stack, then press
`DEL` to delete it from the stack.

Try pressing the apostrophe key, then `2+3+4`, then `RET`.
The result should be the number 9.

Algebraic formulas use the operators ‘`+`’, ‘`-`’, ‘`*`’,
‘`/`’, and ‘`^`’. You can use parentheses to make the order
of evaluation clear. In the absence of parentheses, ‘`^`’ is
evaluated first, then ‘`*`’, then ‘`/`’, then finally
‘`+`’ and ‘`-`’. For example, the expression

2 + 3*4*5 / 6*7^8 - 9

is equivalent to

2 + ((3*4*5) / (6*(7^8))) - 9

or, in large mathematical notation,

3 * 4 * 5 2 + --------- - 9 8 6 * 7

The result of this expression will be the number *-6.99999826533*.

Calc’s order of evaluation is the same as for most computer languages,
except that ‘`*`’ binds more strongly than ‘`/`’, as the above
example shows. As in normal mathematical notation, the ‘`*`’ symbol
can often be omitted: ‘`2 a`’ is the same as ‘`2*a`’.

Operators at the same level are evaluated from left to right, except
that ‘`^`’ is evaluated from right to left. Thus, ‘`2-3-4`’ is
equivalent to ‘`(2-3)-4`’ or *-5*, whereas ‘`2^3^4`’ is equivalent
to ‘`2^(3^4)`’ (a very large integer; try it!).

If you tire of typing the apostrophe all the time, there is
Algebraic mode, where Calc automatically senses
when you are about to type an algebraic expression. To enter this
mode, press the two letters `m a`. (An ‘`Alg`’ indicator
should appear in the Calc window’s mode line.)

Press `m a`, then `2+3+4` with no apostrophe, then `RET`.

In Algebraic mode, when you press any key that would normally begin
entering a number (such as a digit, a decimal point, or the `_`
key), or if you press `(` or `[`, Calc automatically begins
an algebraic entry.

Functions which do not have operator symbols like ‘`+`’ and ‘`*`’
must be entered in formulas using function-call notation. For example,
the function name corresponding to the square-root key `Q` is
`sqrt`

. To compute a square root in a formula, you would use
the notation ‘`sqrt( x)`’.

Press the apostrophe, then type `sqrt(5*2) - 3`. The result should
be ‘`0.16227766017`’.

Note that if the formula begins with a function name, you need to use
the apostrophe even if you are in Algebraic mode. If you type `arcsin`
out of the blue, the `a r` will be taken as an Algebraic Rewrite
command, and the `csin` will be taken as the name of the rewrite
rule to use!

Some people prefer to enter complex numbers and vectors in algebraic form because they find RPN entry with incomplete objects to be too distracting, even though they otherwise use Calc as an RPN calculator.

Still in Algebraic mode, type:

1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1) . 1: (1, -2) . 1: 1 . . . (2,3) RET (1,-2) RET * 1 RET +

Algebraic mode allows us to enter complex numbers without pressing
an apostrophe first, but it also means we need to press `RET`
after every entry, even for a simple number like ‘`1`’.

(You can type `C-u m a` to enable a special Incomplete Algebraic
mode in which the `(` and `[` keys use algebraic entry even
though regular numeric keys still use RPN numeric entry. There is also
Total Algebraic mode, started by typing `m t`, in which all
normal keys begin algebraic entry. You must then use the `META` key
to type Calc commands: `M-m t` to get back out of Total Algebraic
mode, `M-q` to quit, etc.)

If you’re still in Algebraic mode, press `m a` again to turn it off.

Actual non-RPN calculators use a mixture of algebraic and RPN styles.
In general, operators of two numbers (like `+` and `*`)
use algebraic form, but operators of one number (like `n` and `Q`)
use RPN form. Also, a non-RPN calculator allows you to see the
intermediate results of a calculation as you go along. You can
accomplish this in Calc by performing your calculation as a series
of algebraic entries, using the `$` sign to tie them together.
In an algebraic formula, `$` represents the number on the top
of the stack. Here, we perform the calculation
‘`sqrt(2*4+1)`’,
which on a traditional calculator would be done by pressing
`2 * 4 + 1 =` and then the square-root key.

1: 8 1: 9 1: 3 . . . ' 2*4 RET $+1 RET Q

Notice that we didn’t need to press an apostrophe for the `$+1`,
because the dollar sign always begins an algebraic entry.

(•) **Exercise 1.** How could you get the same effect as
pressing `Q` but using an algebraic entry instead? How about
if the `Q` key on your keyboard were broken?
See 1. (•)

The notations `$$`, `$$$`, and so on stand for higher stack
entries. For example, `' $$+$ RET` is just like typing `+`.

Algebraic formulas can include *variables*. To store in a
variable, press `s s`, then type the variable name, then press
`RET`. (There are actually two flavors of store command:
`s s` stores a number in a variable but also leaves the number
on the stack, while `s t` removes a number from the stack and
stores it in the variable.) A variable name should consist of one
or more letters or digits, beginning with a letter.

1: 17 . 1: a + a^2 1: 306 . . . 17 s t a RET ' a+a^2 RET =

The `=` key *evaluates* a formula by replacing all its
variables by the values that were stored in them.

For RPN calculations, you can recall a variable’s value on the
stack either by entering its name as a formula and pressing `=`,
or by using the `s r` command.

1: 17 2: 17 3: 17 2: 17 1: 306 . 1: 17 2: 17 1: 289 . . 1: 2 . . s r a RET ' a RET = 2 ^ +

If you press a single digit for a variable name (as in `s t 3`, you
get one of ten *quick variables* `q0`

through `q9`

.
They are “quick” simply because you don’t have to type the letter
`q`

or the `RET` after their names. In fact, you can type
simply `s 3` as a shorthand for `s s 3`, and likewise for
`t 3` and `r 3`.

Any variables in an algebraic formula for which you have not stored values are left alone, even when you evaluate the formula.

```
1: 2 a + 2 b 1: 2 b + 34
. .
' 2a+2b RET =
```

Calls to function names which are undefined in Calc are also left alone, as are calls for which the value is undefined.

```
1: log10(0) + log10(x) + log10(5, 6) + foo(3) + 2
.
' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) RET
```

In this example, the first call to `log10`

works, but the other
calls are not evaluated. In the second call, the logarithm is
undefined for that value of the argument; in the third, the argument
is symbolic, and in the fourth, there are too many arguments. In the
fifth case, there is no function called `foo`

. You will see a
“Wrong number of arguments” message referring to ‘`log10(5,6)`’.
Press the `w` (“why”) key to see any other messages that may
have arisen from the last calculation. In this case you will get
“logarithm of zero,” then “number expected: `x`

”. Calc
automatically displays the first message only if the message is
sufficiently important; for example, Calc considers “wrong number
of arguments” and “logarithm of zero” to be important enough to
report automatically, while a message like “number expected: `x`

”
will only show up if you explicitly press the `w` key.

(•) **Exercise 2.** Joe entered the formula ‘`2 x y`’,
stored 5 in `x`

, pressed `=`, and got the expected result,
‘`10 y`’. He then tried the same for the formula ‘`2 x (1+y)`’,
expecting ‘`10 (1+y)`’, but it didn’t work. Why not?
See 2. (•)

(•) **Exercise 3.** What result would you expect
`1 RET 0 /` to give? What if you then type `0 *`?
See 3. (•)

One interesting way to work with variables is to use the
*evaluates-to* (‘`=>`’) operator. It works like this:
Enter a formula algebraically in the usual way, but follow
the formula with an ‘`=>`’ symbol. (There is also an `s =`
command which builds an ‘`=>`’ formula using the stack.) On
the stack, you will see two copies of the formula with an ‘`=>`’
between them. The lefthand formula is exactly like you typed it;
the righthand formula has been evaluated as if by typing `=`.

2: 2 + 3 => 5 2: 2 + 3 => 5 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b . . ' 2+3 => RET ' 2a+2b RET s = 10 s t a RET

Notice that the instant we stored a new value in `a`

, all
‘`=>`’ operators already on the stack that referred to ‘`a`’
were updated to use the new value. With ‘`=>`’, you can push a
set of formulas on the stack, then change the variables experimentally
to see the effects on the formulas’ values.

You can also “unstore” a variable when you are through with it:

```
2: 2 + 3 => 5
1: 2 a + 2 b => 2 a + 2 b
.
s u a RET
```

We will encounter formulas involving variables and functions again when we discuss the algebra and calculus features of the Calculator.

Next: Undo Tutorial, Previous: RPN Tutorial, Up: Basic Tutorial [Contents][Index]