dc is an arbitrary precision arithmetic
package. The overall structure of dc is a
stacking (reverse Polish) calculator i.e. numbers are stored on a stack.
Adding a number pushes it onto the stack. Arithmetic operations pop arguments
off the stack and push the results. See also the
bc(1) utility, which is a
preprocessor for dc providing infix
notation and a C-like syntax which implements functions and reasonable control
structures for programs. The options are as follows:

Enable extended register mode. This mode is used by
bc(1) to allow more than 256
registers. See Registers
for a more detailed description.

If neither expression nor
file are specified on the command line,
dc reads from the standard input. Otherwise
expression and
file are processed and
dc exits.

Ordinarily, dc operates on decimal integers,
but one may specify an input base, output base, and a number of fractional
digits (scale) to be maintained. Whitespace is ignored, except where it
signals the end of a number, end of a line or when a register name is
expected. 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 and letters A-F. It may be preceded by an
underscore (‘_’) to input a negative number. A number may
contain a single decimal point. A number may also contain the characters
A-F, with the values 10-15.

The top two values on the stack are added (+), subtracted (-), multiplied
(*), divided (/), remaindered (%), divided and 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.

For addition and subtraction, the scale of the result is the maximum of
scales of the operands. For division the scale of the result is defined by
the scale set by the k operation. For
multiplication, the scale is defined by the expression
min(a+b,max(a,b,scale)), where
a and b are the
scales of the operands, and scale is the
scale defined by the k operation. For
exponentiation with a non-negative exponent, the scale of the result is
min(a*b,max(scale,a)), where
a is the scale of the base, and
b is the value
of the exponent. If the exponent is negative, the scale of the result is
the scale defined by the k operation.

In the case of the division and modulus operator (~), the resultant quotient
is pushed first followed by the remainder. This is a shorthand for the
sequence:

Pop the top value from the stack. If that value is a number, compute the
integer part of the number modulo 256. If the result is zero, push an
empty string. Otherwise push a one character string by interpreting the
computed value as an ASCII character.

If the top value is a string, push a string containing the first character
of the original string. If the original string is empty, an empty string
is pushed back. The a operator is a
non-portable extension.

The top two numbers are popped from the stack and compared. A one is
pushed if the top of the stack is equal to the second number on the stack.
A zero is pushed otherwise. This is a non-portable extension.

Pop the top value from the stack. The recursion level is popped by that
value and, following that, the input is skipped until the first occurrence
of the M operator. The
J operator is a non-portable extension,
used by the bc(1) command.

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.

The top of the stack is popped. If the top of the stack is a string, it is
printed without a trailing newline. If the top of the stack is a number,
it is interpreted as a base 256 number, and each digit of this base 256
number is printed as an ASCII character, without a trailing newline.

Replaces the number on the top of the stack with its length. The length of
a string is its number of characters. The length of a number is its number
of digits, not counting the minus sign and decimal point. The length of a
zero value is its scale.

Puts the bracketed ASCII string onto the top of the stack. If the string
includes brackets, these must be properly balanced. The backslash
character (‘\’) may be used as an escape character, making
it possible to include unbalanced brackets in strings. To include a
backslash in a string, use a double backslash.

These operations are variants of the comparison operations above. The
first register name is followed by the letter ‘e’ and
another register name. Register x will be
executed if the relation is true, and register
y will be executed if the relation is
false. This is a non-portable extension.

The top two numbers are popped from the stack and compared. A one is
pushed if the top of the stack is less than the second number on the
stack. A zero is pushed otherwise. This is a non-portable extension.

The top two numbers are popped from the stack and compared. A one is
pushed if the top of stack is less than or equal to the second number on
the stack. A zero is pushed otherwise. This is a non-portable
extension.

Registers have a single character name x, where
x may be any character, including space, tab
or any other special character. If extended register mode is enabled using the
-x option and the register identifier
x has the value 255, the next two characters
are interpreted as a two-byte register index. The set of standard single
character registers and the set of extended registers do not overlap. Extended
register mode is a non-portable extension.

for trying to set a scale that is too large. A scale must be representable
as a 32-bit unsigned number.

Q command argument exceeded string execution depth

for trying to pop the recursion level more than the current recursion
level.

Q command requires a number >= 1

for trying to pop an illegal number of recursion levels.

recursion too deep

for too many levels of nested execution.

The recursion level is increased by one if the
x or ?
operation or one of the compare operations resulting in the execution of
register is executed. As an exception, the recursion level is not
increased if the operation is executed as the last command of a string.
For example, the commands

[lax]sa
1 lax

will execute an endless loop, while the commands

[laxp]sa
1 lax

will terminate because of a too deep recursion level.

J command argument exceeded string execution depth

for trying to pop the recursion level more than the current recursion
level.

While fractional input in base 10 is always exact, other bases may suffer from
unintuitive rounding. To avoid surprising results, plain integer division can
be used instead of the corresponding floating point notation.