Perform two successive binary operations on same input

[cdmackay]

[this is perhaps a little simplistic to be of interest, but…]

I often want to perform two successive binary operations (i.e. operations with two operands/arguments) on the same input, leaving the two results in the two lower stack levels.

An example might be finding the quotient and remainder (DIV/MOD) of two integers, on calculators that don't have a combined operation such as e.g 41/SandMath QREM, 50g IDIV2, Prime iquorem(). That often requires the first operation to be a binary operation followed by one or more unary operations, e.g. ÷ IP, followed by the second binary operation, e.g. MOD.

My clumsy efforts are as follows; I've not yet considered using STO/RCL methods, which might be useful if stack preserving was a requirement.

This is for interactive use; of course a program could be simpler.

I'd be interested in hearing of quicker/easier/more elegant methods.

RPN (stack not preserved)

Code:

Y ENTER ENTER X ENTER
R↓ x<>y R↓
<first binary operation>
<successive unary operations>
ENTER R↓ R↓                    # dup first result to Z
<second binary operation>

if the RPN example has just a single first binary operation, with no successive unary operations, it's much simpler:

RPN (stack not preserved)

Code:

Y ENTER ENTER X
<first binary operation>
x<>y
LASTX
<second binary operation>

RPL (uses stack levels 1–4)

Code:

Y X DUP2
<first binary operation>
<successive unary operations>
3 ROLLD                        # move first result to level 3; alt: ROT ROT
<second binary operation>

if the RPL example has just a single first binary operation, with no successive unary operations, it's much simpler:

RPL (uses stack levels 1–4)

Code:

Y X
<first binary operation>
LASTARG
<second binary operation>

[cdmackay]

arg! I stupidly forgot that RPL LASTARG will restore both args, which makes the RPL case trivial; ah well.

[cdmackay]

Although, LASTARG will only work if there's just one operation.

e.g. in my example, on many calcs the quotient requires two operations: ÷ IP, and so LASTARG won't restore the original Y X.

The RPL example in the first post will allow successive unary operations after the first binary operation.

[cdmackay]

and there's a similar use of LASTX that can be used to simplify the RPN case, again if there's only the one binary operation. I'll edit that in too.

[Csaba Tizedes]

(02-23-2020 01:03 AM)cdmackay Wrote:  I often want to perform two successive binary operations...
My clumsy efforts are as follows; I've not yet considered using STO/RCL methods, which might be useful if stack preserving was a requirement.

Sure! Check the attachment, there is my opinion about "Tricky-Genius-Programming-Style" - just as a practical engineer point of view...

So, with STO and RCL, with one flag and with lots of labels:

LBL A and LBL B: the two binary operation
LBL S: store the stack status
LBL T: store previous result
LBL R: restore the stack status

variable R: previous result
flag 0: set, if the stack X is the previous result

for the first running clear the flag 0

Code:


LBL A / LBL B
  XEQ S
  //do the binary operation on Y and X here; result in X
  SF 0 //it was an operation and the result is in X
  XEQ R //recover the stack
RTN

LBL S //store stack status
  FS0? //there is a result in X?
  XEQ T
  STO X
  x<>y
  STO Y
  x<>y
RTN

LBL T
  STO R
  Rdown
  CF0
RTN

LBL R //stack recovery
  RCL Y
  x<>y
  RCL X
  x<>y
RTN

Csaba

https://www.hpmuseum.org/forum/attachment.php?aid=8104

[ttw]

On the hp50g, I've done this several way depending on the desired operations. Sometimes I do things like (assuming two operands on the stack):
MAX LASTARG MIN
In other cases:
DUP2 "ops leaving single result" UNROT

I often need things like IDIV2 but that's so slow that IQUOT (or even / FLOOR) and MOD with LASTART or DUP2 are much faster.

[cdmackay]

hah! very good, I agree

thanks for all the suggestions, will study. forgot about UNROT too.

I've been mostly doing this interactive, so hadn't even thought about performance e.g. IDIV2, good point thanks!