Next: Undo Tutorial, Previous: RPN Tutorial, Up: Basic Tutorial

#### 3.1.2 Algebraic-Style Calculations

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:  34 + 2 b
             .                 .

          ' 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:  2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
             .

          ' 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 + 5 => 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.