Google
 

Trailing-Edge - PDP-10 Archives - decus_20tap1_198111 - decus/20-0001/calc.dor
There is 1 other file named calc.dor in the archive. Click here to see a list.
.LM 5
.RM 80
.TITLE CALC.DOC - DECsystem-20 implementation of CALC
.FOOTNOTE 20
COPYRIGHT (C) 1977 BY
.SKIP 1
DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
.SKIP 2
THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
TRANSFERRED.
.SKIP 1
THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
CORPORATION.
.SKIP 1
DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
.END FOOTNOTE
.SKIP 2
.CENTER ;CALC INSTALLATION INSTRUCTIONS
.PAGE
.HL 1 INTRODUCTION
CALC is a calculator designed to evaluate arithmetic expressions.
It was written by Peter Baum at DEC to run on a PDP-11 under RSX-11M
(DECUS no. 11-341). The modifications necessary to run it on the DEC-20
were performed by Paul Lemaire at DEC.
.HL 1 KNOWN BUGS AND DEFICIENCIES
.LIST 1
.LE;The *ASCII data type does not work as described in the CALC USER'S
GUIDE. Specifically, you cannot use it to obtain ASCII octal codes. This
is because *ASCII variables are stored as single characters on the 
PDP-11 while they are stored as full-word Hollerith (left-justified) on
the DEC-20.
.END LIST
.HL 1 FILES SUPPLIED
.HL 2 Save Set 1 - CALC Documentation
	CALC.DOC	This Documentation file
.BLANK
	CALC.USR	CALC USER'S GUIDE
.HL 2 Save Set 2 - Files needed to run CALC and sample command files
	CALC.EXE	CALC executable file
.BLANK
	ADD.		Command file- Adds a sequence of numbers
.BREAK
	ADD1.		used by ADD.
.BLANK
	ADD8.		Command file- Adds octal numbers
.BLANK
	MFACT.		Command file- Calculates factorials
.BREAK
	MF1.		used by MFACT
.BREAK
	MF2.		used by MFACT
.BLANK
	ROOT.		Command file- Calculates the roots of a 
.BREAK
				quadratic equation
.BLANK
	SIGN.		CALC.HLP Example
.BREAK
	MINUS.		used by SIGN.
.BREAK
	PLUS.		used by SIGN.
.BREAK
	ZERO.		used by SIGN.
.PAGE
.HL 2 Save Set 3 - Source files
.CENTER;^&FORTRAN modules\&
.BLANK
	CALC.FOR	The main program
.BLANK
.NOFILL
	^^ASSIGN.FOR\\		ASSOCIATES LOGICAL UNITS WITH FILES
	^^AT.FOR\\			INDIRECT FILE PROCESSING
	^^BASCNG.FOR\\		BASE CHANGES
	^^BLOCK.FOR\\		BLOCK DATA FOR COMMON AREA
	^^CALBIN.FOR\\		CALCULATES BINARY OPERATIONS
	^^CALUN.FOR\\		CALCULATES UNARY FUNCTIONS
	^^CLOSE.FOR\\		CLOSES FILES
	^^CMND.FOR\\		PROCESSES CALC COMMANDS
	^^CODES.FOR\\		INFORMATION ON ^^CALC\\ INTERNAL CODES
	^^CONTYP.FOR\\		CONVERTS DATA TYPES
	^^DECLR.FOR\\		PROCESSES DATA TYPE DECLARATIONS
	^^DTANH.FOR		FUDGED\\ (USES SINGLE-PRECISION ROUTINE)
	^^ERRCX.FOR\\		PERFORMS INITIAL EXPRESSION ERROR 
				CHECKING
	^^ERRMSG.FOR\\		OUTPUTS ALL ERROR MESSAGES
	^^FLIP.FOR\\		REVERSES AN ARRAY
	^^GETNNB.FOR\\		GETS THE NEXT NONBLANK IN INPUT LINE
	^^INPOST.FOR\\		CONVERTS INFIX TO POSTFIX NOTATION
	^^LIST.FOR\\		LISTS A SUMMARY OF LEGAL CALC COMMANDS
	^^MOUT.FOR\\		MULTIPLE PRECISION OUTPUT
	^^PRTCON.FOR\\		   USED BY (AND INCLUDED IN SOURCE FILE
					OF) MOUT
	^^MULADD.FOR\\		MULTIPLE PRECISION ADD
	^^MULCON.FOR\\		MULTIPLE PRECISION CONVERSIONS
	^^MULDIV.FOR\\		MULTIPLE PRECISION DIVISION
	^^MULMUL.FOR\\		MULTIPLE PRECISION MULTIPLICATION
	^^NEXTEL.FOR\\		GETS NEXT ELEMENT FROM INPUT LINE
	^^POSTVL.FOR\\		EVALUATES A POSTFIX EXPRESSION
	^^SLEND.FOR\\		DETERMINES THE LAST NONBLANK IN THE 
				INPUT LINE
	^^STRCMP.FOR\\		COMPARES STRINGS
	^^VAROUT.FOR\\		OUTPUTS THE VALUE OF VARIABLES
	^^ZERO.FOR\\		ZEROES OUT ALL OF THE VARIABLES
	^^ZNEG.FOR\\		DETERMINES IF A VARIABLE IS POSITIVE
.BLANK 3
.CENTER;^&^^MACRO modules\&
.BLANK
	^^MCR20.MAC\\		GETS COMMAND LINE FOR ONE-SHOT
	^^HALT.MAC\\		ENDS ONE-SHOT WITHOUT TIME MESSAGES
.BLANK 3
.CENTER;^&^^Document source files\&
.BLANK
	CALC.DOR	RUNOFF source for this document
	CALC.RNO	RUNOFF source for CALC USER'S GUIDE
.BLANK 3
.CENTER;^&LINK job\&
.BLANK
	CALINK.CTL	BATCH job used to link CALC
.FILL
.HL 1 INSTALLATION INSTRUCTIONS
.LM 5
The contents of the first two Save Sets is all that is needed to run 
CALC. The third Save Set is provided so that the user can make 
modifications if he so desires. The commands needed to compile and
relink CALC are as follows:
.BREAK
	@COMPILE *.FOR/LIST !ignore all error messages (warnings)
.BREAK
	@COMPILE *.MAC/LIST
.BLANK
You may now modify and recompile the appropriate modules, paying
attention to non-warning messages.
.BLANK
	@SUBMIT CALINK
.BLANK
This will produce a new executable file and SAVE it as ^&CALC.EXE\&.
In order to save the original CALC, the user should either RENAME it
before running CALINK or EDIT CALINK to SAVE CALC under a different 
name.
.HL 1 ADDITIONAL DOCUMENTATION
Following is the original documentation as written by Peter Baum.
References to specific PDP-11 features/problems are superceded
by any pertinent comments that I have made above.
.NHY
.AP
.NF
.C 80;INTRODUCTION
.j
.f
 
  This document gives information about CALC that will be of special
interest to anyone maintaining or modifying that program. It is assumed
that the reader has already read the User's Guide and therefore
understands such things as required expression syntax and what the
various CALC commands are used for. Additional documentation that is 
available includes:
.NJ
.NF
 
     1. Detailed comments in source code
     2. Flowcharts for all but the trivial subroutines
     3. Map of subroutine calls
     4. Map of a proposed overlay structure
     5. CALCDOC.MEM (this document)
 
.J
.F
.PG
.C 80;UNDERSTANDING THE STRUCTURE OF CALC
 
  Before trying to understand how the different subroutines relate to
one another, the reader should first learn something about the internal
codes and data structures.
 
.S
.nj
.nf
NUMBER REPRESENTATION: There are 9 different data types that can be
                       defined when using CALC. They are:
 
       TYPE            BYTES USED INTERNALLY
.S
      ASCII           1
HEX, INTEGER, OCTAL   4
    REAL, DECIMAL     8
   M10,M8,M16         100
 
   
.J
.F
   BLOCK.FTN  gives further details on the internal storage of such
numbers. Associated with each number is a byte that gives its type.
You will find that OCTAL and INTEGER numbers are stored internally
as INTEGER*4 numbers but are output differently because of this type
code. The file CODES.FTN gives additional information on the different
codes that are used, including those for the various operators.
 
  The overall structure of CALC can be understood by looking at the
flowchart for the following routines:
.nj
.nf
    CALC - the main routine
    CMND - determines which CALC command is requested
    INPOST - converts infix to postfix notation
    POSTVL - evaluates a postfix expression
.PG
.C 80; CALC DESIGN GOALS, NON-GOALS, AND TRADE-OFF DECISIONS
 
 
CALC DESIGN GOALS
 
1. Evaluate arithmetical expressions.
 
2. Assume the user knows FORTRAN and follows similar
  syntax rules to make it easy to learn the system.
 
3. Perform calculations in base 8, base 10, and base 16.
   Features should be biased towards those that would be
   most useful to a System Programmer.
 
4. Allow for calculations to be performed  on 16, 32, 36,
   and 64 bit integers.
 
5. Be able to code and decode single ASCII characters.
 
6. Allow the user to enter an expression to be evaluated
   or allows the user to assign the value of the expression
   to a variable. Expression can then contain that variable.
 
7. Program must be easily transportable to all presently used
   DEC systems (i.e. written in FORTRAN IV).
 
8. Allow files of commands to be executed.
 
9. Multiple precision capability designed as optional subroutines
   so that a very small version of CALC can be built with a subset of the
   capabilites available with the larger version.
 
 
 
CHARACTERISTICS THAT CALC WAS DESIGNED NOT TO HAVE:
 
1. Perform calculations that are in  a form useful when
   making dollar and cents calculations.
 
2. Design a command language that could be extended to form
   an elegant programming language.
 
 
 
TRADE-OFF DECISIONS
 
Since it is not expected that any single command line will require
a great deal of CPU time, space-time trade-off decisions should be
made to decrease the space needed to run the program.
 
.PG
.C 80;MODIFICATION CLASSES
 
 
M1  CONTAINS I/O CALLS
M2  REFERENCE TO VARIABLE LINE(80)
M3  ASSUMES MULTIPLE PRECISION NUMBERS ARE 100. DECIMAL BYTES LONG
M4  USES INTEGER*4
M5  RESERVED
M6  RESERVED
M7  RESERVED
M8  USES REAL*8
M9  INDIRECTION LEVEL SPECIFIED AS 6 (E.G. BY ITCNTV(6), OR
    BY EXPRESSIONS LIKE  LEVEL.GT.6)
M10 SETS STACK SIZE
 
 
.PG
.C 80;COMMENTS TO DESIGNERS OF FUTURE CALCULATOR PROGRAMS
.J
.F
  This section records some thoughts on the subject of designing
a calculator program that should be of interest to anyone either
designing a completely new program, writing a new version of CALC
or maintaining the present version of CALC.
 
  If you want to extend features, consider the following points.
 
.LM 10
.P -3
.F
.J
  1) "Ease of computing dollars and cents..." is a characteristic to
be avoided for the following reason. Suppose the constant 2.05 is
entered. In such a form, there is not sufficient information to
distinguish between  the "dollar and cents" type and the ordinary
real number type that requires 15 or more significant digits.
We could have a special dollar and cents mode but conversions would
add a lot of code. Note that we can not simply use REAL*8 and the
proper format statement because potential  round-off could result
in unacceptable errors. The only way to properly treat the problem
is to use integers and assume a decimal place before the last
two digits. Since the format for decimals already rounds to 15
decimal places, most dollar and cents calculations can be easily done with
the data type DECIMAL.
 
  2) The most surprising complication was the necessity of considering
the possible conversions that could occur in an expression. If you want
to add another data type, be forewarned.
 
  3) If you insist on adding control features to make CALC into a
language, please exercise intelligence and restraint. If such features
are added,
 
.LM 15
.P -3
          1) Don't call it "CALC" for you have violated a specific non-goal.
          2) Reconsider. Start by specifying the syntax for an elegant
             human engineered language that gives the capabilities you need.
 
.J
.F
.LM 10
.P -3
   4. The capability of having a default base for each level was present
in CALC for awhile and then taken out. The problem that arose was that you
had to make a call to a special file to set the default
base unless you wanted to set it every time the major file was entered. The alternative would
be to have the capability of setting the base on selective logical I/0 units
or all logical I/O units. Since it is rare that you would be switching between bases on
different logical I/O units, the feature was removed.
 
.F
.J
.PG
.LM 0
.P 5
.C 80;FEATURES THAT WORKED OUT WELL
.LM 10
.P -3
   1) The introduction of the variable "%" which holds the value of the
last expression evaluated was a language element that was invented
without fully realizing its usefulness. Perhaps  a character could be
found that is easier to type. It was an especially nice surprise to
find that the feature enabled indirect command files of CALC commands to
request that the user enter a single number. Without this feature
one would have to preceed the value with a variable and an equal sign.
It also had unexpected significance
when iteration capability was added to the *@ command.
 
 
   2) The type MULTIPLE PRECISION (M8, M10, and M16) data type was originally
created to allow for the manipulation of unsigned 32 bit numbers. During the
first attempt to transport the program to a foreign (non RSX-11M) operating
system (RSTS) it was discovered that the only FORTRAN compiler
available was limited to 16 bit integer calculations. It was nice to
know that multiple precision arithmetic was still possible so that calculations
like 20000*2 (entered as 0000020000*2) could be performed!
 
 
   3) The limit of 99 digits allows for the expression (in base 10)
of the largest magnitudes that can be represented by REAL*8 floating
point numbers using IBM's data format. The number is roughly
7.2370*10**75. The extra digits are important when simulating fractions
by having the result multiplied by a power of 10.
 
.PG
.LM 0
.P 5
.C 80;DESIGN PROBLEMS
 
   There are several data types that one might wish to eliminate.
Specifically, it would be nice to remove the distinctions between multiple
precision numbers (bases still need specification), integers (bases specified), and
reals. It would be easy to remove the non-multiple precision data types and
let all calculations be done in multiple precision. The distinction was made
to allow a very small version of CALC  to be created on machines that could not
afford the space to have any of the multiple precision capability. If such
capability is removed,
The vector VBLS (which holds the values of the variables) and the stacks
can be made 8 bytes wide.
 
 
  The alternative of going to variable length numbers to represent multiple
precision numbers, integers, and reals has definite space advantages. The
problem would be to economically simulate all of the floating point functions.
There would also be additional code needed to manipulate such numbers in the
stacks.
 
.PG
.C 80;REFERENCE TO COMMONS BY MODULE NAME
.NF
.NJ
 
 () indicates that data in a common block is modified as a result of a call
 to that routine with an appropriate variable in the routine's argument list.
 
 
as an argument in a call to that routine.
BLANK  CONS   DECIDE DIGV   ERROR  ITERA  STACK  V
---------------------------------------------------------------------
AT     AT     -      -      -      AT     -      -
BASCNG -      -      BASCNG -      -      -      -
BLOCK  BLOCK  BLOCK  BLOCK  BLOCK  BLOCK  BLOCK  BLOCK  
CALBIN -      CALBIN -      -      -      CALBIN CALBIN
CALC   CALC   -      CALC   -      CALC   -      -
-      -      -      -      -      -      CALUN  -
CMND   -      -      -      -      CMND   -      -
-      -      -      -      -      -      -      -         CODES
-      -      -      -      -      -      (CONTYP)-
DECLR  DECLR  -      -      -      -      -       DECLR
-      -      -      -      -      -      -      -         DFLOAT
-      -      -      -      -      -      -      -         DTANH
ERRCX  ERRCX  -      -      -      -      -      -
-      -      -      -      -      -      -      -         ERRMSG
-      -      -      -      -      -      -      -         FLIP
-      -      -      -      -      -      -      -         GETMCR
GETNNB GETNNB -      -      -      -      -      -
INPOST -      -      -      INPOST -      INPOST INPOST
-      -      -      -      -      -      -      -         LIST
-      -      -      MOUT   -      -      -      MOUT
-      -      -      -      -      -      MULADD -
-      -      -      -      -      -      (MULCON)-
-      -      -      -      -      -      MULDIV -
-      -      -      -      -      -      MULMUL -
NEXTEL NEXTEL -      NEXTEL NEXTEL -      -      NEXTEL
POSTVL -      -      -      -      -      POSTVL POSTVL
SLEND  SLEND  -      -      -      -      -      -
STRCMP STRCMP -      -      -      -      -      -
-      VAROUT -      VAROUT -      -      -      VAROUT
-      -      -      -      -      -      -      ZERO
-      -      -      -      -      -      -      ZNEG
.PG
.C 80;FORTRAN DATA TYPES BY MODULE NAME
 
REAL*8    INTEGER*4 INTEGER*2 LOGICAL*1 NO VARIABLES
--------------------------------------------------
-         -         AT        AT
-         -         BASCNG    BASCNG
-         -         BLOCK     BLOCK
CALBIN    CALBIN    CALBIN    CALBIN
-         -         CALC      CALC
CALUN     CALUN     CALUN     CALUN
-         -         CMND      CMND
-         -         -         -          CODES
CONTYP    CONTYP    CONTYP    CONTYP
-                   DECLR     DECLR
DFLOAT    DFLOAT         -         -
DTANH     -         -         -
-         -         ERRCX     ERRCX
-         -         ERRMSG    -
-         -         FLIP      FLIP
-         -         GETMCR    GETMCR
-         -         GETNNB    GETNNB
-         -         INPOST    INPOST
-         -         -         -          LIST
-         -         MOUT      MOUT
-         -         MULADD    MULADD
-         -         MULCON    MULCON
-         -         MULDIV    MULDIV
-         MULMUL    MULMUL    MULMUL
NEXTEL    NEXTEL    NEXTEL    NEXTEL
-         -         POSTVL    POSTVL
-         -         SLEND     SLEND
-         -         STRCMP    STRCMP
VAROUT    VAROUT    VAROUT    VAROUT
-         -         ZERO      ZERO
ZNEG      ZNEG      ZNEG      ZNEG
.PG
.C 80;PROBLEM FILE
 
 
26-Sep-77
  1. Since we can't properly convert IABS(-2147483648) to a positive
    INTEGER*4 2's compliment number, when output in OCTAL the result is
    -20000000000 and in HEX  -80000000.    I'm not sure how to
    code this for other machines and compilers. In FORTRAN-IV PLUS
    (DEC compiler) running under RSX11M we have IABS(-2147483648) evaluate
    as -2147483648 so things print nicely. Could be a real problem on other
    machines.
  
  2. Above mentioned compiler doesn't trap expressions like
            1+2147483647
    Decided  for  now  not   to  call ERRTST and ERRSET to trap errors but
  let the run-time system field the errors and print out those messages
  that mean little to the user. The problem is that everybody has routines
  like ERRSET but they are all different in some respects.
 
 
  3. At present, changing a variable type does not cause the variable
    to be undefined. This would be easy to fix. For now, left that way
    because it allows one to decode (somewhat) the internal values held
    by different data types.
 
 
  4. Some compiler/operating system/terminals don't handle output properly
    when more than a buffer full of characters are to be output. Specifically,
    when RSX-11M version 3.0/ FCS  outputs more than 80 characters to a VT-52
    no LF is sent so that the line is overwritten.
.PG
.C 80;ADDING A UNARY FUNCTION
 
  1) In subroutine NEXTEL, the function names are identified and the 
    function code is passed to INPOST, so
 
   a. Add 1 to the value defined by FCNT's data statement.
   b. Add the function name to the data statement for array FUNCT.
      Be certain that a subset of the first n characters of that
      function name is not a previously specified function name. If
      it does, you will have to rearrange the order of the functions,
      also changing the array FUNVAL. For example, it is important
      because of the linear search of names, that "ALOG10" be placed
      before "ALOG".
    c) Add the character count and function code to the data statement
      for vector FUNVAL.
    d) Update CODES.FTN and INPOST to reflect this new function code.
       (This change is to the comments that give a table of all the codes.)
    e) Note that space has already been provided for the above additions.
      This was done to get an idea about total task size if additions were
     added. What this means is that the blanks at the end of FUNCT and
     the zero's at the end of FUNVAL are to be replaced.
 
 
2)  CALUN must be modified to make the unary function calculation. Notice that
   real to real functions are all done at the section starting at 10000.
   K holds the function code, K2 the data type of the argument. Unless the
   function is only a couple of line, actual value calculations should be
   done in a separate subroutine.
.PG
.C 80;A COMPARISON WITH THE COMPETITION
IBM - CALC-370
.J
.F
 
   The University of Western Ontario produced a program
called CALC-370 that runs under the CMS/370 (Conversational
Monitor System) operating system. This comparison is made using the
CALC-370 User's Guide as a reference. It is dated
October 20, 1973 and is for Version 1 -- level 2 of the program.
Comparison is made with CALC (DIGITAL) version 1.0 as of 1-OCT-77.
 
 
   Similarities: Both programs allow expressions to be entered for
immediate evaluation. The letters A-Z can be
used as registers and have default types as in FORTRAN IV. Function
routines from their respective FORTRAN-IV libraries are sometimes 
called for such functions as COSINE and SINE. The equal sign is
used as an assignment operator and allows one to assign
values to a register.
 
 
 Differences: The programs are each oriented toward slightly different
audiences, with CALC-370 providing a number of functions of
interest to the engineer or statistician. DIGITAL's CALC (hereafter
referred to as CALC-DEC) emphasizes capabilities
which would be of interest to the system programmer on a variety of
machines.
.NJ
.NF
 
 
        CALC-370                             CALC-DEC
 
Prompt is with a question mark.        Prompt is with  CALC>
 
Invoked with the command CALC          If installed under RSX-11M version 3.0
                                       invoked with the command   CAL
 
CALC-370 error messages begin          CALC-DEC error messages begin with
with "CALCERR"                         *** ERROR ***
 
If FLOAT does not have an integer      If FLOAT does not have an integer
argument, it is converted to one       argument, an error message
and processing continues.              is produced and the error entry
                                       point in the mainline is entered.
 
FIX function                           called IFIX
LOG                                    called ALOG
LOG10                                  called ALOG10
 
If FIX has an integer argument or      Treated by CALC-DEC as errors and an
FLOAT has a real argument, the         appropriate error message is printed.
function call is ignored.              Expression is not evaluated and the
                                       mainline's error entry point is entered.
 
.TP 8
Uses IBM SYSTEM/360 FORTRAN IV         Uses FORTRAN-IV PLUS Object Time
library subroutines (see               library if run under RSX-11M V3.0
IBM SRL GC28-6596)                     Can be compiled with other compilers.
 
Uses CLEAR * to zero all variables.    Uses *ZERO to set all variables to zero.
 
Initially all variables are zeroed.    Initially all variables are undefined.
 
CLEAR A or CLEAR A,B clears the        A=0 and A=B=0 have the same effect.
specified variables.
 
Lower case letters are interpreted     RSX11M V3.0 can be used to convert lower
as upper case (by operating system?)   case entries to upper case.
 
DISPLAY enables printing whenever a    *VIEW does the same for CALC-DEC
variable changes value.
 
NODISPLAY disables printing whenever   *NOVIEW
a variable changes value.
 
Blanks separate command parameters     Except for the iteration specification
from each other and at least one       for the *@ command, command parameters
is required.                           are separated from each other by single
                                       commas.
 
A command and its parameters are       It is not a requirement that the
separated by at least one blank.       arguments of a command be separated
                                       from its parameters by at least one 
                                       blank.
 
All commands may be abreviated to      All commands require the character '*'
their first letter, first two          and at least the first letter.
letters etc.                           Declarations require the complete
                                       spelling.
 
A file of commands can be executed     A file of commands can be executed using
using the PERFORM command.             *@.
 
session terminated by the command      session terminated by either *STOP,
QUIT                                   *EXIT, or a control Z (if at command
                                       level 1).
 
REAL*8 variables declared using        REAL*8 variables declared using command
command REAL.                          *REAL.
 
INTEGER*4 variables declared using     INTEGER*4 variables declared using
using command INTEGER.                 *INTEGER.
 
Values of registers are typed by       Values of registers are displayed by
using the command TYPE.                typing the variable's name.
 
Limit   of   INTEGER*4 registers       Limit of INTEGER*4 registers is the
is  (2**31)-1 . Overflow is trapped.   entire range of a 32 bit 2's compliment
                                       number when run under RSX11M Version 3.0.
                                       Thus -(2**31) can be represented.
                                       Under RSX11M's FORTRAN-IV PLUS overflow
                                       is not trapped, allowing for convenient
                                       "modulo" arithmetic that might be useful
                                       when doing system programming.
 
When an invalid character is found     When a single invalid character is found
in the input line, that single         in an expression, an error message is
character is identified.               printed and that character as well as all
                                       the following characters are output.
 
REAL*8 magnitude is 0 or 16**(-65)     On a PDP-11 we have REAL*8 magnitudes of
through (1-(16**(-14)))*16**63         0 or between 2**(-128) and
or approximately 5.398*10**(-79)       (1-(2**(-56))*2**127 which is equivalent
through 7.237*10**75. Precision is     to 16**(-32) and (1-(16*(-14))*.5*16**32
at least 15.9 decimal digits.          or approximately
                                       0.29387*10**(-38) and 1.70141*10**38
                                       Precision is approximately 16.8 decimal
                                       digits.
 
I**R is real                           I**R is integer
 
-2**2 has value -4                     -2**2 has value +4
 
.PG
.C 80;FEATURES  OF CALC-370 NOT AVAILABLE IN CALC-DEC
 
    The following functions are available only with CALC-370. CALC-DEC could be
easily extended to process these unary functions provided that FORTRAN IV
library routines of that type existed and that task image size was not a
problem.
 
ACOS(=ARCOS)   arc Cosine
ASIN(=ARSIN)   arc Sine   for ABS(X)<1,
                          X+(1/2.)*(1/3.)*X**3+(1/2.)*(3/4.)*(1/5.)*X**5
 
COSH           hyperbolic Cosine   (e**X + e**(-X))/2
 
COTAN          cotangent           COS(X)/SIN(X)
 
ERF            error function
 
ERFC           compliment error function
 
GAMMA          gamma function
 
LGAMMA         log Gamma
 
SINH           hyperbolic Sine     (e**X - e**(-X))/2
 
TAN            tangent             SIN(X)/COS(X)
 
 
 
      CALC-370                               CALC-DEC
 
 
Commands REAL and INTEGER can be   It was decided to follow the requirements of
abreviated "R" and "I"             FORTRAN IV and require the full spelling.
                                   Note also that *REAL must be
                                   distinguished from *READ. Commands which do
                                   not make data type declarations may be
                                   abreviated to the asterisks and the first
                                   character.
 
 
Declarations can have an           Feature can be easily added if found to be
argument of "*" to represent       useful. Experience thus far does not indicate
all variables.                     that it would be used very often.
 
The value of more than one         Feature could be added if found useful.
variable can be displayed using
the TYPE command. All variables
can be displayed using the
the command TYPE *
 
CALC-370 traps program             Function call errors are usually trapped
interrupts and gives error         by the FORTRAN run time system. Allowing
messages when function calls       integer overflow is useful when doing
have arguments that are out of     system programming. Could be modified
range.                             using ERRSET and ERRTST but would not be
                                   directly transportable as such.
 
 
.PG
.C 80;FEATURES OF CALC-DEC NOT AVAILABLE WITH CALC-370
 
  In addition to the 26 registers denoted by single alphabetic characters
(which are also available with CALC-370), % is a special register which
initially holds an integer value that represents the version number of 
the CALC-DEC program. It may be treated like any other register except
that it is automatically assigned the value and type of the last
complete expression that has been evaluated.
 
 
 
          CALC-DEC                      CALC-370
 
 
  All variables other than % are     variables are initialized to zero.
initially undefined. The default
data types are similar to those
of CALC-370. If an attempt is made
to use an undefined variable in an
expression an error message results.
 
Functions not availabe with CALC-370:
 
ABS (=DABS)                          Can be simulated with SQRT(X*X)
IABS
AINT                                 Can be simulated with an appropriate
INT (=IDINT)                         assignment statement.
 
 
Expressions can be evaluated without
using an equal sign. Value of
expression is automatically assigned
to the register %.
 
Multiple assignments are legal, e.g.
A=B=C=812.
 
A list of valid commands will be output
if a question mark is entered.
 
Valid data types not available with
CALC-370:
 
1) OCTAL (32 bit integer)
2) HEXADECIMAL (32 bit integer)
3) REAL and DECIMAL to control the
  output form of REAL*8 variables.   Output uses D format if magnitude is
4) multiple precision base 10        outside the range 0.1, 10**17 - 1
   (99 digits)
5) multiple precision base 8
   (99 digits)
6) multiple precision base 16
   (99 digits)
7) ASCII
 
 
Exponentiation operator may be either
** or !
 
Constants may be entered using E     CALC-370 limits real constants to 23 digits
or D format as well as a string      and a decimal point.
of digits and a decimal point.
Limits are only a result of the 
input buffer line length.
 
Immediate base specifications are    Not appropriate as only base 10 numbers are
allowed.                             allowed.
 
Default base specification for       Not appropriate as only base 10 numbers are
for constants can be changed.        allowed.
 
Unary operators + and - are          Expressed as A*(-B) for CALC-370
allowed. Expressions such as
A*-B are allowed.
 
*@ allows for nested calls to        CALC-370 allows no nested calls to files of
up to 5 files.  This limit could     commands.
be easily increased. Nested calls
must be to files with distinct
names.
 
Iteration is allowed on files of 
CALC-DEC commands.
 
*C can be used to document files of
CALC-DEC commands.
 
*R allows a command to be entered
while executing a file of CALC-DEC
commands.
 
*V n  allows precise control over
output, selectively turning off
output of evaluated expressions and
lines read from command files.
 
.PG
      Possible differences:
 
1. CALC-DEC allows an RSX-11M call if installed as ...CAL so that
   a one shot execution can be performed using the argument of the
   call.
 
2. Blanks are ignored by CALC-DEC except after ASCII constant specifications
   and iteration specifications for the *@ command.
 
3. Library functions' range and accuracy.
 
4. Error checking for correct expression syntax.
.PG
.C 80;DATA TYPE CONVERSION TABLES
 
 
 
.NHY
.PS 60,80
.UC
.NF
.NJ
		* / + -  CONVERSIONS
		--------------------
.B2
	OPERAND	OPERAND	MODIFY		MODIFY		FUNCTION
	1	2	OPERAND 1	OPERAND 2	VALUE
	-------	-------	---------	---------	--------
.B2
1  1	ASCII	ASCII	INTEGER  4	INTEGER  4	INTEGER  4
   2		DECIMAL	DECIMAL  2	(DECIMAL)0	DECIMAL  2
   3		HEX	HEX      3	(HEX)	 0	HEX      3
   4		INTEGER	INTEGER  4	(INTEGER)0	INTEGER  4
   5		M10	M10      5	(M10)	 0	M10      5
   6		M8	M8       6 	(M8)	 0	M8       6
   7		M16     M16      7	(M16)	 0	M16      7
   8		OCTAL	OCTAL    8	(OCTAL)	 0	OCTAL    8
   9		REAL	REAL     9	(REAL)	 0	REAL     9
.B1
2  1	DECIMAL	ASCII	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   2		DECIMAL	(DECIMAL)0	(DECIMAL)0	DECIMAL  2
   3		HEX	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   4		INTEGER	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   5		M10	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   6		M8	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   7		M16	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   8		OCTAL	(DECIMAL)0	DECIMAL  2	DECIMAL  2
   9		REAL	(DECIMAL)0	(REAL)	 0	DECIMAL  2
.B1
3  1	HEX	ASCII	(HEX)	 0	HEX      3	HEX      3
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	(HEX)	 0	(HEX)	 0	HEX	 3
   4		INTEGER	(HEX)	 0	(INTEGER)0	HEX	 3
   5		M10	M16	 7	M16	 7	M16	 7
   6		M8	M16	 7	M16	 7	M16	 7
   7		M16	M16	 7	(M16)	 0	M16	 7
   8		OCTAL	(HEX)	 0	(OCTAL)	 0	HEX	 3
   9		REAL	REAL	 9	(REAL	 0)	REAL	 9
.B1
4  1	INTEGER	ASCII	(INTEGER)0	INTEGER	 4	INTEGER	 4
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	(INTEGER)0	(HEX)	 0	HEX	 3
   4		INTEGER	(INTEGER)0	(INTEGER)0	INTEGER	 4
   5		M10	M10	 5	(M10)	 0	M10	 5
   6		M8	M10	 5	M10	 5	M10	 5
   7		M16	M16	 7	(M16)	 0	M16	 7
   8		OCTAL	(INTEGER)0	(OCTAL)	 0	INTEGER	 4
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9
.B1
5  1	M10	ASCII	(M10)	 0	M10	 5	M10	 5
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	M16	 7	M16	 7	M16	 7
   4		INTEGER	(M10)	 0	M10	 5	M10	 5
   5		M10	(M10)	 0	(M10)	 0	M10	 5
   6		M8	(M10)	 0	M10	 5	M10	 5
   7		M16	M16	 7	(M16)	 0	M16	 7
   8		OCTAL	(M10)	 0	M10	 5	M10	 5
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9
.B1
6  1	M8	ASCII	(M8)	 0	M8	 6	M8	 6
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	M16	 7	M16	 7	M16	 7
   4		INTEGER	M10	 5	M10	 5	M10	 5
   5		M10	M10	 5	(M10)	 0	M10	 5
   6		M8	(M8)	 0	(M8)	 0	M8	 6
   7		M16	M16	 7	(M16)	 0	M16	 7
   8		OCTAL	(M8)	 0	M8	 6	M8	 6
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9
.B1
7  1	M16	ASCII	(M16)	 0	M16	 7	M16	 7
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	(M16)	 0	M16	 7	M16	 7
   4		INTEGER	(M16)	 0	M16	 7	M16	 7
   5		M10	(M16)	 0	M16	 7	M16	 7
   6		M8	(M16)	 0	M16	 7	M16	 7
   7		M16	(M16)	 0	(M16)	 0	M16	 7
   8		OCTAL	(M16)	 0	M16	 7	M16	 7
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9
.B1
8  1	OCTAL	ASCII	(OCTAL)	 0	OCTAL	 8	OCTAL	 8
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	HEX	 3	(HEX)	 0	HEX	 3
   4		INTEGER	(OCTAL)	 0	(INTEGER)0	INTEGER	 4
   5		M10	M10	 5	(M10)	 0	M10	 5
   6		M8	M8	 6	(M8)	 0	M8	 6
   7		M16	M16	 7	(M16)	 0	M16	 7
   8		OCTAL	(OCTAL)	 0	(OCTAL)	 0	OCTAL	 8
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9
.B1
9  1	REAL	ASCII	(REAL)	 0	REAL	 9	REAL	 9
   2		DECIMAL	DECIMAL	 2	(DECIMAL)0	DECIMAL	 2
   3		HEX	(REAL)	 0	REAL	 9	REAL	 9
   4		INTEGER	(REAL)	 0	REAL	 9	REAL	 9
   5		M10	(REAL)	 0	REAL	 9	REAL	 9
   6		M8	(REAL)	 0	REAL	 9	REAL	 9
   7		M16	(REAL)	 0	REAL	 9	REAL	 9
   8		OCTAL	(REAL)	 0	REAL	 9	REAL	 9
   9		REAL	(REAL)	 0	(REAL)	 0	REAL	 9
.B4
.PG
		  **  CONVERSIONS
		  ---------------
.B2
	OPERAND	OPERAND	MODIFY		MODIFY		FUNCTION   FUNC.
	1	2	OPERAND 1	OPERAND 2	VALUE	   CODE
	-------	-------	---------	---------	--------   ----
.B2
1  1	ASCII	ASCII	INTEGER  4	INTEGER  4	INTEGER  4  4
   2		DECIMAL	DECIMAL  2	(DECIMAL)0	DECIMAL  2  1
   3		HEX	HEX      3	(HEX)	 0	HEX      3  4
   4		INTEGER	INTEGER  4	(INTEGER)0	INTEGER  4  4
   5		M10	INTEGER	 4	REAL	 9	INTEGER	 4  3
   6		M8	INTEGER	 4	REAL	 9	INTEGER	 4  3
   7		M16	INTEGER	 4	REAL	 9	INTEGER	 4  3
   8		OCTAL	INTEGER	 4	INTEGER	 4	INTEGER	 4  4
   9		REAL	INTEGER	 4	(REAL)	 0	INTEGER	 4  3
.B1
2  1	DECIMAL	ASCII	(DECIMAL)0	INTEGER	 4	DECIMAL  2  2
   2		DECIMAL	(DECIMAL)0	(DECIMAL)0	DECIMAL  2  1
   3		HEX	(DECIMAL)0	(HEX)	 0	DECIMAL  2  2
   4		INTEGER	(DECIMAL)0	(INTEGER)0	DECIMAL  2  2
   5		M10	(DECIMAL)0	REAL	 9	DECIMAL  2  1
   6		M8	(DECIMAL)0	REAL	 9	DECIMAL  2  1
   7		M16	(DECIMAL)0	REAL	 9	DECIMAL  2  1
   8		OCTAL	(DECIMAL)0	(OCTAL)	 0	DECIMAL  2  2
   9		REAL	(DECIMAL)0	(REAL)	 0	DECIMAL  2  1
.B1
3  1	HEX	ASCII	(HEX)	 0	INTEGER	 4	HEX	 3  4
   2		DECIMAL	(HEX)	 0	(DECIMAL)0	HEX	 3  3
   3		HEX	(HEX)	 0	(HEX)	 0	HEX	 3  4
   4		INTEGER	(HEX)	 0	(INTEGER)0	HEX	 3  4
   5		M10	(HEX)	 0	REAL	 9	HEX	 3  3
   6		M8	(HEX)	 0	REAL	 9	HEX	 3  3
   7		M16	(HEX)	 0	REAL	 9	HEX	 3  3
   8		OCTAL	(HEX)	 0	(OCTAL)	 0	HEX	 3  4
   9		REAL	(HEX)	 0	(REAL)	 0	HEX	 3  3
.B1

4  1	INTEGER	ASCII	(INTEGER)0	INTEGER	 4	INTEGER	 4  4
   2		DECIMAL	(INTEGER)0	(DECIMAL)0	INTEGER	 4  3
   3		HEX	(INTEGER)0	(HEX)	 0	INTEGER	 4  4
   4		INTEGER	(INTEGER)0	(INTEGER)0	INTEGER	 4  4
   5		M10	(INTEGER)0	REAL	 9	INTEGER	 4  3
   6		M8	(INTEGER)0	REAL	 9	INTEGER	 4  3
   7		M16	(INTEGER)0	REAL	 9	INTEGER	 4  3
   8		OCTAL	(INTEGER)0	(OCTAL)	 0	INTEGER	 4  4
   9		REAL	(INTEGER)0	(REAL)	 0	INTEGER	 4  3
.B1
5  1	M10	ASCII	(M10)	 0	INTEGER	 4	M10	 5  6
   2		DECIMAL	REAL	 9	(DECIMAL)0	REAL	 9  1
   3		HEX	(M10)	 0	(HEX)	 0	M10	 5  6
   4		INTEGER	(M10)	 0	(INTEGER)0	M10	 5  6
   5		M10	(M10)	 0	INTEGER	 4	M10	 5  6
   6		M8	(M10)	 0	INTEGER	 4	M10	 5  6
   7		M16	(M10)	 0	INTEGER	 4	M10	 5  6
   8		OCTAL	(M10)	 0	(OCTAL)	 0	M10	 5  6
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9  1
.B1
6  1	M8	ASCII	(M8)	 0	INTEGER	 4	M8	 6  5
   2		DECIMAL	REAL	 9	(DECIMAL)0	REAL	 9  1
   3		HEX	(M8)	 0	(HEX)	 0	M8	 6  5
   4		INTEGER	(M8)	 0	(INTEGER)0	M8	 6  5
   5		M10	(M8)	 0	INTEGER	 4	M10	 5  5
   6		M8	(M8)	 0	INTEGER	 4	M8	 6  5
   7		M16	(M8)	 0	INTEGER	 4	M16	 7  5
   8		OCTAL	(M8)	 0	(OCTAL)	 0	M8	 6  5
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9  1
.B1
7  1	M16	ASCII	(M16)	 0	INTEGER	 4	M16	 7  7
   2		DECIMAL	REAL	 9	(DECIMAL)0	REAL	 9  1
   3		HEX	(M16)	 0	(HEX)	 0	M16	 7  7
   4		INTEGER	(M16)	 0	(INTEGER)0	M16	 7  7
   5		M10	(M16)	 0	INTEGER	 4	M16	 7  7
   6		M8	(M16)	 0	INTEGER	 4	M16	 7  7
   7		M16	(M16)	 0	INTEGER	 4	M16	 7  7
   8		OCTAL	(M16)	 0	(INTEGER)0	M16	 7  7
   9		REAL	REAL	 9	(REAL)	 0	REAL	 9  1
.B1
8  1	OCTAL	ASCII	(OCTAL)	 0	INTEGER	 4	OCTAL	 8  4
   2		DECIMAL	(OCTAL)	 0	(DECIMAL)0	OCTAL	 8  3
   3		HEX	(OCTAL)	 0	(HEX)	 0	OCTAL	 8  4
   4		INTEGER	(OCTAL)	 0	(INTEGER)0	OCTAL	 8  4
   5		M10	(OCTAL)	 0	REAL	 9	OCTAL	 8  3
   6		M8	(OCTAL)	 0	REAL	 9	OCTAL	 8  3
   7		M16	(OCTAL)	 0	REAL	 9	OCTAL	 8  3
   8		OCTAL	(OCTAL)	 0	(OCTAL)	 0	OCTAL	 8  4
   9		REAL	(OCTAL)	 0	(REAL)	 0	OCTAL	 8  3
.B1
9  1	REAL	ASCII	(REAL)	 0	INTEGER	 4	REAL	 9  2
   2		DECIMAL	(REAL)	 0	(DECIMAL)0	REAL	 9  1
   3		HEX	(REAL)	 0	(HEX)	 0	REAL	 9  2
   4		INTEGER	(REAL)	 0	(INTEGER)0	REAL	 9  2
   5		M10	(REAL)	 0	REAL	 9	REAL	 9  1
   6		M8	(REAL)	 0	REAL	 9	REAL	 9  1
   7		M16	(REAL)	 0	REAL	 9	REAL	 9  1
   8		OCTAL	(REAL)	 0	(OCTAL)	 0	REAL	 9  2
   9		REAL	(REAL)	 0	(REAL)	 0	REAL	 9  1
.B4
.PG
	** FUNCTION CODES
	-----------------
.B2
RESULT	FUNCTION	CODE
------	--------	----
.B1
REAL	REAL**REAL	 1
REAL	REAL**INTEGER	 2
INTEGER	INTEGER**REAL	 3
INTEGER	INTEGER**INTEGER 4
M8	M8**INTEGER	 5
M10	M10**INTEGER	 6
M16	M16**INTEGER	 7
.F
.J