```

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

NAME

dc - desk calculator

SYNOPSIS

dc [ file ]

DESCRIPTION

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:

number

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

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

stack.

<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

ignored.

!      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

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

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

together.

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

[la1+dsa*pla10>y]sy

0sa1

lyx

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.

DIAGNOSTICS

(x) ? for unrecognized character x.

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

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

digits).

`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.

BUGS

```