GOPHERSPACE.DE - P H O X Y
gophering on box.matto.nl
dc: a RPN commandline calculator
================================

Last edited: \$Date: 2020/10/11 10:02:08 \$

dc  is  a  commandline  calculater that uses reverse
polish notation (RPN). RPN is an  efficient  way  to
calculate. In the seventees scientists and engineers
choose the HP pocket calculators  because  of  this.
Those calculators worked with the RPN method.

By  using  RPN  you  don't need to enter parenthesis
and, after getting used to it, the  order  in  which
you  enter  the  operands  and  operations  is  more
intuitive. So the use of RPN is more  efficient  and
less error-prone.

RPN calculators work with a stack, where entries can
be pushed and popped. Pushing puts a  new  entry  at
the  top of the stack, popping removes an entry from
the top of the stack.

Think of a stack  like  a  pile  of  dishes  in  the
kitchensink.   You  add  a new dish to this stack by
putting one on top and remove a dish by  taking  one
from the top.

Adding the two numbers 4 and 3 works like this:

- push the number 4 to the stack:
The stack now contains one entry, the number 4
- push the number 3 to the stack:
The stack now contains two entries, the number 4 at the
bottom and the number 3 at the top
- give the "plus" command:
The calculator now pops two values from the stack, first
the top value (in our case 3), after which the next
value on the stack becomes the top value.
The calculator pops another values from the stack (in
our cases 4) and do an addition of those two values.
It than pushes the outcome of this operation to the
stack

We can write this as:

4
3
+

### Calculating 5 - ( 3 * 4 )

With  RPN  this  kind  of  calculations become quite
easy:

5
3
4
*
-

Explanation:

After pushing 5,3, and 4 our stack is, from  top  to
bottom,

4
3
5

Now   we   do  the  "product"  operation  (*).   The
calculator pops the two top values  (4  and  3)  and
pushes the product.

After  this  operation,  our  stack  is, from top to
bottom,

12
5

Now we  do  the  "difference"  operation  (-).   The
calculator  pops  the  two top values (12 and 5) and
pushes the difference.

-7

Because the outcome of a operation is pushed back to
the  stack,  we can continu calculating. Most of the
time entering formula's in RPN follows  the  formula
closer,  compared to a 'normal' calculator, where we
have to much more aware  of  where  the  parenthesis
are.

Reverse polish notation in dc

To   use   dc  directly,  just  enter  'dc'  on  the
commandline.  This will start dc and  allows  us  to
enter commands (there is no prompt).

Entering  a  number  followed  by  Enter  pushes the
current number to the stack.

So, like the example above, we can just enter:

5
3
4
*
-

This will push the result  (-7)  to  the  stack.  In
order  for  us  to  see  this,  we  have to give the
command 'p', which will print the top value  of  the
stack, without altering the stack.

Here are some things we can enter in dc:

Enter: pushes the current line to the stack
p:     prints the top value of the stack (without
altering the stack)
f:     prints the entire stack (without
altering the stack)

+:     pops two values from the stack and pushes
the sum
-:     pops two values from the stack and pushed
the difference
*:     pops two values from the stack and pushes
the product
/:     pops two values from the stack and pushes
the fraction
%:     pops two values from the stack and pushes
the modulo value
^:     pops two values from the stack and pushes
the exponatation
v:     pops one value from the stack and pushes
the square root of that value

c:     clears the stack
d:     duplicates the top of the stack

Set the precision

In  the  default  setting,  dc will show the results
without any decimal digits:

10
3
/
p
3

To change this, set your preferred precision number
in the stack, like 3 and give the command k:

3
k

Now, test:

10
3
/
p
3.333

Using registers

dc gives us 256 named registers, 'a' to 'z'.

### Pop to register

sa:    pops the value from the top of the stack and
put that in register 'a'.

### Use register as stack

Sa:    pops the value from the top of the stack and
pushes that on top of the stack of register 'a'.

### Push a copy from register

la:    copies the value from the register 'a' and pushes
that to the stack.

So, this operation will alter the stack.

### Pop from register and push to stack

La:    pop the top value from the stack of register 'a'
and push that to the stack

Use a different output number base

You  can  view  the  number  on  top of the stack in
different number base systems.

With the command "o" we switch to a different output
number  base.  First  put  the number of the desired
number-base on the stack, than enter 'o'.

Below we  view  some  numbers in a  16-base  and  in
2-base:

16
o
254
p
FE
12
p
C
2
o
254
p
11111110
12
p
1100

There is more to dc

This  was just a short introduction. We didn't touch
things like creating a macro and  storing  it  as  a
string in a register, looping and much more.

dc  is  a  very  old  Unix utility, so there will be
differences in current versions, like GNU  and  non-
GNU. As always, read the very informative manpages.

The examples above were tested on a FreeBSD system.

I am grateful to Sergey Matveev who pointed me to dc
on his webslite http://www.stargrave.org/.

Resources

- Wikipedia page on Reverse Polish notation https://en.wikipedia.org/wiki/Reverse_Polish_notation
- Wikipedia page on dc https://en.wikipedia.org/wiki/Dc_(computer_program)