DC(I)                        2/8/75                         DC(I)


     dc - desk calculator


     dc [ file ]


     Dc is an arbitrary precision arithmetic package.  Ordinarily

     it  operates  on  decimal  integers,  but one may specify an

     input base, output base, and a number of  fractional  digits

     to be maintained.  The overall structure of dc is a stacking

     (reverse Polish) calculator.  If an argument is given, input

     is  taken  from  that  file  until  its  end,  then from the

     standard input.  The following constructions are recognized:


           The value of the number is pushed  on  the  stack.   A

           number  is  an  unbroken string of the digits 0-9.  It

           may be preceded by an underscore _ to input a negative

           number.  Numbers may contain decimal points.

     +  -  *  %  ^

           The top  two  values  on  the  stack  are  added  (+),

           subtracted   (-),   multiplied   (*),   divided   (/),

           remaindered  (%),  or  exponentiated  (^).   The   two

           entries are popped off the stack; the result is pushed

           on the stack in their place.  Any fractional  part  of

           an exponent is ignored.

     sx     The top of the stack is  popped  and  stored  into  a

           register  named  x,  where x may be any character.  If

           the s is capitalized, x is treated as a stack and  the

           value is pushed on it.

     lx     The value in register x is pushed on the stack.   The

           register  x  is not altered.  All registers start with

           zero value.  If the l is capitalized,  register  x  is

           treated  as  a  stack and its top value is popped onto

           the main stack.

     d      The top value on the stack is duplicated.

     p      The top value on the stack is printed.  The top value

           remains unchanged.

     f      All values on the stack and in registers are printed.

     q      exits  the  program.   If  executing  a  string,  the

           recursion   level   is   popped   by  two.   If  q  is

           capitalized, the top value on the stack is popped  and

           the string execution level is popped by that value.

     x      treats the top element of the stack  as  a  character

           string and executes it as a string of dc commands.

     [ ... ]puts the bracketed ascii string onto the top  of  the


     <x  >x  =x

           The top two elements  of  the  stack  are  popped  and

           compared.   Register  x  is  executed if they obey the

           stated relation.

     v      replaces the top element on the stack by  its  square

           root.  Any existing fractional part of the argument is

           taken into account, but otherwise the scale factor  is


     !      interprets the rest of the line as a UNIX command.

     c      All values on the stack are popped.

     i      The top value on the stack is popped and used as  the

           number radix for further input.

     o      The top value on the stack is popped and used as  the

           number radix for further output.

     k      the top of the stack is popped,  and  that  value  is

           used  as  a non-negative scale factor: the appropriate

           number of places are printed on output, and maintained

           during  multiplication,  division, and exponentiation.

           The interaction  of  scale  factor,  input  base,  and

           output  base  will  be  reasonable  if all are changed


     z      The stack level is pushed onto the stack.

     ?      A line of  input  is  taken  from  the  input  source

           (usually the console) and executed.

     An example which prints the first ten values of n! is





     bc (I), which is  a  preprocessor  for  dc  providing  infix

     notation  and a C-like syntax which implements functions and

     reasonable control structures for programs.


     (x) ? for unrecognized character x.

     (x) ? for not enough elements on the stack to  do  what  was

     asked by command x.

     `Out of space' when the free list  is  exhausted  (too  many


     `Out of headers' for too many numbers being kept around.

     `Out of pushdown' for too many items on the stack.

     `Nesting Depth' for too many levels of nested execution.