dc - an arbitrary precision calculator
Dc is a reverse-polish desk calculator which supports unlimited precision
arithmetic. It also allows you to define and call macros. Normally dc
reads from the standard input; if any command arguments are given to it,
they are filenames, and dc reads and executes the contents of the files
before reading from standard input. All normal output is to standard
output; all error output is to standard error.
A reverse-polish calculator stores numbers on a stack. Entering a number
pushes it on the stack. Arithmetic operations pop arguments off the
stack and push the results.
To enter a number in dc, type the digits with an optional decimal point.
Exponential notation is not supported. To enter a negative number, begin
the number with ``_''. ``-'' cannot be used for this, as it is a binary
operator for subtraction instead. To enter two numbers in succession,
separate them with spaces or newlines. These have no meaning as
p Prints the value on the top of the stack, without altering the
stack. A newline is printed after the value.
P Prints the value on the top of the stack, popping it off, and does
not print a newline after.
f Prints the entire contents of the stack without altering anything.
This is a good command to use if you are lost or want to figure out
what the effect of some command has been.
+ Pops two values off the stack, adds them, and pushes the result.
The precision of the result is determined only by the values of the
arguments, and is enough to be exact.
- Pops two values, subtracts the first one popped from the second one
popped, and pushes the result.
* Pops two values, multiplies them, and pushes the result. The number
of fraction digits in the result is controlled by the current
precision value (see below) and does not depend on the values being
/ Pops two values, divides the second one popped from the first one
popped, and pushes the result. The number of fraction digits is
specified by the precision value.
% Pops two values, computes the remainder of the division that the /
command would do, and pushes that. The division is done with as
many fraction digits as the precision value specifies, and the
remainder is also computed with that many fraction digits.
^ Pops two values and exponentiates, using the first value popped as
the exponent and the second popped as the base. The fraction part
of the exponent is ignored. The precision value specifies the
number of fraction digits in the result.
v Pops one value, computes its square root, and pushes that. The
precision value specifies the number of fraction digits in the
Most arithmetic operations are affected by the ``precision value'', which
you can set with the k command. The default precision value is zero,
which means that all arithmetic except for addition and subtraction
produces integer results.
The remainder operation % requires some explanation: applied to
arguments ``a'' and ``b'' it produces ``a - (b * (a / b))'', where ``a /
b'' is computed in the current precision.
c Clears the stack, rendering it empty.
d Duplicates the value on the top of the stack, pushing another copy
of it. Thus, ``4d*p'' computes 4 squared and prints it.
Dc provides 256 memory registers, each named by a single character. You
can store a number or a string in a register and retrieve it later.
sr Pop the value off the top of the stack and store it into register r.
lr Copy the value in register r and push it onto the stack. This does
not alter the contents of r.
Each register also contains its own stack. The current register value is
the top of the register's stack.
Sr Pop the value off the top of the (main) stack and push it onto the
stack of register r. The previous value of the register becomes
Lr Pop the value off the top of register r's stack and push it onto the
main stack. The previous value in register r's stack, if any, is
now accessible via the lr command.
Dc has three parameters that control its operation: the precision, the
input radix, and the output radix. The precision specifies the number of
fraction digits to keep in the result of most arithmetic operations. The
input radix controls the interpretation of numbers typed in; all numbers
typed in use this radix. The output radix is used for printing numbers.
The input and output radices are separate parameters; you can make them
unequal, which can be useful or confusing. The input radix must be
between 2 and 36 inclusive. The output radix must be at least 2. The
precision must be zero or greater. The precision is always measured in
decimal digits, regardless of the current input or output radix.
i Pops the value off the top of the stack and uses it to set the input
o Pops the value off the top of the stack and uses it to set the
k Pops the value off the top of the stack and uses it to set the
I Pushes the current input radix on the stack.
O Pushes the current output radix on the stack.
K Pushes the current precision on the stack.
Dc can operate on strings as well as on numbers. The only things you can
do with strings are print them and execute them as macros (which means
that the contents of the string are processed as dc commands). All
registers and the stack can hold strings, and dc always knows whether any
given object is a string or a number. Some commands such as arithmetic
operations demand numbers as arguments and print errors if given strings.
Other commands can accept either a number or a string; for example, the p
command can accept either and prints the object according to its type.
Makes a string containing characters (contained between balanced [
and ] characters), and pushes it on the stack. For example, [foo]P
prints the characters foo (with no newline).
x Pops a value off the stack and executes it as a macro. Normally it
should be a string; if it is a number, it is simply pushed back onto
the stack. For example, [1p]x executes the macro 1p which pushes 1
on the stack and prints 1 on a separate line.
Macros are most often stored in registers; [1p]sa stores a macro to print
1 into register a, and lax invokes this macro.
>r Pops two values off the stack and compares them assuming they are
numbers, executing the contents of register r as a macro if the
original top-of-stack is greater. Thus, 1 2>a will invoke register
a's contents and 2 1>a will not.
<r Similar but invokes the macro if the original top-of-stack is less.
=r Similar but invokes the macro if the two numbers popped are equal.
? Reads a line from the terminal and executes it. This command allows
a macro to request input from the user.
q exits from a macro and also from the macro which invoked it. If
called from the top level, or from a macro which was called directly
from the top level, the q command will cause dc to exit.
Q Pops a value off the stack and uses it as a count of levels of macro
execution to be exited. Thus, 3Q exits three levels. The Q command
will never cause dc to exit.
Z Pops a value off the stack, calculates the number of digits it has
(or number of characters, if it is a string) and pushes that number.
X Pops a value off the stack, calculates the number of fraction digits
it has, and pushes that number. For a string, the value pushed is
z Pushes the current stack depth; the number of objects on the stack
before the execution of the z command.
! Will run the rest of the line as a system command.
# Will interpret the rest of the line as a comment.
:r Will pop the top two values off of the stack. The old second-to-top
value will be stored in the array r, indexed by the old top-of-stack
;r Pops the top-of-stack and uses it as an index into the array r. The
selected value is then pushed onto the stack.
The array operations : and ; are usually only used by traditional
implementations of bc. (The GNU bc is self contained and does not need
dc to run.) The comment operator # is a new command not found in
traditional implementations of dc.
Email bug reports to email@example.com. Be sure to include
the word ``dc'' somewhere in the ``Subject:'' field.
PPPPaaaaggggeeee 5555 [ Back ]