The dc(1) utility is a reverse-Polish desk calculator which
supports unlimited precision arithmetic. You can also use it to
define and call macros. Normally, dc(1) reads from the
standard input. If any command arguments are given to it, they must
be file names. The dc(1) utility reads and runs 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(1), type the digits with an
optional decimal point. Exponential notation is not supported. To
enter a negative number, begin the number with and underscore (_).
A dash (-) cannot be used for this, as it is a binary
operator for subtraction. To enter two numbers in succession,
separate them with spaces or newlines. These have no meaning as
commands.
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 multiplied.
/
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
result.
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.
The dc(1) utility 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 inaccessible.
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 through the lr
command.
The dc(1) utility 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 radix.
o
Pops the value off the top of the stack and uses it to set the
output radix.
k
Pops the value off the top of the stack and uses it to set the
precision.
The dc(1) utility can operate on strings as well as on
numbers. The only things you can do with strings are print them and
run them as macros (which means that the contents of the string are
processed as dc(1) commands). All registers and the stack
can hold strings, and dc(1) 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.
[characters]
Makes a string containing characters (contained between
balanced [ and ] characters), and pushes it on the
stack. For example, [exp]P prints the characters exp
(with no newline).
x
Pops a value off the stack and runs 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 runs 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 will invoke
register a's contents and 2 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 runs 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(1) 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(1) to exit.
The array operations : and ; are usually used only by
traditional implementations of bc. (The GNU bc(1) is
self-contained and does not need dc(1) to run.) The comment
operator # is a new command not found in traditional
implementations of dc(1).
E-mail bug reports to bug-gnu-utils@prep.ai.mit.edu. Be sure to
include the word "dc" somewhere in the Subject field.
500 Internal Server Error
Internal Server Error
The server encountered an internal error or
misconfiguration and was unable to complete
your request.
Please contact the server administrator at
webmaster@systemmanager.forsenergy.ru to inform them of the time this error occurred,
and the actions you performed just before this error.
More information about this error may be available
in the server error log.
Additionally, a 500 Internal Server Error
error was encountered while trying to use an ErrorDocument to handle the request.