
Although the second solution is longer, the last 3 steps illustrate the
dropping action of the stack as two-number operations are performed.  Also
note that due to the automatic stack lift it was necessary to press ENTER^
[ENTER] only once in the first solution.

The automatic stack drop can be used to insert a constant into a problem.
Suppose you deposit $1800 in a savings account which pays a simple 8% annual
interest.  How much will you have at the end of one year?   two years ?
three years ?   six years ?

To answer each question requires multiplying the previous year's result by the
constant 1.08.  Place 1.08 in the Y, Z, and T registers and place 1800 in the
X-register.

          Key [1] [.] [0] [8] [ENTER] [ENTER] [ENTER] [1] [8] [0] [0]

Press [*] to get the answer for one year.  "$1944."

The number 1.08 is duplicated from the T-register each time the stack drops
and hence does not have to be re-entered.  1.08 always remains in the top
three stack registers.

Press [*] a second time to get the two-year answer. "$2099.52"

Press [*] a third time to get the 3-year answer.  "$2267.4816"

Press [*] three more times in succession to get the 6-year answer
$2856.3737813  in X.

The superiority of RPN is most apparent in performing chain calculations.  As
a matter of fact, the speed and simplicity of RPN is best illustrated in the
longest and most complicated problems.

The following rules are usually sufficient to solve any problem.  The order of
execution is usually unimportant but it is always best to begin in the middle
of an expression and work outward.


     1. Key in the next number.

     2. If any operations can be performed, perform them and go to step 1.

     3. If no operation can be performed then press ENTER^ and go to step 1.


Chain calculations with RPN are that simple!


                                                                       page 21


There are no special hierarchies or parenthesis keystrokes that must be
remembered.  Simply begin in the middle and separate consecutive number
entries (if any) by ENTER^.  The operational stack will keep track of
everything else for you and automatically position intermediate results as
they are needed.

Those not already familiar with RPN who feel somewhat intimidated by it are
certainly not aware that the above three steps give RPN its simplicity.  It is
certainly true that it takes some time and practice to learn RPN.  But once
mastered you will really appreciate its simple elegance.

At this point we are finished with our introduction to RPN.  When we finish
the rest of the commands in the display screen then we will be finished with
the entire discussion of the Manual Mode.


                             KEYBOARD COMMANDS


For each RPN function previously introduced we always gave its name in the
syntax of the RPN language.  Our reason for doing so was twofold.  First, you
will use those designators when you write programs in the RPN language.
Second, the Manual Mode contains a universal keyboard command that allows you
to execute any language instruction.

We will choose two keyboard commands and show they may be executed in two
different ways.  The  X<>Y  function can be executed in Manual Mode by simply
pressing key [X].  An alternative is to press key [K] first.  When you press
[K] the cursor drops to a blank line under the Current Command designator.
RPNDEMO is now waiting for you to key in the full name of any instruction to
be executed.  We will key in "X<>Y".

For example, key  [K] [X] [shift]+[,] [shift]+[.] [Y] [ENTER]

When using key [K] to key in a language command you must press [ENTER] to
complete your instruction.  If the line entered does not conform to the proper
syntax of any language statement then your command will be replaced with what
is called a NOP.  NOP stands for "no operation" which is in fact a useful
language element.  It doesn't do anything.

Other languages may generate annoying syntax errors.  RPN simply executes a
NOP when it can't determine what to do.  In some programming situations
involving conditional branching it is essential to have an instruction like
NOP that doesn't do anything.


                                                                       page 22

As a second example let's store PI in R25.  If you recall this was the first
example instruction given in this manual.  This time we will do it another
way.  Press [P] to get the number PI in X.  Then press [K] and key in the
complete store command as:

                     [S] [T] [O] [SPACE] [2] [5] [ENTER]

You should find  [K] [S] [T] [O] [SPACE] [2] [5] [ENTER] equivalent to
[S] [2] [5].

Why use a keyboard command like [K] when you can execute a desired function
by pressing the corresponding keyboard key ?  The answer is of course that for
all the assigned keyboard functions you probably wouldn't use [K].  But the
RPN language contains many instructions that are not assigned to particular
keys.

In fact, the RPN language contains so many instructions that it would be
awkward if not impossible to assign all of them to special keys.  And if each
key executed a different instruction you would then have the additional
burden of remembering which key was associated with which function.  So only
the basic functions which appear in the menus on the right side of the screen
have been associated with particular keys.

After you learn most of the language commands you will really appreciate the
[K] key which can be used to execute any function.  You shouldn't find
remembering the language instructions to be much of a problem after you learn
the basic ones.  In fact, you can use the [K] key to test your knowledge of
the language syntax.  Each NOP you generate (unless you key in NOP itself)
means the command you gave wasn't valid.


                             OTHER MODES


The lower-right corner of the display screen shows five special operations
that can be performed from the Manual Mode.  The [K] command just described
is one of these.  Another is [H].  Pressing [H] in Manual Mode causes several
help screens of information about RPNDEMO to be displayed.  The first help
screen is for the program editor and the last 3 screens explain the entire
language syntax.  If you can't remember a function then press [H] for help
and look for it in one of these help screens.

Two other commands are related to the Program Mode.  Pressing [ALT]+[P] causes
you to leave the Manual Mode and enter the Program Mode.  The next section of
this manual describes the Program Mode in detail.


                                                                       page 23


The other option is to press [ALT]+[R] which causes the current program to
start running from the current line number in the program.  If you look at
the display screen just above the Current Command designator you should see a
3-digit number.  This number is set to "001" when RPNDEMO is first run but it
can change to any line in the current program depending on whether you edit
the program or run the program.

On most computers this line number is called the program counter.  It's
purpose is to designate the current position or next instruction line in the
program that will be executed if you press [ALT]+[R].  During a running
program the 3-digit number is replaced by the blinking designator "PRGM" to
indicate a program is running.  When the program stops running the 3-digit
line number the program stopped at will be shown.

Although you can only change this line number in Program Mode, it is
convenient to be able to start to run a program from Manual Mode.  For
example, if a running program stops for input from the keyboard you can press
[ALT]+[R] to start the program running again.  Otherwise, you would normally
begin running a program from the Program Mode.

The final command allows you to quit the RPNDEMO program altogether.  To do
this press the control key marked [CTRL] and while holding down this key press
key [Q] and then release both key [Q] and the [CTRL] key.  You should then
gracefully return to the operating system and the active disk drive should be
the same as the active or current disk drive when you started the RPNDEMO
program.



                              MANUAL MODE SUMMARY


At this point we are finished describing all of the Manual Mode functions and
keyboard operations.  We summarize the Manual Mode by grouping all of the
functions into the categories of one-number and two-number mathematical
functions, stack operations, miscellaneous, and other modes.  Listed below are
the keys for each mode and a description of their corresponding functions.
Where possible a page reference in this manual is also given.

The column under RPN SYNTAX is blank if there is no corresponding program
language command.  Otherwise the exact form of the Program Mode syntax is
shown.  These function designators are important to know since they are the
commands you will write when you start programming.


                                                                       page 24


MISCELLANEOUS:

Key   RPN SYNTAX      Description            Page
---   ----------      -----------            ----

[0]   [1] [2]         number entry keys      11
[3]   [4] [5]         number entry keys      11
[6]   [7] [8]         number entry keys      11
[9]   [.]             number entry keys      11
[E]                   enter exponent key     11
[N]   CHS             Change Sign            11
[A]                   Angle Mode change      18
[P]   PI              number 3.1415926536    9,12
[S]   STO             Manual Mode  Store --  9,12
[R]   RCL             Manual Mode Recall --  12
[K]                   keyboard command       22



TWO-NUMBER OPERATIONS:

Key   RPN SYNTAX      Description            Page
---   ----------      -----------            ----

[+]   +               add operation 18
[-]   -               subtract operation     18
[*]   *               multiply operation     18
[/]   /               divide operation       18
[F6]  Y^X             Xth power of Y18



ONE-NUMBER OPERATIONS:

Key            RPN SYNTAX       Description            Page
---            ----------       -----------            ----

[F4]           1/X              Reciprocal             16
[shift]+[F3]   10^X             Power of 10            16
[F8]           ABS              Absolute Value         16
[shift]+[F7]   ACOS             Cosine Inverse         16
[shift]+[F5]   ASIN             Sine Inverse           16
[shift]+[F9]   ATAN             Tangent Inverse        16
[N]            CHS              Change Sign            11,16
[F7]           COS              Cosine                 16
[shift]+[F1]   E^X              Power of e             16
[F1]           LN               Natural Logarithm (e)  16
[F3]           LOG              Common Logarithm (10)  16
[F5]           SIN              Sine                   16
[F2]           SQRT             Square Root            16
[F9]           TAN              Tangent                16
[F10]          X^2              Square                 16



                                                                       page 25


STACK OPERATIONS:

Key           RPN SYNTAX       Description            Page
---           ----------       -----------            ----

[SPACE]
or [ENTER]    ENTER^           Separates numbers      13
[X]           X<>Y             Exchanges X & Y        9,15,22
[C]           CLX              Clear X-register       10
[U]           R^               Roll stack up          10
[D]           RDN              Roll stack down        10
[L]           LASTX            Recall L-register      17




OTHER MODES:

Key   RPN SYNTAX       Description            Page
---   ----------       -----------            ----

[H]                    Help Screens           23
[ALT]+[P]              Switch program mode    23
[ALT]+[R]              Run program from       24
                        the current line
[CTRL]+[Q]             Quit program           24


                                                                       page 26


                                 PROGRAM MODE


When RPNDEMO is first started you will be in the Manual Mode.  To get into the
Program Mode press [ALT]+[P] and you will see a new screen that represents the
Program Mode.  The left side of the screen in Program Mode shows a menu of
selections and the right part of the screen shows the numbered lines of the
current program.

Before you load your first program RPNDEMO will start up with the program
consisting of the three lines:

  "001 LBL PROGRAM"
  "002 NOP"
  "003 RTN"

The first line of every program must be what is called a label and the last
line must be a RTN.  Later we will describe the significance of these
language elements.  The second line in this program performs No OPeration
but acts as a dummy instruction that will usually be overwritten by a more
useful instruction.

In this section of the manual we will briefly describe the options in the
Program Mode menu and then discuss the Program Mode editor.  The next section
will introduce all the elements/commands/functions of the RPN language.


                                     HELP


The simplest option in the Program Mode menu is the Help option.  Pressing
key [H] will cause RPNDEMO to display several help screens.  The first
screen contains information about using the program editor and the second
screen has information about the Animated and Fast Modes.  The remaining
three pages give a summary of the command syntax.


                             CLEARING A PROGRAM


Another simple option in Program Mode is to clear the current program.  When
you press [C] in Program Mode you will be prompted with the message

                 "You wish to clear the current program ? Y/N"

If you then press any key other than [Y] the current program is not cleared,
in fact you are simply returned to the Program Mode main menu.


                                                                       page 27


If you press [Y] then the current program (up to 999 lines) is erased and is
replaced by the three-line program:


 "001 LBL PROGRAM"
 "002 NOP"
 "003 RTN"


When you clear a program you clear the whole program.   In Edit Mode you can
repeatedly delete individual lines by holding down the [BACKSPACE] key.  There
are no options for deleting a block of lines within a program.



                             LOADING A PROGRAM

To load or read a program from disk press key [L] in the Program Mode main
menu.  You will be prompted by the message

                   "Enter filename to read: "

If you change your mind and decide you don't want to read in a program from
disk then you can simply press [ENTER] to go back to the Program Mode main
menu.

Otherwise key in a filename of a file you know already exists on disk.  You
can optionally precede your filename with a disk drive identifier and/or a
directory path.  For example, "B:\TEST\MYPRGM" will get the file called MYPRGM
from the directory TEST on drive B.

If you give a name of a file that doesn't exist then RPNDEMO will warn you
that it could not find the desired file and suggest that you try again.

When a proper file is located you will be asked to proceed with one of two
options.  You can replace the current program and make the new program the
one to be read from the disk, or, you can leave the current program alone and
merge it with the program to be read from the disk.  You will be prompted by

             "Key M to merge program or key N for a new program."

You must press either [M] or [N] to proceed.

When reading the program from disk the middle of the screen will show a
running count of the number of program lines being read.  When finished
reading the entire file, RPNDEMO will give the total number of lines read.
It will also tell you if it had to insert a LBL instruction as a new first
line or a RTN as a new last line.


                                                                       page 28


During a read from disk each program line is checked for proper syntax.  If
necessary, improper lines will be converted to NOP's.  RPNDEMO will also
report the total number of lines converted to NOP's, if any.

After reading the status screen from the load program operation you will be
returned to the Program Mode main menu.


                          SAVING A PROGRAM ON DISK


To save a program on disk press key [S] in the Program Mode main menu.  You
will be prompted by the message

                     "Enter the filename to write to: "

If you change your mind and decide you don't want to save anything on disk
then you can simply press [ENTER] to go back to the Program Mode main menu.

Otherwise key in a filename.  You can optionally precede your filename with a
disk drive and/or directory path.  For example, "C:\HP\MYPRGM"  will designate
a file called MYPRGM on drive C in the directory named HP.


IF YOU DON'T KNOW WHAT A PROPER FILENAME IS THEN YOU SHOULD ASK SOMEONE.  IN
PARTICULAR, FILENAMES SHOULD NOT EXCEED 8 CHARACTERS IN LENGTH AND SHOULD NOT
CONTAIN BLANKS OR SPECIAL PUNCTUATION MARKS!


If the name of your new file is the same as that of an already existing file
on your disk then you will be given a warning message and asked if you want to
overwrite the existing file.  You can press [Y] to proceed or press [N] to
abort the save operation.

After receiving a proper file name, RPNDEMO will write your file on the disk.
As the file is written to disk you will see a running count in the middle of
the display of the number of program lines written.  When finished you will
see the final total of the number of lines written.


                                                                       page 29



                             RUNNING A PROGRAM


To run a program from the Program Mode press key [R].  You will then be
prompted by the message


                    "Press  RETURN to start at line 1 or"

                      "Key in a starting line number ?"


Simply pressing [ENTER] is equivalent to keying in [1] and then pressing
[ENTER].  You can start running your program from any line by keying in the
appropriate line number.  You will be given a warning if the line number you
key in is not an integer or if it is larger than the number of the last line
in your program.

When your program stops running you will be in the Manual Mode.

                         CHANGING THE PROGRAM MODE

Programs can be run in one of two modes called the Fast Mode and the Animated
Mode.  In the Animated Mode which is the program default mode you can visually
see how each operation is carried out.  The Fast Mode is for those times when
you wish to quickly perform a computation.


                          CHANGING THE DELAY TIME

A number that is called the Delay Time is used to control the speed of
animation.  The default value is 100, and this number must be in the range
between 1 and 300.  You can change the value to make the animations go slower
or faster as you desire.


                         QUITTING THE PROGRAM MODE


To exit the Program Mode and return to the Manual Mode simply press [ALT]+[P]
when in the Program Mode main menu.


                                                                       page 30


                          THE PROGRAM MODE EDITOR


This section of the manual will explain the use of the program mode editor.
Although you can use your favorite word processor to create programs you
should find the built-in editor to be convenient and easy to use.

Once in the Program Mode you can enter the Edit Mode by pressing key [E].  You
will notice the cursor lands on the top line of the edit screen.  In fact the
cursor will be positioned in the column between the statement line numbers and
the actual RPN language commands.  We call this cursor column position the
normal cursor position.

When the cursor is in its normal column position you may give one of seven
commands.  These seven commands should seem natural and are simple to learn.   You can

     1. Move the cursor up one line
     2. Move the cursor down one line
     3. Type a new instruction which overwrites the current line
     4. Insert a new instruction on the current line and push
        the following lines down
     5. Delete the current line and pull the following lines up
     6. Automatically go to any line in your program
     7. Quit the Edit Mode and return to the Program Mode menu


The up and down cursor arrow keys may be used to move the cursor up or down to
any desired line of the program.  You can never move the cursor above the
first line nor below the last line of your program.   As you attempt to move
the cursor past the top or bottom of the edit screen you will note that the
edit screen automatically scrolls up and down to show any remaining lines of
your program.

You can change the instruction on the line the cursor is in by simply starting
to type the characters of a new instruction.  The cursor will then move into
the current line on which you are typing.  Once you start a new instruction
you cannot move the cursor up or down to another line.  You must type [ENTER]
to complete your new instruction.  You can use the [BACKSPACE] key to make
corrections on the current line before you press [ENTER] to complete the
current line.  When you type [ENTER] the program checks the syntax of your
instruction and if not valid, the program will replace your line with a NOP.
The cursor will then move to the next line down in its normal column position.


                                                                       page 31


Note that the first line of every program must be a LBL and if you attempt to
key in any first line that is not a LBL then your line will be replaced by the
line  LBL PROGRAM.  Also, if the cursor was on the last line of your program
which is always RTN then the editor will not overwrite that statement, but
will push the RTN down one line and insert your new line just above the last
RTN.

To insert a new instruction between lines simply press [ENTER] without keying
in anything.  You will see a new NOP instruction inserted and the lines
following the current cursor line will be moved down and renumbered.  You can
then key in a new instruction which overwrites the NOP.

To delete the line the cursor is on simply press the [BACKSPACE] key.  All the
following lines will move up and will be renumbered.

The insert with [ENTER] or delete with [BACKSPACE] key operations only occur
when the cursor is in its normal column position between the line numbers and
the actual program statements.  Otherwise, when the cursor is inside a
statement line then pressing [ENTER] will complete that line or pressing
[BACKSPACE] will erase the last typed character.

If you have a very long program and you want to go to a particular line then
just holding the up or down cursor keys to get you there may take a long time.
Instead you can go immediately to any line by simply pressing the decimal
point [.] and then typing the digits of the line number you would like to go
to.

For example, assume you are on line 25 of a 200 line program and you want to
go to line 150.  When the cursor is in its normal column position simply
press

                            [.] [1] [5] [0] [ENTER]

and you should see the edit screen re-written with the cursor on the top line
which should be program line number 150.

If you attempt to go to a line that does not exist then the editor simply
leaves the cursor where it was previously.  For instance, pressing

                            [.] [2] [1] [0] [ENTER]

within a 200 line program will leave the cursor line unchanged.

The RPN language does NOT use line numbers but the editor will number your
lines for reference purposes.  The editor acts more like a full screen editor
than a line oriented editor and you can never move the cursor into or change
the line numbers.  The editor numbers and renumbers lines as you make changes.


                                                                       page 32


The final command you can give in Edit Mode allows you to quit the Edit Mode
and return to the Program Mode.  To do this press [CTRL]+[Q]  and you should
note the cursor returns under the main menu in the Program Mode.


                                                                       page 33


                              RPN LANGUAGE SYNTAX


The following pages give a technical summary of the RPN language.  All the
language statements are listed in the ASCII order of their syntax.  The
description of each command conforms to the following format.  A couple of
sections are optional, but when present will appear in the following order.

    SYNTAX
    NOMENCLATURE
    PURPOSE
    CAUTION/RESTRICTION
    SPECIFICATION
    EXAMPLES

The SYNTAX of each command will be written between single quotes.  Certain
selectors must be within a specified range and the following abbreviations
are used.

     ff  denotes a flag number in the range 00-09
     nn  denotes a register number or numeric label 00-99
     mm  denotes what nn denotes
     ss  denotes one of the stack registers X,Y,Z,T,L
     rr  denotes either what ss denotes or what nn denotes,
           i.e. a register designator X,Y,Z,T,L or 00-99
     cc  denotes a conditional comparison =,<>,<,>,<=,>=

The NOMENCLATURE is a one-line name for the command which in many cases
corresponds to a verbal reading of the syntax.  For example the nomenclature
of the syntax 'CHS' is "change sign".

The PURPOSE is a brief abstract of the purpose of the command, but this
description is deliberately void of technical details.  The PURPOSE should
tell what the command does, short of describing how it does it.

The next description may be a CAUTION or a RESTRICTION, but these are
optional.  A CAUTION is less severe than a RESTRICTION and is given to remind
you of a mild exception or option that is related to a command.  For example,
the trigonometric cosine function 'COS' contains the CAUTION that you set the
desired angle mode before using the function.

A RESTRICTION describes a condition under which the command is guaranteed to
fail with an error message.  Thus RESTRICTIONS must be adhered to in order for
the command to be successfully executed.


                                                                       page 34


The SPECIFICATION describes the effect each command has on the RPN
environment.  The SPECIFICATION tells how the command works in the setting
of the RPN machine.  In many cases the stack contents are shown before and
after the command is executed.  In other cases the affected flags, memories
or modes are described.  The effect the command has on the "Overwrite X"
status is not indicated because all commands except CLX and ENTER^ leave
"Overwrite X" off.  Only CLX and ENTER^ leave the stack lift disabled and
show the "Overwrite X" message.  Once you understand the PURPOSE of a command,
the SPECIFICATION section details the essentials of the command.

Several commands have a general syntax and the purpose of the EXAMPLES (which
are optional) is not to give examples of how the commands operate, but simply
to give examples of the possible variations in the syntax.

One of the most effective means of understanding a command is to read the
entire description given in this part of the manual and then practice the
command and any of its variations in the Manual Mode.  Below is a brief
listing of the syntax forms of all the commands.


                    RPNDEMO LANGUAGE SYNTAX

*              DEG              LASTX           ST- 00-99
+              DSE 00-99        LBL 00-99       ST- IND 00-99
-              DSE IND 00-99    LBL "text"      ST- IND XYZTL
/              DSE IND XYZTL    LN              ST- XYZTL
0 (number)     DSE XYZTL        LOG             ST/ 00-99
1/X            ENTER^           L compare       ST/ IND 00-99
10^X           E^X              NOP             ST/ IND XYZTL
1 (number)     FC? 00-99        PI              ST/ XYZTL
2 (number)     FC? IND 00-99    QR              STO 00-99
3 (number)     FC? IND XYZTL    RAD             STO IND 00-99
4 (number)     FC?C 00-99       RCL 00-99       STO IND XYZTL
5 (number)     FC?C IND 00-99   RCL IND 00-99   STO XYZTL
6 (number)     FC?C IND XYZTL   RCL IND XYZTL   STOP
7 (number)     FRC              RCL XYZTL       TAN
8 (number)     FS? 00-99        RDN             T compare
9 (number)     FS? IND 00-99    R00-99 compare  X<>Y
ABS            FS? IND XYZTL    RTN             X<> 00-99
ACOS           FS?C 00-99       R^              X<> IND 00-99
ASIN           FS?C IND 00-99   SF 00-99        X<> IND XYZTL
ATAN           FS?C IND XYZTL   SF IND 00-99    X<> XYZTL
BEEP           GTO 00-99        SF IND XYZTL    XEQ 00-99
CF 00-09       GTO IND 00-99    SIGN            XEQ IND 00-99
CF IND 00-99   GTO IND XYZTL    SIN             XEQ IND XYZTL
CF IND XYZTL   INT              SQRT            X^2
CHS            ISG 00-99        ST* 00-99       X compare
CLRG           ISG IND 00-99    ST* IND 00-99   Y^X
CLX            ISG IND XYZTL    ST* IND XYZTL   Y compare
COS            ISG XYZTL        ST* XYZTL       Z compare
                                ST+ 00-99
                                ST+ IND 00-99
                                ST+ IND XYZTL
                                ST+ XYZTL
                                                                       page 35


SYNTAX: '*'
NOMENCLATURE: multiplication
PURPOSE: computes the product of two numbers
SPECIFICATION:       before:                after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    T    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Z    |
                    +---------+           +---------+
                 X: |    X    |        X: |   Y*X   |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+



SYNTAX: '+'
NOMENCLATURE: addition
PURPOSE: computes the sum of two numbers
SPECIFICATION:       before:                after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    T    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Z    |
                    +---------+           +---------+
                 X: |    X    |        X: |   Y+X   |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+



                                                                       page 36


SYNTAX: '-'
NOMENCLATURE: subtraction
PURPOSE: computes the difference of two numbers
SPECIFICATION:       before:                after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    T    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Z    |
                    +---------+           +---------+
                 X: |    X    |        X: |   Y-X   |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+



SYNTAX: '/'
NOMENCLATURE: division
PURPOSE: computes the quotient of two numbers
RESTRICTION: X must be nonzero
SPECIFICATION:       before:                after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    T    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Z    |
                    +---------+           +---------+
                 X: |    X    |        X: |   Y/X   |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+




                                                                       page 37


SYNTAX: numeric constant, see examples below
NOMENCLATURE: number entry of a real constant
PURPOSE: loads the X-register with the specified constant
RESTRICTIONS: the constant must begin with a digit 0-9 and may
   have up to 11 significant digits.  It may or may not have an
   embedded decimal point and scientific notation is optional.
SPECIFICATION: there are two different cases depending on the
   state of "Overwrite X".
                     before:                 after:
                    +---------+           +-----------+
                 T: |    T    |        T: |     T     |
                    +---------+           +-----------+
                 Z: |    Z    |        Z: |     Z     |
Overwrite X on      +---------+           +-----------+
                 Y: |    Y    |        Y: |     Y     |
                    +---------+           +-----------+
                 X: |    X    |        X: | constant  |
                    +---------+           +-----------+

                    +---------+           +-----------+
                 L: |    L    |        L: |     L     |
                    +---------+           +-----------+

              ------------------------------------------

                    +---------+           +-----------+
                 T: |    T    |        T: |     Z     |
                    +---------+           +-----------+
                 Z: |    Z    |        Z: |     Y     |
Overwrite X off     +---------+           +-----------+
                 Y: |    Y    |        Y: |     X     |
                    +---------+           +-----------+
                 X: |    X    |        X: | constant  |
                    +---------+           +-----------+

                    +---------+           +-----------+
                 L: |    L    |        L: |     L     |
                    +---------+           +-----------+

EXAMPLES: '123'
          '123.'
          '123.00'
          '3.1415926536'
          'PI'                (same as line above)
          '6.023E-23'         (Avagadro's number)
          '2.997925E+10'      (speed of light)
          '2.997925E10'       (speed of light, positive exp.)
          '3.3356404856E-11'  (reciprocal of speed of light)
          '0.5772156649'      (Euler's Constant)
          '1.6180339887'      (Golden Ratio)




                                                                       page 38

SYNTAX: '1/X'
NOMENCLATURE: reciprocal
PURPOSE: calculates the reciprocal of a number
RESTRICTION: X must be nonzero
SPECIFICATION:       before:               after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    Z    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Y    |
                    +---------+           +---------+
                 X: |    X    |        X: |   1/X   |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+




SYNTAX: '10^X'
NOMENCLATURE: 10 to the Xth power
PURPOSE: calculates the common anti-logarithm (base 10) of X.
CAUTION: if X is too large, overflow may result
SPECIFICATION:       before:               after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    Z    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Y    |
                    +---------+           +---------+
                 X: |    X    |        X: |  10^X   |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+



                                                                       page 39


SYNTAX: 'ABS'
NOMENCLATURE: absolute value
PURPOSE: computes the absolute value of a number
SPECIFICATION:       before:               after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    Z    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Y    |
                    +---------+           +---------+
                 X: |    X    |        X: |  ABS(X) |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    X    |
                    +---------+           +---------+




SYNTAX: 'ACOS'
NOMENCLATURE: arc cosine
PURPOSE: computes the inverse cosine of a number
CAUTION: the resulting angle is in either degrees or radians,
   depending on the angle mode setting.
   for radians: 0<=ACOS(X)<=PI
   for degrees: 0<=ACOS(X)<=180.
RESTRICTION: X must be between -1 and +1.  -1<=X<=+1.
SPECIFICATION:       before:               after:
                    +---------+           +----------+
                 T: |    T    |        T: |    T     |
                    +---------+           +----------+
                 Z: |    Z    |        Z: |    Z     |
                    +---------+           +----------+
                 Y: |    Y    |        Y: |    Y     |
                    +---------+           +----------+
                 X: |    X    |        X: | ACOS(X)  |
                    +---------+           +----------+

                    +---------+           +----------+
                 L: |    L    |        L: |    X     |
                    +---------+           +----------+


                                                                       page 40


SYNTAX: 'ASIN'
NOMENCLATURE: arc sine
PURPOSE: computes the inverse sine of a number
CAUTION: the resulting angle is in either degrees or radians
   for radians: -PI/2<=ASIN(X)<=PI/2
   for degrees: -90<=ASIN(X)<= 90
RESTRICTION: X must be between -1 and +1.  -1<=X<=+1.
SPECIFICATION:       before:               after:
                    +---------+           +----------+
                 T: |    T    |        T: |    T     |
                    +---------+           +----------+
                 Z: |    Z    |        Z: |    Z     |
                    +---------+           +----------+
                 Y: |    Y    |        Y: |    Y     |
                    +---------+           +----------+
                 X: |    X    |        X: |  ASIN(X) |
                    +---------+           +----------+

                    +---------+           +----------+
                 L: |    L    |        L: |    X     |
                    +---------+           +----------+





SYNTAX: 'ATAN'
NOMENCLATURE: arc tangent
PURPOSE: computes the inverse tangent of a number
CAUTION: the resulting angle is in either degrees or radians,
   depending on the angle mode setting.
   for radians: -PI/2<ATAN(X)<PI/2
   for degrees: -90<ATAN(X)<90.
SPECIFICATION:       before:               after:
                    +---------+           +----------+
                 T: |    T    |        T: |    T     |
                    +---------+           +----------+
                 Z: |    Z    |        Z: |    Z     |
                    +---------+           +----------+
                 Y: |    Y    |        Y: |    Y     |
                    +---------+           +----------+
                 X: |    X    |        X: |  ATAN(X) |
                    +---------+           +----------+

                    +---------+           +----------+
                 L: |    L    |        L: |    X     |
                    +---------+           +----------+



SYNTAX: 'BEEP'
NOMENCLATURE: beep
PURPOSE: sounds 4 quick chirps on the speaker
SPECIFICATION: no effect on stack contents

                                                                       page 41


SYNTAX: 'CF ff' or  'CF IND rr'
NOMENCLATURE: clear flag.
PURPOSE: clears a specified flag to 0.
RESTRICTION: the flag selected must be in the range from 0-9.
SPECIFICATION: no effect on stack contents.  Flags take on the
   values 0 and 1 only and when a flag is in state 0 we say it
   is clear.  When a flag is in state 1 we say it is set.
   'CF ff' clears the flag designated directly by ff.
   'CF IND rr' calculates the selected flag number by taking
   the integer part of the absolute value of the number
   contained in the register named by rr.  This selector must
   be in the range 0-9 or a 'NONEXISTENT' error message will
   result.
EXAMPLES:  'CF 01'
           'CF 08'
           'CF IND 25'
           'CF IND Z'




SYNTAX: 'CHS'
NOMENCLATURE: change sign
PURPOSE: computes the negative of a number
CAUTION: this function has no effect on LASTX nor on the
   "Overwrite X" status
SPECIFICATION:       before:               after:
                    +---------+           +---------+
                 T: |    T    |        T: |    T    |
                    +---------+           +---------+
                 Z: |    Z    |        Z: |    Z    |
                    +---------+           +---------+
                 Y: |    Y    |        Y: |    Y    |
                    +---------+           +---------+
                 X: |    X    |        X: |   -X    |
                    +---------+           +---------+

                    +---------+           +---------+
                 L: |    L    |        L: |    L    |
                    +---------+           +---------+



                                                                       page 42


SYNTAX: 'CLRG'
NOMENCLATURE: clear all registers
PURPOSE: clears all the memory registers R00-R99 to all 0's
SPECIFICATION: no effect on stack contents.  This function
   stores a 0 in each of R00 thru R99.





SYNTAX: 'CLX'
NOMENCLATURE: clear X
PURPOSE: clears the X-register to zero
CAUTION: this function has no effect on LASTX and it leaves
   the "Overwrite X" message on
SPECIFICATION:  before:               after:
               +---------+           +---------+
            T: |    T    |        T: |    T    |
               +---------+           +---------+
            Z: |    Z    |        Z: |    Z    |
               +---------+           +---------+
            Y: |    Y    |        Y: |    Y    |
               +---------+           +---------+
            X: |    X    |        X: |    0    |
               +---------+           +---------+

               +---------+           +---------+
            L: |    L    |        L: |    L    |
               +---------+           +---------+  "Overwrite X"





SYNTAX: 'COS'
NOMENCLATURE: cosine
PURPOSE: computes the cosine of an angle
CAUTION: the angle is assumed to be in either degrees or
   radians, depending on the angle mode setting.
SPECIFICATION:       before:               after:
                    +---------+           +----------+
                 T: |    T    |        T: |    T     |
                    +---------+           +----------+
                 Z: |    Z    |        Z: |    Z     |
                    +---------+           +----------+
                 Y: |    Y    |        Y: |    Y     |
                    +---------+           +----------+
                 X: |    X    |        X: |  COS(X)  |
                    +---------+           +----------+

                    +---------+           +----------+
                 L: |    L    |        L: |    X     |
                    +---------+           +----------+




                                                                       page 43
