home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Frozen Fish 1: Amiga
/
FrozenFish-Apr94.iso
/
bbs
/
alib
/
d1xx
/
d103
/
calc.lha
/
Calc
/
Calc.doc
< prev
next >
Wrap
Text File
|
1987-10-22
|
41KB
|
789 lines
******************
***** CALC *****
* Version 1.00 *
* by Bob Brooks *
* Copyright 1987 *
==================
User Documentation
******************
1) Introduction
Congratulations! You are now the owner of CALC, a highly
programmable calculator program with similarities to a
hand-held RPN calculator but with much more power. CALC
allows you to operate in either an interactive mode
(entering commands from the keyboard directly) or by
pre-defined programs which you have written and stored in
disk files. CALC provides the user with four work
registers (X, Y, Z, T) and 100 long-term storage registers
(numbered 00 through 99). This version of CALC provides
the following functions:
1) Arithmetic
2) Exponentiation
3) Logarithms
4) Trigonometry
5) Factorials
6) Square-root
7) Integer and Fractional portions of numbers
8) Time/Angle conversions
9) Reciprocal
10) Rounding-off numbers
11) Hyperbolic functions
12) Direct register manipulation
Whether you need an answer to a quick computation or want
to run a long and complicated program, CALC can handle it.
However, this version of CALC only operates from CLI. To
execute CALC from CLI, you need only type
CALC
from the CLI prompt. CALC will then begin running.
CALC can actually be thought of as a mathmatical programm-
ing language. Its command structure is very simple with,
as is true of any programming language, a fairly strict
syntax for those commands. Every attempt has been made to
name the commands so that their name describes what they do.
All of its number munching and crunching is performed in
double precision for extreme accuracy even with very large
and very small numbers. Variable output formats allow you
to see the 15 most significant digits in all four work
registers. Numbers larger than 15 digits or too small to
show in 15 decimal places are displayed in exponential
format. A small set of commands provide direct control of
CALC, making it possible to tell CALC from where it should
get its input and how to handle output. A brief online
Help menu is available which gives a short description of
each CALC command.
Section 2 of this document will explain what each command is
and does. The third section will explain how to use CALC in
both the Keyboard and File modes, including how to build a
program file on disk. Finally, several sample programs are
provided to help you to learn to program CALC. A quick-ref
appendix appears at the end of the document.
A Special Note to the Users of CALC:
This is Public Supported Software and, as such, can be
propogated and distributed by its users unchanged and free-
of-charge. Feel free to put it on any bulletin boards, etc
along with this documentation. This also means that if you
like CALC, then a $20.00 donation sent to:
Bob Brooks
7352 Amestoy Ave.
Van Nuys, CA 91406
would be greatly appreciated. As a special service, all paid
users will be notified by mail when the upgrade is available.
An upgraded version will be released in the future and will
incorporate such capabilities as BREAK/CONT, Program Labels/GOTO,
single stepping through your programs and maybe some very nice
surprizes if the response to Version 1.00 is good enough.
Now, with all of the formalities out of the way, let's get
started.
2) CALC Command List
This is a complete list of all currently active CALC commands.
The command is shown followed by a description of what the
command actually does. The work registers (X, Y, Z, T) are
represented by either the letter r or R. Memory registers are
indicated by use of the ## symbol.
+ Addition. Adds contents of Y register to contents
of X register and puts result in X register.
- Subtraction. Subtracts the contents of the Y
register from the contents of the X register and
puts the result in the X register.
* Multiplication. Multiply the contents of the Y
register by the contents of the X register and put
the result in the X register.
/ Division. Divides the contents of the X register
by the contents of the Y register and puts the result
into the X register. The Y register MUST contain a
non-zero number (division by zero is undefined).
E This command loads the value of the constant 'e'
(2.7182818285) into the X register.
** Raise to a Power. This command will raise the
contents of the X register to the power that is
contained in the Y register. Both X and Y can be
Real numbers BUT X must be only a positive Real or
zero. If X is a negative number, then CALC will
issue an error message and not perform the requested
function. The result is put into the X register.
LN Natural Logarithm. This command takes the natural
logarithm (Log to the base e) of the contents of the
X register and puts the result into the X register.
X may only be a positive Real number. If X is zero
or negative, CALC will issue an error message and
not perform the requested action.
PI This command loads the value of the constant PI
(3.1415926536) into the X register.
**2 Square of a Number. Computes the square of the
contents of the X register and puts the result in
the X register. This command will process all
numbers, positive, negative, or zero.
**3 Cube of a Number. Computes the cube of the
contents of the X register and puts the result in
the X register. This command will process all
numbers, positive, negative, or zero.
ABS Absolute Value. Take the absolute value of the
contents of the X register and put the result in
the X register.
CLR Clear all Work Registers. Sets the contents of the
X, Y, Z, and T registers to 0.0000000
EXP Raise e to a Power. Raises the constant 'e'
(2.7182818285) to the power of the contents of the
X register and puts the result in the X register.
INT Integer Part. Take the integer portion of the
contents of the X register and put result in the
X register. The integer portion of a number is
that pert to the left of the decimal point.
LOG Common Logarithm. Takes the common logarithm (Log
to base 10) of the contents of the X register and
puts the result into the X register. X may contain
any positive Real number. If X is zero or negative,
CALC will issue an error message and not perform
the requested action.
SIN, COS, TAN Trigonometric functions. Computes the requested
CSC, SEC, COT trigonometric function for the angle contained in
the X register. All angles must be in degrees.
The result is put into the X register.
RCL ## r Recall from a Memory Register. This command will
get whatever the contents of storage register ##
is and put that value into the work register
specified in the 'r' field. The value of the ##
field can be 00 through 99. The 'r' field is
optional. The 'r' field can be any of the work
registers (X, Y, Z, or T). If the 'r' field is
left blank or omitted, then CALC assumes that the
contents of Mem Reg ## is to be put into the X
work register.
For example, the command RCL 02 Y would get the
value stored in Mem Reg number 2 and put it into
work register Y. The command RCL 00 would get the
value stored in Mem Reg 0 and put it into the X
work register since no destination register 'r'
was provided. The syntax of this command is very
important. The RCL must be followed by one space,
then a two digit Mem Reg number, then a blank space,
and, finally, the optional destination register.
STO ## Store to a Memory Register. This command will put
the value of work register X into memory register
##. The ## field can be from 00 through 99. The
syntax is STO followed by one blank space and then
the Mem Reg number ##.
SUM ## Add to a Memory Register. Adds the contents of the
X work register to whatever value is already stored
in Mem Reg ##. The ## field can be any number from
00 through 99.
For example, if Mem Reg 14 contained the value 23.00
and work register X contained 56.00000, then after
executing a SUM 14 command, Mem Reg 14 would contain
79.0000 (23+56). The syntax is SUM followed by one
blank space, then the memory number ##.
ASIN, ACOS, ATAN Inverse Trigonometric Functions. Computes the
requested inverse trigonometric function for the
value contained in the X register and puts the
result into the X register. The result is expressed
in degrees.
CLRX Clear X Register Only. Set value of X to 0.0000000
EXCH r R Exchange Work Registers. Exchanges the value in
work register 'r' with that stored in work register
'R.' Both 'r' and 'R' can take on the values
X, Y, Z, or T. If 'R' or 'r' are not one of these
or if they are the same (R=r), then CALC will issue
an error message and ignore the request. For example,
EXCH X Y would be a valid request and would result
in the values stored in register X and register Y
being swapped. Now what was in X would be in Y and
what was in Y would be in X. An example of an
invalid use of this command would be EXCH X X.
Also, the order that you enter 'r' and 'R' is not
important. EXCH Y T and EXCH T Y produce the same
effect, to exchange the Y and T registers. The
syntax of this command is EXCH followed by one blank
space, then one of the registers ('r'), then another
blank space, and finally the other register ('R').
FACT Factorial. Computes the factorial of the integer
portion of the number stored in the X register and
puts the result into the X register. This function
will compute from 1! to 50!. Any zero or negative
value in X will result in an error message being
issued and CALC not performing the requested action.
FILE Program File Input. Open a program file and run it.
When this command is entered, CALC will request that
you enter the name of your program file. CALC will
read this program file and execute the commands in
it until it reaches either the end of the file, a
KEYBRD command or a STOP or END command.
FRAC Fractional Part. Take the fractional portion of the
number in the X register and put the result into the
X register. The fractional portion of a number is
that part to the right of the decimal point.
HHMS Decimal Hours/Degrees to Mixed Units. Converts
decimal hours/degrees in the X register to
hours/degrees, minutes, and seconds. The result is
put into the X register in the format HHMMSS where
HH is the hours/degrees, MM is the minutes, and
SS is the seconds.
An example of this would be if the X register
contained 16.505555. entering HHMS would give the
value 163020.0000 in the X register. This translates
to 16 hours/degrees, 30 minutes, and 20 seconds.
HMSH Mixed Units to Decimal Hours/Degrees. This really
just performs the opposite function that the previous
command performs. It takes mixed units in the HHMMSS
format from the X register and converts them to
decimal hours/degrees, putting the result into the
X register.
Using the example from the previous command, if the
X register contains 163020.0000, then entering this
command would give the result 16.50555 in the X
register.
SHOW (ON/OFF) Turn ON/OFF display of X, Y, Z, and T. Entering
SHOW ON will display the contents of the work reg-
isters after each command is executed by CALC. If
you enter SHOW OFF then CALC will not display the
work registers until a SHOW ON command is entered
or, if you are running a program, until the end of
the program file is reached. The syntax of this
command is SHOW followed by one blank space, and then
either ON or OFF.
SINH, COSH, TANH Hyperbolic functions. Computes the appropriate
hyperbolic function using the contents of the X
register and puts the result into the X register.
SQRT Square-Root. Take the square-root of the value in
the X register and put the result into the X
register. The contents of the X register must be
a positive number or zero. If X is negative, then
CALC will issue an error message and not perform the
requested function.
RECIP r Reciprocal. Take the reciprocal of the value of
'r' register and put the result into the 'r' register.
'r' can be any of the work registers (X, Y, Z, or T).
If 'r' is omitted, CALC assumes that you want the
reciprocal of the X register. Register 'r' can
contain any non-zero value. If it equals zero, then
CALC will issue an error message and not perform the
requested function.
ROUND Round-off. Round-off the value in the X register to
the nearest integer.
This means that if X contains 23.45763, then if it
is rounded, it will become 23.0000. If X is set to
23.51703, then entering ROUND would round X up to
24.0000.
CHSIGN r Change Sign. Change the sign of the value in the
'r' work register. In other words, a positive number
will become a negative number and a negative will
become positive. The 'r' field can be any one of
X, Y, Z, or T. If the 'r' field is omitted, then
CALC assumes that you want to change the sign of the
X register.
KEYBRD Read CALC program statements from the Keyboard.
ROLLDN Rotate Work Registers. Rotate the X, Y, Z, T
registers counter-clockwise so that the following
occurs: X=Y, Y=Z, Z=T, T=X. This allows you to use
the work registers as a FIFO stack.
For those who don't know what FIFO means, it's an
acronym for First-In-First-Out.
STOP, END Quit running CALC and exit to CLI.
3) How to write programs for CALC
CALC reads its input from either the keyboard or from disk files.
When in keyboard mode, CALC tells you, each time, what the values of
the four work registers are. As an example, from the CALC prompt
for input, type the number 30 and hit return. Notice that 30 is now
stored in the X register. All of the others are still zero. Now
type EXCH X Y. Be sure that the syntax is exactly as described in
the previous section. This command caused the value in X to be put
in Y and the value in Y to be put into X. Now type 25 and hit
return. CALC now shows X equal to 25 and Y equal to 30. If we
wanted to multiply these two numbers, we would simply type * and
CALC would do the multiplication and put the result into the X regis-
ter. The * symbol is the instruction to CALC that it should mult-
iply the value in X by that in Y. In this case, the result is 750
and that is precisely what we see in X. This is the basis on which
CALC operates. You enter your initial data to CALC and then tell
it how to process those data. A description of all valid CALC
commands is provided in the previous section.
Of course, what you have just done is to use CALC in its inter-
active, or keyboard mode. The other mode that CALC can operate in
is the File mode. You may have a long set of calculations to make
to arrive at some final value. And you may want to keep that program
stored away where you can get at it when you need it in the future
to do the same calculations again but with different data. Rather
than just writing these commands down on a piece of paper and then
retyping those commands over again to rerun the program, CALC allows
you to store your commands in ASCII disk files and then simply tell
CALC to read the commands from the file and process just as though
you were entering those commands from the keyboard, but much more
efficiently and quickly. Your program file can contain any command
which is acceptable to CALC with the single exception of the FILE
command. CALC only allows one program file to be open at a time
and asking to open a file from another file will cause CALC to issue
an error message and then to ignore the requested command. Other-
wise, you can enter numbers and commands in whatever order will make
CALC do the computations you need.
When CALC is processing in FILE mode, it will continue until it
reaches the end of the program file, a KEYBRD command, or a STOP
or END command. When CALC encounters the end of a file, it will
automatically put you back in keyboard mode. When it sees a STOP
or END command, it exits CALC and returns to the system.
As mentioned earlier, CALC is very sensitive to syntax. Both
upper and lower case are acceptable, but your commands must be
syntactically correct. Violations of the syntactical rules which
were identified in the command definitions section of this document
will result in CALC issuing an error message and, in FILE mode,
asking you if it should stop processing so you can fix the error or
just continue.
To build your program files, you can use any text editor or word
processor that writes its files in ASCII. In the Amiga, the ED text
editor is quite good for this purpose. Your AmigaDOS documentation
should be consulted for more information about ED.
In your program files, the first 35 characters of each line are
reserved for your CALC commands. From column 36 to the end of the
line you can enter any comments you might want to make regarding
just what your program is doing. This will help you when you are
debugging your programs as well as when you look at them long after
writing them and can't remember what they were supposed to be doing.
Several sample problems and the programs that will solve them
are provided below to help you learn how to program CALC.
Some helpful hints on writing programs:
1) When writing a program, break your problem down into the
smallest pieces possible. Then work on those little parts one
at a time and save the results in the various work and memory
registers for later retrieval. This method is a standard
programming technique and helps enormously when you have to
debug your programs.
2) If some of the values to your program change with each run,
then try to design your programs to retrieve those values from
the memory registers. Then, each time that you run a program,
you can initialize those memory registers with the values that
you want to use with that run. This would be done by entering
the values by hand and then STOing them into the appropriate
register. Once they are stored away, you can enter a FILE
command and start cranking away.
Amiga and AmigaDOS are trademarks of Commodore-Amiga, Inc.
4) Sample programs:
Most of the sample programs given deal with mathematical
problems, though two do temperature conversions and another
computes the monthly payment for a loan. Their order of present-
ation is from simplest to most complex. Most are designed to be
general use programs and, therefore, require you to initialize
them before running them. When this is required, the initializa-
tion commands are entered from the keyboard and appear under the
heading
"Program Initialization:"
The stored program commands are listed under the heading
"Program Listing:"
Read each example and then try entering the program first via
the keyboard one statement at a time. Then build a program file
and run the file through CALC. You should be pleased with the
increase in efficiency and speed. By the way, you don't need to
enter the comments for each line when doing keyboard entry, only
the commands themselves.
1) Convert -30 degrees Celcius to degrees Kelvin.
The equation is: K=C+273.15
where: K is the temperature in degrees Kelvin
C is the temperature in degrees Celcius
Program Initialization:
-30
STO 00
Program Listing:
273.15 DIFFERENCE BETWEEN CELCIUS AND KELVIN IN X
RCL 00 Y LOAD DEGREES CELCIUS FROM MEM REG 00 INTO Y
+ COMPUTE KELVIN=CELCIUS+273.15
2) Convert 513 degrees Fahrenheit to degrees Celcius.
The equation is: C=(5/9)*(F-32)
where: C is the temperature in degrees Celcius
F is the temperature in degrees Fahrenheit
Program Initialization:
513
STO 00
Program Listing:
9 LOAD 9 INTO X REG
EXCH X Y MOVE IT TO THE Y REG
5 LOAD 5 INTO X REG
/ COMPUTE (5/9) TERM
EXCH X Z SAVE THAT IN THE Z REG FOR SAFE KEEPING
32 LOAD 32 INTO THE X REG
EXCH X Y MOVE IT TO THE Y REG
RCL 00 GET DEGREES F FROM MEM REG 00 PUT IN X
- COMPUTE (F-32) TERM
EXCH Y Z MOVE (5/9) FROM Z TO Y
* COMPUTE C=(5/9)*(F-32)
3) Convert angular 61 degrees to radians.
The equations are: number of Radians per Degree = PI/180
Radians=(PI/180)*Degrees
Program Initialization:
61
STO 00
Program Listing:
180 DEGREES IN A HALF CIRCLE
EXCH X Y STICK IT IN THE Y REG
PI RADIANS IN A HALF CIRCLE
/ COMPUTE CONVERSION FACTOR DEG TO RAD
RCL 00 Y GET ANGLE IN DEGREES FROM 00 AND PUT IN Y
* COMPUTE ANGLE IN RADIANS
4) Compute the circumference of a circle with radius of 10 inches.
The equation is: C=2*PI*R
where: C is the circumference of the circle
R is the radius of the circle
Program Initialization:
10
STO 00
Program Listing:
PI GET VALUE OF PI AND PUT IT IN X
EXCH X Y MOVE PI TO Y REG
2 LOAD 2 INTO X REG
* COMPUTE (2*PI) TERM
RCL 00 Y GET CIRCLE RADIUS (R) FROM MEM REG 00 INTO Y
* COMPUTE CIRCUM=2*PI*R
5) Compute the area of a circle with radius of 4 inches.
The equation is: A=PI*(R**2)
where: A is the area of the circle
R is the radius of the circle
Program Initialization:
4
STO 00
Program Listing:
PI PUT VALUE OF PI INTO X REG
EXCH X Y MOVE PI TO Y REG
RCL 00 GET RADIUS (R) OF CIRCLE FROM MEM REG 00 TO X
**2 COMPUTE SQUARE OF RADIUS
* COMPUTE AREA=PI*(R**2)
6) Use the Pythagorean Theorem to compute the length of the hypotenuse of a
right triangle with sides of 6 inches and 8 inches.
The equation is: C=SQRT((A**2)+(B**2))
where: C is the length of the hypotenuse
A and B are the two sides of the triangle
Program Initialization:
6
STO 00
8
STO 01
Program Listing:
RCL 00 GET ONE OF THE SIDES FROM MEM REG 00
**2 SQUARE THAT SIDE
EXCH X Y AND MOVE RESULT OVER TO REG Y
RCL 01 GET OTHER SIDE FROM REG 01
**2 SQUARE THAT SIDE
+ COMPUTE THE SUM OF THE SQUARES
SQRT TAKE SQUARE-ROOT TO GET LENGTH OF THIRD SIDE
7) Compute the volume of a sphere with radius of 5 inches.
The equation is: V=(4/3)*PI*(R**3)
where: V is the volume of the sphere
R is the radius of the sphere
Program Initialization:
5
STO 00
Program Listing:
PI GET VALUE OF PI AND PUT IN X REG
EXCH X Y MOVE PI TO Y REG
4 LOAD 4 INTO X
* COMPUTE (4*PI) TERM
EXCH X Y MOVE THAT TO Y REG
3 LOAD 3 INTO X
EXCH X Y SWAP X REG AND Y REG
/ COMPUTE (4*PI/3) TERM
EXCH X Y PUT THAT IN THE Y REG FOR LATER USE
RCL 00 GET RADIUS (R) OF SPHERE FROM MEM REG 00
**3 COMPUTE (R**3) TERM
* COMPUTE VOL=(4*PI/3)*(R**3)
8) Use the Law of Cosines to find the length of the third side of a triangle
whose other two sides measure 16 inches and 18 inches and with the angle
between those two sides equal to 40 degrees.
The equation is: A**2=(B**2)+(C**2)-(2*B*C*COS(ALPHA))
where: A is the length of the third side
B and C are the lengths of the two given sides
ALPHA is the angle between sides B and C
Program Initialization:
16
STO 00
18
STO 01
40
STO 02
Program Listing:
RCL 00 GET ONE OF THE SIDES
RCL 01 Y GET THE OTHER SIDE
* COMPUTE (B*C) TERM
EXCH X Z SAVE RESULT IN Z REG FOR NOW
RCL 00 GET ONE OF THE SIDES IN X REG
**2 COMPUTE (B**2) TERM
STO 00 SAVE RESULT IN MEM REG 00
RCL 01 GET OTHER SIDE IN X REG
**2 COMPUTE (C**2) TERM
SUM 00 COMPUTE (B**2)+(C**2) AND STORE IN MEM REG 00
EXCH Y Z GET THE (B*C) TERM FROM Z REG PUT IN Y REG
2 GET READY TO COMPUTE (2*B*C) TERM
* COMPUTE (2*B*C) TERM
EXCH X Y STICK IT IN THE Y REG
RCL 02 GET THE ANGLE (ALPHA) BETWEEN LINES B & C
COS TAKE COSINE OF THAT ANGLE
* COMPUTE (2*B*C*COS(ALPHA)) TERM
EXCH X Y SAVE IT IN THE Y REG FOR LATER USE
RCL 00 GET THE (B**2)+(C**2) TERM FROM MEM REG 00
- COMPUTE ((B**2)+(C**2)-(2*B*C*COS(ALPHA)))
SQRT TAKE SQUARE-ROOT TO COMPUTE THIRD SIDE
9) Compute the monthly payment for a loan on a house for $100,000.00 at 12.5
percent annual interest rate and with a term of 30 years.
The equation is: P=(R*A*((R+1)**N))/(((R+1)**N)-1)
where: P is the MONTHLY payment
R is the MONTHLY interest rate (computed from annual rate)
A is the amount of the loan
N is the total number of payments (computed from term)
Program Initialization:
12.5
STO 00
30
STO 01
100000
STO 02
Program Listing:
RCL 01 Y GET TERM OF LOAN IN YEARS
12 NUMBER OF MONTHS IN A YEAR
* COMPUTE TOTAL NUMBER OF PAYMENTS
STO 01 STORE RESULT BACK IN 01
RCL 00 Y GET ANNUAL INTEREST RATE
1200 12 MON/YR * 100 PERCENT
EXCH X Y SWAP X AND Y FOR DIVISION
/ COMPUTE MONTHLY INTEREST RATE
STO 00 STORE RESULT BACK IN 00
EXCH X Y PUT MONTHLY INT RATE IN Y REG
1 TO COMPUTE THE (R+1) TERM
+ COMPUTE THE (R+1) TERM
RCL 01 Y GET TOTAL NUMBER OF PAYMENTS
** COMPUTE ((R+1)**N) TERM
EXCH X Y PUT IT IN Y REG
1 FOR COMPUTATION OF DENOMINATOR
- COMPUTE (1-(R+1)**N)
CHSIGN X THEN CHANGE SIGN TO GET (((R+1)**N)-1)
EXCH X Y GET ((R+1)**N) TERM IN X
/ COMPUTE ((R+1)**N)/(((R+1)**N)-1)
RCL 02 Y GET TOTAL AMOUNT OF LOAN
* COMPUTE A*((R+1)**N)/(((R+1)**N)-1)
RCL 00 Y GET MONTHLY INTEREST RATE
* COMPUTE TOTAL MONTHLY PAYMENT
EXCH X Y PUT IT IN THE Y REG
100 GET READY TO ROUND OFF THE PAYMENT
EXCH X Y WILL NEED THAT 100 AGAIN LATER
* STILL GETTING READY TO ROUND
ROUND ROUND IT OFF TO NEAREST PENNY
/ TAKE IT BACK TO DOLLARS AND CENTS
KEYBRD GO BACK TO KEYBOARD INPUT
5) Command quick reference lists.
General Command List
Command Description
---------------------------------------------------------------
? Help.
+ Addition.
- Subtraction.
* Multiplication.
/ Division.
E Load 'e' (2.7182818285) into the X register.
** Raise to a Power.
LN Natural Logarithm.
PI Load PI (3.1415926536) into the X register.
**2 Square of a Number.
**3 Cube of a Number.
ABS Absolute Value.
CLR Clear all Work Registers.
END Quit running CALC and exit to the System.
EXP Raise e to a Power.
INT Integer Part.
LOG Common Logarithm.
SIN Trigonometric function Sine.
COS Trigonometric function Cosine.
TAN Trigonometric function Tangent.
CSC Trigonometric function Cosecant.
SEC Trigonometric function Secant.
COT Trigonometric function Cotangent.
RCL ## r Recall from a Memory Register.
STO ## Store to a Memory Register.
SUM ## Add to a Memory Register.
ASIN Inverse Trigonometric Function Arcsine.
ACOS Inverse Trigonometric Function Arccosine.
ATAN Inverse Trigonometric Function Arctangent.
CLRX Clear X Register Only.
EXCH r R Exchange Work Registers.
FACT Factorial.
FILE Program File Input.
FRAC Fractional Part.
HELP Help.
HHMS Decimal Hours/Degrees to Mixed Units.
HMSH Mixed Units to Decimal Hours/Degrees.
SHOW (ON/OFF) Turn ON/OFF display of X, Y, Z, and T.
SINH Hyperbolic Sine function.
COSH Hyperbolic Cosine function.
TANH Hyperbolic Tangent function.
SQRT Square-Root.
STOP Quit running CALC and exit to the System.
RECIP r Reciprocal.
ROUND Round-off.
CHSIGN r Change Sign.
KEYBRD Read CALC program statements from the Keyboard.
ROLLDN Rotate Work Registers.
Functional Command List
Function Associated Commands
--------------------------------------------
CALC control commands ?
END
FILE
HELP
SHOW
STOP
KEYBRD
Register Manipulation CLR
RCL
STO
SUM
CLRX
EXCH
ROLLDN
Arithmetic +
-
*
/
ROUND
Constants E
PI
Portions of numbers INT
FRAC
Algebraic **
**2
**3
ABS
EXP
FACT
SQRT
RECIP
CHSIGN
Logarithms LN
LOG
Trigonometry SIN
COS
TAN
CSC
SEC
COT
ASIN
ACOS
ATAN
Hyperbolic functions SINH
COSH
TANH
Time/Angle conversions HHMS
HMSH
