RPN with HP 15C & DM32: Stack Register Arithmetic
Got a treat for today folks. First...
14 YEARS!!
On the 16th, it will be 14 years since my blog started!!!! Thank you so much for your support – the blog is one of my joys of life.
Today is another installment of RPN with HP 15C & DM32, I hope you are enjoying this new monthly series, currently every second Saturday of the month.
Stack Register Arithmetic
As we know, nearly all Hewlett Packard (HP) and I think all Swiss Micros (SM) calculators that operate on Reverse Polish Notation (RPN) or Reverse Polish Lisp (RPL, think HP 48 and 50g), a feature that we can calculate an arithmetic operation (+, -, ÷, ×) directly on any number stored in any memory register. It’s a very handy feature indeed.
On the HP 41C, DM41, HP 42S, and DM42 series of calculators, that ability extend to the stack registers themselves (X, Y, Z, T, L (LastX)). To do this, press [ STO ], the required arithmetic operation, the decimal point [ . ], and the appropriate key.
Example:
The current stack is set as:
T: 11
Z: 16
Y: 10
X: 5
Note the 5 in the X stack. We can use the contents of the X stack to do operations on the other levels without “disturbing” the other levels.
Add 5 to stack Z without having to disturb the stack. ST+ Z (41), STO+ ST Z (42) returns:
T: 11
Z: 21
Y: 10
X: 5
Note that the entire stack except Z remains the same.
Multiply stack T by 5. 5 is in the X stack already. ST* T (41), STO× ST T (42) returns:
T: 55
Z: 21
Y: 10
X: 5
Pretty neat, right?
In summary:
STO+ SL: new SLV= old SLV + X
STO- SL: new SLV = old SLV – X
STO× SL: new SLV = old SLV × X
STO÷ SL: new SLV = old SLV ÷ X
where:
X = value in stack level X (display on one-line calculators)
SLV = stack value level (X, Y, Z, T, L)
The 15C and 32S series do not have a native way to do this, but today I will present a way to mimic these powerful stack storage arithmetic on levels X, Y, Z, and T. Most of them will not require the use of an outside memory register (i.e. R0 or R1 for the 15C series, or A or Z for the 32S series).
These techniques were tested on a Hewlett Packard HP 15C and Swiss Micros DM32. They probably would work on the HP 12C (or equivalent) as well, just substitute the roll up (R↑) with three roll down (R↓ R↓ R↓) commands when encountered.
FYI, the 42 series also has recall arithmetic on stack levels, which returns on stack X.
The Algorithms
For the following algorithms, let {OP} stand for the arithmetic operation (+, -, ×, ÷). Let the hash symbol, {#}, stack for a register of your choice (i.e. R0 for 15 or A for 32).
Storage Arithmetic on Stack X
R↑
STO {#}
R↓
ENTER
{OP}
RCL {#}
R↓
Stack Illustration with STO+ X (it will be similar with the rest of the arithmetic operations)
t |
z |
z |
t |
z |
z |
z |
t |
z |
y |
y |
z |
y |
z |
y |
z |
y |
x |
x |
y |
x |
y |
x + x |
y |
x |
t |
t |
x |
x |
x + x |
t |
x + x |
START |
R↑ |
STO {#} |
R↓ |
ENTER |
+ |
RCL {#} |
R↓ |
Shortcuts:
STO- X: Clx
STO× X: x^2 (specifically, the square function)
The next set will not require a separate memory register.
Example:
40 |
30 |
30 |
40 |
30 |
30 |
30 |
40 |
30 |
20 |
20 |
30 |
20 |
30 |
20 |
30 |
20 |
10 |
10 |
20 |
10 |
20 |
20 |
20 |
10 |
40 |
40 |
10 |
10 |
10 + 10 = 20 |
40 |
20 |
START |
R↑ |
STO {#} |
R↓ |
ENTER |
+ |
RCL {#} |
R↓ |
Storage Arithmetic on Stack Y
This is by far the easiest.
{OP}
LAST X
Stack Illustration with STO+ Y (it will be similar with the rest of the arithmetic operations)
t |
t |
t |
z |
t |
z |
y |
z |
y + x |
x |
y + x |
x |
START |
+ |
LAST X |
Example:
40 |
40 |
40 |
30 |
40 |
30 |
20 |
30 |
30 |
10 |
20 + 10 = 30 |
10 |
START |
+ |
LAST X |
Storage Arithmetic on Stack Z
x<>y
R↓
{OP}
LAST X
R↑
x<>y
Stack Illustration with STO+ Z (it will be similar with the rest of the arithmetic operations)
t |
t |
y |
y |
y |
t |
t |
z |
z |
t |
y |
t |
z +x |
z + x |
y |
x |
z |
t |
z + x |
x |
y |
x |
y |
x |
z + x |
x |
y |
x |
START |
x<>y |
R↓ |
+ |
LAST X |
R↑ |
x<>y |
Example:
40 |
40 |
20 |
20 |
20 |
40 |
40 |
30 |
30 |
40 |
20 |
40 |
40 |
40 |
20 |
10 |
30 |
40 |
40 |
10 |
20 |
10 |
20 |
10 |
30 + 10 = 40 |
10 |
20 |
10 |
START |
x<>y |
R↓ |
+ |
LAST X |
R↑ |
x<>y |
Storage Arithmetic on Stack T
R↑
x<>y
{OP}
LAST X
x<>y
R↓
Stack Illustration with STO+ T (it will be similar with the rest of the arithmetic operations)
t |
z |
z |
z |
z |
z |
t + x |
z |
y |
y |
z |
y |
y |
z |
y |
x |
t |
y |
t + x |
x |
y |
x |
t |
x |
t + x |
x |
t + x |
x |
START |
R↑ |
x<>y |
+ |
LAST X |
x<>y |
R↓ |
Example:
40 |
30 |
30 |
30 |
30 |
30 |
50 |
30 |
20 |
20 |
30 |
20 |
20 |
30 |
20 |
10 |
40 |
20 |
50 |
10 |
20 |
10 |
40 |
10 |
40 + 10 = 50 |
10 |
50 |
10 |
START |
R↑ |
x<>y |
+ |
LAST X |
x<>y |
R↓ |
Until next time,
Eddie
All original content copyright, © 2011-2025. Edward Shore. Unauthorized use and/or unauthorized distribution for commercial purposes without express and written permission from the author is strictly prohibited. This blog entry may be distributed for noncommercial purposes, provided that full credit is given to the author.
