# HP Forums

Full Version: Algebraic Operation System (AOS)
You're currently viewing a stripped down version of our content. View the full version with proper formatting.
Description

This program allows you to use the Algebraic Operation System (AOS) similar to how old Texas Instruments calculators work.
The shunting yard algorithm is used with a data and an operator stack.
Their stack size is configurable and is only limited by the amount of memory available.

Functions

The functions just operate on the X register in postfix notation.
This is how the TI-57 and other older calculators from Texas Instruments work.

For example, to calculate $$\sqrt{3^2 + 4^2}$$ use:

3 x^2 + 4 x^2 = √x

Alternatively we can use:

( 3 x^2 + 4 x^2 ) √x

However, this requires one more keystroke.

Apparently we use a mixture of infix notation for arithmetic operations and postfix notation for functions.

Change Sign

It behaves similarly to an ordinary function.

E.g. an expression like $$- 3^4$$ has to be keyed in like:

3 y^x 4 = +/-

Or alternatively:

( 3 y^x 4 ) +/-

Intermediate Results

The intermediate results of a calculation are viewed and may also be printed.

Example

$$\frac{1 \times 2 + 3 \times 4 + 5 \times 6 + 7 \times 8}{4}$$

( 1 * 2 + 3 * 4 + 5 * 6 + 7 * 8 ) / 4 =

Code:
ST X=                  2 ST X=                 12 ST X=                 14 ST X=                 30 ST X=                 44 ST X=                 56 ST X=                100 ST X=                 25

Implicit Data Entry

The current value in the X register is used as data entry.

This allows to reuse the first entry:

3 + =

This results in $$3 + 3 = 6$$.

3 * * =

This results in $$3^4 = 81$$.

The Monster Formula

The formula is from A case against the x<>y key:

$$1 - 2 \times 3^4 \div 5 + \sin\left(6 - \sqrt[3]{7^2} \right) \times 8! + \ln \left[ \left(-9^{2^3} \times 45 ^ \frac{6}{7} \right)^2 \right]$$

Here's how it is entered with this program.

1 - 2 * 3 ^ 4 / 5 + ( 6 - 7 X^2 ^ 3 1/X ) SIN * 8 FACT + ( 9 ^ 2 ^ 3 * 45 ^ ( 6 / 7 ) ) CHS X^2 LN =

1657.008948

Intermediate Results

Code:
ST X=                 81 ST X=                162 ST X=               32.4 ST X=              -31.4 ST X=      3.65930571002 ST X=      2.34069428998 ST X=      1646.72764773 ST X=      1615.32764773 ST X=                  8 ST X=           43046721 ST X=   8.57142857143ᴇ-1 ST X=      26.1239772883 ST X=      1124551561.74 ST X=      1657.00894809

Registers

This is a list of the registers after the calculation:
Code:
00:                 5 01:                10 02:              -4.1 03:                 0 04:                 0 05:                 0 06:     1615.32764773 07:          43046721 08:                45 09:                 6 10:                 0 11:              -1.2 12:                 0 13:              -3.1 14:               5.1 15:                 0 16:              -4.1 17:                 0 18:                 0 19:                 0

Mark Hardman’s solution

(05-10-2015 03:12 PM)Mark Hardman Wrote: [ -> ]
Code:
              x          y          z          t 1 [Enter]     1          -          -          - 3 [Enter]     3          1          -          - 4             4          3          1          - y^x          81          1          -          - 2             2         81          1          - x           162          1          -          - 5             5        162          1          - /            32.4        1          -          - -           -31.4        -          -          - 6 [Enter]     6        -31.4        -          - 7             7          6        -31.4        - x^2          49          6        -31.4        - 3             3         49          6        -31.4 1/x           0.3333    49          6        -31.4 y^x           3.6593     6        -31.4      -31.4 -             2.3407   -31.4      -31.4      -31.4 sin           0.0408   -31.4      -31.4      -31.4 8             8          0.0408   -31.4      -31.4 x!        40320          0.0408   -31.4      -31.4 x          1646.7276   -31.4      -31.4      -31.4 +          1615.3276   -31.4      -31.4      -31.4 45 [Enter]   45       1615.3276   -31.4      -31.4 6  [Enter]    6         45       1615.3276   -31.4 7             7          6         45       1615.3276 /             0.8571    45       1615.3276  1615.3276 y^x          26.1240  1615.3276  1615.3276  1615.3276 2 [Enter]     2         26.1240  1615.3276  1615.3276 3             3          2         26.1240  1615.3276 y^x           8         26.1240  1615.3276  1615.3276 9 [Chs]      -9          8         26.1240  1615.3276 x<>y          8         -9         26.1240  1615.3276 y^x        4.3047e07    26.1240  1615.3276  1615.3276 x          1.1246e09  1615.3276  1615.3276  1615.3276 x^2        1.2646e18  1615.3276  1615.3276  1615.3276 ln        41.6813     1615.3276  1615.3276  1615.3276 +       1657.0089     1615.3276  1615.3276  1615.3276

TI-57

These are the key strokes for the TI-57:

1 - 2 × 3 y^x 4 ÷ 5 + ( 6 - 7 x^2 INV y^x 3 ) 2nd sin * 40320 + ( 9 y^x ( 2 y^x 3 ) × 45 ^ ( 6 ÷ 7 ) ) +/- x^2 lnx =

We get the same result:

1657.0089

For this I used the TI-57 Programmable Calculator.
However I had to cheat a little: since the factorial function is missing I just replaced $$8!$$ with $$40320$$.
Also since the $$y^x$$ operation apparently is not right associative I used another pair of parenthesis to calculate:

$$9 ^ {2 ^ 3} = 9 ^ {(2 ^ 3)}$$

Program

This is the program for the HP-41C:
Code:
01▸LBL "AOS" 02 CLRG 03 3 04 STO 00 05 10 06 STO 01 07 CLST 08 RTN 09▸LBL "+" 10 -1.2 11 GTO 00 12▸LBL "-" 13 -2.2 14 GTO 00 15▸LBL "*" 16 -3.1 17 GTO 00 18▸LBL "/" 19 -4.1 20 GTO 00 21▸LBL "^" 22 5.1 23▸LBL 00 24 STO 02 25 FRC 26 X>0? 27 GTO 11 28▸LBL 09 29 RCL IND 01 30 X=0? 31 GTO 10 32 FRC 33 X<Y? 34 GTO 10 35 X<> Z 36 LASTX 37 XEQ 06 38 R^ 39 GTO 09 40▸LBL 10 41 RDN 42▸LBL 11 43 RDN 44 RCL 02 45 XEQ 07 46 ISG 00 47 RTN 48 STO IND 00 49 RTN 50▸LBL "<" 51 0 52▸LBL 07 53 ISG 01 54 RTN 55 STO IND 01 56 RDN 57 RTN 58▸LBL ">" 59 XEQ 08 60 DSE 01 61 RTN 62▸LBL "=" 63▸LBL 08 64 RCL IND 01 65 X=0? 66 GTO 13 67 XEQ 06 68 GTO 08 69▸LBL 13 70 RDN 71 RTN 72▸LBL 06 73 DSE 01 74 X<>Y 75 RCL IND 00 76 DSE 00 77 X<>Y 78 XEQ IND Z 79 VIEW X 80 RTN 81▸LBL 01 82 + 83 RTN 84▸LBL 02 85 - 86 RTN 87▸LBL 03 88 * 89 RTN 90▸LBL 04 91 / 92 RTN 93▸LBL 05 94 Y^X 95 END

Key Assignments

Of course you are free to choose differently buy I recommend the following key assignments:
Code:
| Label | Key    | Code |-------|--------|----- | +     | +      |  61 | -     | -      |  51 | *     | *      |  71 | /     | /      |  81 | ↑     | Y↑X    | -12 | =     | ENTER↑ |  41 | <     | X<>Y   |  21 | >     | R↓     |  22 | AOS   | CLx/A  | -44

Registers

The program needs 3 register to control the data and the operator stack:
Code:
| Register | Comment |----------|---------------------- | 00       | top of data stack | 01       | top of operator stack | 02       | current operator

Synthetic Programming

We could use the alpha registers M, N and O instead of register 00-02.
With this the data stack could be started at register 00.
For now I'm leaving that as an exercise for the dear reader.

Operators

The decimal part of the code is used as precedence.
A negative code means left associativity.

The code for the left parenthesis ( is 0.
Thus we already have an implicit open parenthesis.
This makes handling the right parenthesis ) and = similar.

Code:
| Operator | Label | Code  | Precedence | Associativity |----------|-------|-------|------------|-------------- | (        |       |   0   |            | | +        | 01    |  -1.2 | -0.2       | left | -        | 02    |  -2.2 | -0.2       | left | *        | 03    |  -3.1 | -0.1       | left | /        | 04    |  -4.1 | -0.1       | left | ^        | 05    |   5.1 |  0.1       | right

Code Walkthrough

Initialisation

The registers and the stack is cleared with:

XEQ AOS

Here you can configure the start of the data and the operator stack.
Be warned that there are no checks in the program.
Thus the data stack could grow into the operator stack and vice versa.
It's up to you to select reasonable values.

Code:
LBL "AOS" CLRG 3                ; top of data stack STO 00 10               ; top of operator stack STO 01 CLST RTN

Enter Operator

Each operator pushes a specific code onto the stack in which label, precedence and associativity is encoded.

Code:
LBL "+" -1.2 GTO 00           ; new operator LBL "-" -2.2 GTO 00           ; new operator LBL "*" -3.1 GTO 00           ; new operator LBL "/" -4.1 GTO 00           ; new operator LBL "^" 5.1 LBL 00           ; new operator

New operator

Each time we reach a new operator, we pop operators from the stack until we reach one that has lower precedence.
In the case of a right associative operator, we also stop if we reach an operator of the same precedence.

Code:
| X    | Y    | Decision |------|------|----------- | -0.2 | -0.2 | pop | -0.1 | -0.2 | pop |  0.1 | -0.2 | pop | -0.2 | -0.1 | no more | -0.1 | -0.1 | pop |  0.1 | -0.1 | pop | -0.2 |  0.1 | no more | -0.1 |  0.1 | no more |  0.1 |  0.1 | no more

There's no lower precedence than -0.2, thus + and - always pop.
On the other hand, ^ never pops previous operators.
This leaves us with * and / which pop unless an operator on the stack has lower precedence like + or -.

Stack diagram: ( x op -- x' )
Code:
LBL 00           ; add new operator STO 02           ; save new operator FRC              ; precedence of new operator X>0?             ; it is ^ GTO 11           ; no more pop LBL 09           ; while higher precedence RCL IND 01       ; top of stack operator X=0?             ; is left parenthesis ? GTO 10           ; no more pop FRC              ; precedence of top of stack operator X<Y?             ; has lower precedence ? GTO 10           ; no more pop X<> Z            ; x LASTX            ; top of stack operator XEQ 06           ; pop operator R^               ; precedence of new operator GTO 09           ; while higher precedence LBL 10           ; no more pop RDN              ; drop precedence of top of stack operator LBL 11           ; no more pop RDN              ; drop precedence of new operator RCL 02           ; current operator XEQ 07           ; push operator ISG 00           ; push data RTN              ; no op STO IND 00       ; store data RTN

Push Operator

The left parenthesis ( is just pushed onto the operator stack.
The RTN command after ISG is used as a no-operation which is always skipped.

Code:
LBL "(" 0 LBL 07           ; push operator ISG 01           ; increment top operator RTN              ; no op STO IND 01       ; store operator RDN              ; drop operator RTN

Right Parentheses and Equals

Code:
while the operator at the top of the operator stack is not a left parenthesis:     pop the operator from the operator stack into the output queue pop the left parenthesis from the operator stack and discard it

Code:
LBL ")" XEQ 08 DSE 01          ; pop left parenthesis RTN LBL "=" LBL 08          ; while not ( RCL IND 01      ; top of operator stack X=0?            ; is left parenthesis ? GTO 13          ; pop ( XEQ 06          ; pop operator GTO 08          ; while not ( LBL 13          ; pop ( RDN             ; drop operator RTN

The = operator does not pop the implicit left parenthesis.
But otherwise it behaves like the right parenthesis and removes any leftover operators from the operator stack.

Pop Operator

Stack diagram: ( a x op -- a a op x' )
Code:
LBL 06           ; pop operator DSE 01           ; decrement top of operator stack X<>Y             ; ( a op x ) RCL IND 00       ; y: top of data stack DSE 00           ; pop data X<>Y             ; ( a op y x ) XEQ IND Z        ; execute operator VIEW ST X        ; view result RTN

Implementation

This is just the implementation of the operators:
Code:
LBL 01           ; + + RTN LBL 02           ; - - RTN LBL 03           ; * * RTN LBL 04           ; / / RTN LBL 05           ; ^ Y^X END

HP-42S

The program also works with the HP-42S.
However, we can assign the programs only to a custom menu.

I'm using the following layout:
Code:
 X^2  | SQRT | 10^X | LOG  | E^X  |  LN ------+------+------+------+------+------    +  |   -  |   *  |   /  |   ↑  |   = ------+------+------+------+------+------    (  |   )  |  1/X |  N!  |      |  AOS
But compared to the HP-41C, the user experience is modest.

Code:
00 { 186-Byte Prgm } 01▸LBL "AOS" 02 CLRG 03 3 04 STO 00 05 10 06 STO 01 07 CLST 08 RTN 09▸LBL "+" 10 -1.2 11 GTO 00 12▸LBL "-" 13 -2.2 14 GTO 00 15▸LBL "*" 16 -3.1 17 GTO 00 18▸LBL "/" 19 -4.1 20 GTO 00 21▸LBL "↑" 22 5.1 23▸LBL 00 24 STO 02 25 FP 26 X>0? 27 GTO 11 28▸LBL 09 29 RCL IND 01 30 X=0? 31 GTO 10 32 FP 33 X<Y? 34 GTO 10 35 X<> ST Z 36 LASTX 37 XEQ 06 38 R↑ 39 GTO 09 40▸LBL 10 41 R↓ 42▸LBL 11 43 R↓ 44 RCL 02 45 XEQ 07 46 ISG 00 47 RTN 48 STO IND 00 49 RTN 50▸LBL "(" 51 0 52▸LBL 07 53 ISG 01 54 RTN 55 STO IND 01 56 R↓ 57 RTN 58▸LBL ")" 59 XEQ 08 60 DSE 01 61 RTN 62▸LBL "=" 63▸LBL 08 64 RCL IND 01 65 X=0? 66 GTO 13 67 XEQ 06 68 GTO 08 69▸LBL 13 70 R↓ 71 RTN 72▸LBL 06 73 DSE 01 74 X<>Y 75 RCL IND 00 76 DSE 00 77 X<>Y 78 XEQ IND ST Z 79 VIEW ST X 80 RTN 81▸LBL 01 82 + 83 RTN 84▸LBL 02 85 - 86 RTN 87▸LBL 03 88 × 89 RTN 90▸LBL 04 91 ÷ 92 RTN 93▸LBL 05 94 Y↑X 95 END

References
Great work Thomas, your suggested key assignment made it very easy to use.

Sylvain

PS: I was too lazy to type in the program, so I used the barcode reader instead.

Procedure to create a barcode from text with lifutils on macOS.
Code:
1) use the "View a Printable Version" at the bottom of this page 2) copy paste the program into a text file 3) removed the first three columns of the text file (line numbers) 4) save it to file: aos.txt
Then from the command line:
Code:
comp41     aos.txt >aos.raw prog41bar <aos.raw >aos.bc barps AOS <aos.bc  >aos.ps ps2pdf     aos.ps   aos.pdf
Then I used macOS preview to print the aos.pdf file and the bar code reader to load it into my HP-41.

Source File: aos.txt
Barcode File: aos.pdf
Thank you for providing the barcode and instructions.
I wasn't aware that the lifutils are available on macOS.
This begs the question: is there an emulator you can recommend for macOS?
I use Genesis-41 from Laurent Spohr.
That was one of the best emulator that I have seen.
Unfortunately that macOS emulator is no longer available since 2016.

Windows application V41 works with Wine on Linux/macOS & CrossOver (a macOS customized version of Wine).
Everything seems to works but the mcode console is way too slow even when full speed is selected.
If that is your goal, you will have to use V41 under Parallels Desktop or VMware Fusion running a full version of Windows.

Sylvain

Genesis-41

V41 under CrossOver
(04-17-2022 12:57 AM)Thomas Klemm Wrote: [ -> ]TI-57

These are the key strokes for the TI-57:

1 - 2 × 3 y^x 4 ÷ 5 + ( 6 - 7 x^2 ^ 3 1/x ) 2nd sin * 40320 + ( 9 y^x ( 2 y^x 3 ) × 45 ^ ( 6 ÷ 7 ) ) +/- x^2 lnx =

We get the same result:

1657.0089

For this I used the TI-57 Programmable Calculator.

Thank you for this excellant program allowing us to use the AOS from the historic competitor on the HP-41C !

I get a lot of fun and a great time this morning by using AOS on my HP-41C and comparing with the results obtained on a newly restored TI Programmable 58C.

Armed with the MASTER LIBRARY MODULE, the keystrokes sequences on Ti-58/59 are quite identical to the one for the TI-57. Except that the factorial function is available (Module program Pgm 16 , label A for entry n and label C to compute n!) and the x√y function is available with the INV y^x keystrokes.

These are the key strokes for the TI-58/59 armed with the MASTER LIBRARY MODULE:

2nd Deg CLR 1 - 2 × 3 y^x 4 ÷ 5 + ( 6 - 7 x^2 INV y^x 3 ) 2nd sin * 8 2nd Pgm16 A C + ( 9 y^x ( 2 y^x 3 ) × 45 y^x 6 INV y^x 7 ) +/- x^2 lnx =

We get the expected result: 1657.008948
For this I used the TI Programmable 58 C Calculator serial n°8208744.

Despite the Ti-57, the infamous Ti-57 LCD allows a simpler keystrokes sequence since this model also has factorial n! and x√y functions(°):

ON/C ON/C 1 - 2 × 3 y^x 4 ÷ 5 + ( 6 - 7 x^2 INV y^x 3 ) sin * 8 2nd n! + ( 9 y^x ( 2 y^x 3 ) × 45 y^x 6 INV y^x 7 ) +/- x^2 lnx =

We get the same result as he TI 57: 1657.0089 on but on a LCD display as colorless as the HP-41.

EDIT:
(°) I am currently in a doubt, isn't the x√y function available on the red LED Ti-57 as the INV y^x keystrokes ? Please check for that, I have no TI-57 with LED and have an issue trying a simulator on Internet.
(04-17-2022 10:32 AM)Thomas Klemm Wrote: [ -> ]Thank you for providing the barcode and instructions.
I wasn't aware that the lifutils are available on macOS.
This begs the question: is there an emulator you can recommend for macOS?

Nicely done Thomas, I've attached the RAW file to this post in case it's useful

This subject seems to resurface every few years, I'm aware of two other versions of the same topic:
1. in the HP-67 Games ROM, by Jim Horn
2. In the GJM ROM, by Greg McClure

Both manuals are available at Monte's site and at TOS,
http://www.systemyde.com/hp41/documents.html

Cheers,
ÁM
(04-18-2022 06:15 AM)C.Ret Wrote: [ -> ]EDIT:
(°) I am currently in a doubt, isn't the x√y function available on the red LED Ti-57 as the INV y^x keystrokes ? Please check for that, I have no TI-57 with LED and have an issue trying a simulator on Internet.

Yes it is. I had to try several times due to the poor keyboard of my TI-57, but 8 INV y^x 3 = returns 2
(04-18-2022 06:15 AM)C.Ret Wrote: [ -> ]isn't the x√y function available on the red LED Ti-57 as the INV y^x keystrokes ?

I totally forgot about that and have since corrected it.
Thanks for the hint.
And also thanks to Didier for the confirmation.

(04-18-2022 07:01 AM)Ángel Martin Wrote: [ -> ]1. in the HP-67 Games ROM, by Jim Horn

Code:
wget http://*****/file/HP67_FUN.zip unzip HP67_FUN.zip Archive:  HP67_FUN.zip   inflating: HP67_FUN_20161213.ROM   inflating: HP67_FUN.mod

Then I dowloaded rom2raw, compiled it on Mac and used it to extract the listing:
Code:
wget https://thomasokken.com/free42/download/rom2raw.zip unzip rom2raw.zip Archive:  rom2raw.zip   inflating: rom2raw.c   inflating: rom2raw.exe cc -o rom2raw rom2raw.c ./rom2raw -l HP67_FUN_20161213.ROM > HP67_FUN.txt

Here is the listing:
Code:
01▸LBL "AOS" 02 SF 27 03▸LBL a 04 CF 01 05 CF 02 06 CF 22 07 12 08 STO 23 09 -1 10 STO 24 11 CLX 12 RTN 13▸LBL "+" 14▸LBL A 15 61 16 GTO 00 17▸LBL "-" 18▸LBL B 19 51 20 GTO 00 21▸LBL "*" 22▸LBL C 23 42 24 GTO 00 25▸LBL "/" 26▸LBL D 27 32 28 GTO 00 29▸LBL "YX" 30▸LBL b 31 14 32 GTO 00 33▸LBL "NEG" 34▸LBL c 35 23 36 GTO 00 37▸LBL "<" 38▸LBL d 39 5 40▸LBL 00 41 10 42 / 43 STO 22 44 INT 45 X≠0? 46 GTO 00 47 FS? 01 48 XEQ 03 49▸LBL 00 50 RDN 51 FS?C 22 52 XEQ 02 53 RCL 22 54 INT 55 X=0? 56 GTO 00 57▸LBL 07 58 RCL 24 59 X<0? 60 GTO 00 61 RCL IND 24 62 FRC 63 RCL 22 64 FRC 65 X>Y? 66 GTO 00 67 RCL IND 24 68 INT 69 X=0? 70 GTO 00 71 XEQ 01 72 GTO 07 73▸LBL 00 74 ISG 24 75 ENTER↑ 76 RCL 24 77 13 78 X<=Y? 79 ASIN 80 RCL 22 81 STO IND 24 82 RCL IND 23 83 CF 01 84 GTO 99 85▸LBL ">" 86▸LBL e 87 1 88 STO 22 89 X<>Y 90 FS?C 22 91 XEQ 02 92 RCL 24 93 X<0? 94 SQRT 95 RCL IND 24 96 INT 97 X=0? 98 GTO 08 99 XEQ 01 100 GTO e 101▸LBL 08 102 DSE 24 103 ENTER↑ 104 RCL IND 23 105 SF 01 106 GTO 99 107▸LBL E 108▸LBL "=" 109 1 110 STO 22 111 X<>Y 112 FS?C 22 113 XEQ 02 114 RCL 24 115 X<0? 116 GTO 00 117 RCL IND 24 118 XEQ 01 119 GTO E 120▸LBL 00 121 RCL IND 23 122 XEQ a 123 RDN 124 RDN 125 SF 22 126 GTO 99 127▸LBL 02 128 ISG 23 129 ENTER↑ 130 21 131 RCL 23 132 - 133 X<0? 134 SQRT 135 RDN 136 STO IND 23 137 RCL 22 138 INT 139 X≠0? 140 RTN 141▸LBL 03 142 ISG 24 143 ENTER↑ 144 4.2 145 STO IND 24 146 RDN 147 RTN 148▸LBL 01 149 RCL IND 23 150 DSE 23 151 RCL IND 23 152 X<>Y 153 XEQ IND Z 154 FS?C 02 155 ISG 23 156 ENTER↑ 157 RCL 23 158 13 159 - 160 X<0? 161 SQRT 162 X<>Y 163 STO IND 23 164 DSE 24 165 RTN 166 RTN 167▸LBL 01 168 Y↑X 169 RTN 170▸LBL 02 171 CHS 172▸LBL 00 173 SF 02 174 RTN 175▸LBL 03 176 / 177 RTN 178▸LBL 04 179 * 180 RTN 181▸LBL 05 182 CHS 183▸LBL 06 184 + 185▸LBL 99 186 RTN 187 SF 22 188 END

It appears that Free42 has a problem parsing this line:
Code:
153 XEQ IND Z

You better make sure to use the following instead:
Code:
153 XEQ IND ST Z

At first glimpse I noticed the following differences:

The power function is left-associative.
Thus we get:

9 YX 2 YX 3 =

531441

But then I noticed that this is apparently still the case with today's calculators from Texas Instruments.
From Solution 12705: Differences Between Algebraic Operating System (AOS) and Equation Operating System (EOS).:
Quote:The Algebraic Operating System (AOS) completes all operations according to their relative priorities, which are listed below:

1) Trigonometric and hyperbolic functions, square roots, cube roots, factorials, reciprocals (inverse), angle conversions, combinations, permutations, percents, logarithms, sign changes (+/-), metric conversions, logical "not".
2) Universal powers, exponents and roots.
3) Multiplication and division.
5) Logical "and".
6) Other logical functions, such as "or", "xor" and "xnor".
7) Close parenthesis.
8) Equals.

Operations of priority 1 are immediate functions which means they are performed as soon as the operation keys are pressed.

Operations in priorities 2, 3, and 4 are completed by any operation with the same priority or with a lower priority.

The [=] key completes all operations.

But for example Python does it right.
The power operation ** is actually right-associative, as it should:
Code:
>>> dis(lambda a, b, c: a ** b ** c)   1           0 LOAD_FAST                0 (a)               2 LOAD_FAST                1 (b)               4 LOAD_FAST                2 (c)               6 BINARY_POWER               8 BINARY_POWER              10 RETURN_VALUE

Code:
>>> dis(lambda a, b, c: a ** (b ** c))   1           0 LOAD_FAST                0 (a)               2 LOAD_FAST                1 (b)               4 LOAD_FAST                2 (c)               6 BINARY_POWER               8 BINARY_POWER              10 RETURN_VALUE

The other arithmetic operations like / are left-associative:
Code:
>>> dis(lambda a, b, c: a / b / c)   1           0 LOAD_FAST                0 (a)               2 LOAD_FAST                1 (b)               4 BINARY_TRUE_DIVIDE               6 LOAD_FAST                2 (c)               8 BINARY_TRUE_DIVIDE              10 RETURN_VALUE

Code:
>>> dis(lambda a, b, c: (a / b) / c)   1           0 LOAD_FAST                0 (a)               2 LOAD_FAST                1 (b)               4 BINARY_TRUE_DIVIDE               6 LOAD_FAST                2 (c)               8 BINARY_TRUE_DIVIDE              10 RETURN_VALUE

The NEG function is implemented.

The program is about twice as long and big.

Flag 22 is used to detect numeric input.
I still haven't figured out why this is necessary.
In my implementation, each operation always adds the current value of register X to the data stack.
(04-18-2022 12:27 PM)Thomas Klemm Wrote: [ -> ]The power function is left-associative.
Thus we get:

9 YX 2 YX 3 =

531441

But then I noticed that this is apparently still the case with today's calculators from Texas Instruments.

Although associative order is wrong (*), this made parsing expression easier, scanning from left to right.
Easy parsing translate to intepreted code run faster, which may be needed in the old days.
(I just checked, HP71B power is also left-associative)

To have power right-associative, we may need to parse expression in reverse order.
(it can be done in forward order too, but I cannot make parsing expression as fast)

(*) wrong is probably the wrong word, perhaps not right
At the risk of beating a dead horse, here's the infamous Mach number:

$\sqrt{5 \left( \left( \left( \left( \left(1 + 0.2 \left(\frac{350}{661.5} \right)^{2} \right)^{3.5} - 1 \right) \times \left(1-6.875 \times 10^{-6} \times 25500 \right)^{-5.2656} \right)+1 \right)^{0.286}-1 \right)}$

( 5 * ( ( ( ( ( 1 + .2 * ( 350 / 661.5 ) X^2 ) ^ 3.5 - 1 ) * ( 1 - 6.875E-6 * 25500 ) ^ -5.2656 ) + 1 ) ^ .286 - 1 ) ) SQRT

0.835724536
And the mach number problem is one of the examples I put into the HP-67 Games rom put together a couple of years ago.

Here's the manual (PDF): HP-67 Fun rom
Jim Horn, who posts here fairly often, is the original author of the AOS program for the HP-67 that is now in the HP-67 fun rom.
(04-18-2022 05:24 PM)Thomas Klemm Wrote: [ -> ]At the risk of beating a dead horse, here's the infamous Mach number:

$\sqrt{5 \left( \left( \left( \left( \left(1 + 0.2 \left(\frac{350}{661.5} \right)^{2} \right)^{3.5} - 1 \right) \times \left(1-6.875 \times 10^{-6} \times 25500 \right)^{-5.2656} \right)+1 \right)^{0.286}-1 \right)}$

( 5 * ( ( ( ( ( 1 + .2 * ( 350 / 661.5 ) X^2 ) ^ 3.5 - 1 ) * ( 1 - 6.875E-6 * 25500 ) ^ -5.2656 ) + 1 ) ^ .286 - 1 ) ) SQRT

0.835724536

This is a good test case for the new Double-Length Stack ROM, just finished and ready to be released.. stay tuned

To whet your appetite here's the programmatic version of the sequence of steps, entering the formula strictly from left to right:

Code:
 01  LBL "MACH" 02  5 03  ENTER^^ 04  1 05  ENTER^^ 06  .2 07  ENTER^^ 08  350 09  ENTER^^ 10  661.5 11  ^/ 12  X^2 13  ^* 14  ^+ 15  ENTER^^  - not needed in manual mode 16  3.5 17  ^Y^X 18  ENTER^^  - not needed in manual mode 19  1 20  ^- 21  ENTER^^  - not needed in manual mode 22  1 23  ENTER^^ 24  6.875 E-6 25  ENTER^^ 26  25500 27  ^* 28  ^- 29  ENTER^^  - not needed in manual mode 30  -5.2656 31  ^Y^X 32  ^* 33  ENTER^^  - not needed in manual mode 34  1 35  ^+ 36  ENTER^^  - not needed in manual mode 37  .286 38  ^Y^X 39  ENTER^^  - not needed in manual mode 40  1 41  ^- 42  ^* 43  SQRT 44  END

Most of those ENTER^^ steps are not required in manual mode, by virtue of the I/O_SVC interrupt - which isn't "active" in a running program.

Cheers,
ÁM
(04-18-2022 12:27 PM)Thomas Klemm Wrote: [ -> ]I found the ROM on TOS, downloaded it and unzipped it:

It appears that Free42 has a problem parsing this line:
Code:
153 XEQ IND Z

You better make sure to use the following instead:
Code:
153 XEQ IND ST Z

that's the standard notation used on the HP-41, and also the expected syntax by hp41uc.exe

Did you change your original code ?
(04-19-2022 12:25 AM)Gene Wrote: [ -> ]And the mach number problem is one of the examples I put into the HP-67 Games rom put together a couple of years ago.

Here's the manual (PDF): HP-67 Fun rom

And here's the link to Greg McClure's
http://www*hp41*org/LibView.cfm?Command=...leID=30533

replace the * with dot characters
(04-19-2022 03:00 PM)Ángel Martin Wrote: [ -> ]Did you change your original code ?

Apparently I didn't make that clear: in general you can just copy and paste a listing for the HP-41C into Free42 and it will be parsed.
But for some reason XEQ IND Z is ignored.

For the sake of simplicity, here is Jim's program from the HP67_FUN ROM for the HP-42S:
Code:
00 { 363-Byte Prgm } 01▸LBL "AOS" 02 SF 27 03▸LBL a 04 CF 01 05 CF 02 06 CF 22 07 12 08 STO 23 09 -1 10 STO 24 11 CLX 12 RTN 13▸LBL "+" 14▸LBL A 15 61 16 GTO 00 17▸LBL "-" 18▸LBL B 19 51 20 GTO 00 21▸LBL "*" 22▸LBL C 23 42 24 GTO 00 25▸LBL "/" 26▸LBL D 27 32 28 GTO 00 29▸LBL "YX" 30▸LBL b 31 14 32 GTO 00 33▸LBL "NEG" 34▸LBL c 35 23 36 GTO 00 37▸LBL "<" 38▸LBL d 39 5 40▸LBL 00 41 10 42 ÷ 43 STO 22 44 IP 45 X≠0? 46 GTO 00 47 FS? 01 48 XEQ 03 49▸LBL 00 50 R↓ 51 FS?C 22 52 XEQ 02 53 RCL 22 54 IP 55 X=0? 56 GTO 00 57▸LBL 07 58 RCL 24 59 X<0? 60 GTO 00 61 RCL IND 24 62 FP 63 RCL 22 64 FP 65 X>Y? 66 GTO 00 67 RCL IND 24 68 IP 69 X=0? 70 GTO 00 71 XEQ 01 72 GTO 07 73▸LBL 00 74 ISG 24 75 ENTER 76 RCL 24 77 13 78 X≤Y? 79 ASIN 80 RCL 22 81 STO IND 24 82 RCL IND 23 83 CF 01 84 GTO 99 85▸LBL ">" 86▸LBL e 87 1 88 STO 22 89 X<>Y 90 FS?C 22 91 XEQ 02 92 RCL 24 93 X<0? 94 SQRT 95 RCL IND 24 96 IP 97 X=0? 98 GTO 08 99 XEQ 01 100 GTO e 101▸LBL 08 102 DSE 24 103 ENTER 104 RCL IND 23 105 SF 01 106 GTO 99 107▸LBL E 108▸LBL "=" 109 1 110 STO 22 111 X<>Y 112 FS?C 22 113 XEQ 02 114 RCL 24 115 X<0? 116 GTO 00 117 RCL IND 24 118 XEQ 01 119 GTO E 120▸LBL 00 121 RCL IND 23 122 XEQ a 123 R↓ 124 R↓ 125 SF 22 126 GTO 99 127▸LBL 02 128 ISG 23 129 ENTER 130 21 131 RCL 23 132 - 133 X<0? 134 SQRT 135 R↓ 136 STO IND 23 137 RCL 22 138 IP 139 X≠0? 140 RTN 141▸LBL 03 142 ISG 24 143 ENTER 144 4.2 145 STO IND 24 146 R↓ 147 RTN 148▸LBL 01 149 RCL IND 23 150 DSE 23 151 RCL IND 23 152 X<>Y 153 XEQ IND ST Z 154 FS?C 02 155 ISG 23 156 ENTER 157 RCL 23 158 13 159 - 160 X<0? 161 SQRT 162 X<>Y 163 STO IND 23 164 DSE 24 165 RTN 166 RTN 167▸LBL 01 168 Y↑X 169 RTN 170▸LBL 02 171 +/- 172▸LBL 00 173 SF 02 174 RTN 175▸LBL 03 176 ÷ 177 RTN 178▸LBL 04 179 × 180 RTN 181▸LBL 05 182 +/- 183▸LBL 06 184 + 185▸LBL 99 186 RTN 187 SF 22 188 END
(04-19-2022 03:40 PM)Thomas Klemm Wrote: [ -> ]Apparently I didn't make that clear: in general you can just copy and paste a listing for the HP-41C into Free42 and it will be parsed.
But for some reason XEQ IND Z is ignored.

Thanks for clarifying Thomas.
Your version is indeed much shorter, and doesn't lack functionality, I'm not wrong.

Best,
ÁM
(04-18-2022 05:24 PM)Thomas Klemm Wrote: [ -> ]At the risk of beating a dead horse, here's the infamous Mach number:

$\sqrt{5 \left( \left( \left( \left( \left(1 + 0.2 \left(\frac{350}{661.5} \right)^{2} \right)^{3.5} - 1 \right) \times \left(1-6.875 \times 10^{-6} \times 25500 \right)^{-5.2656} \right)+1 \right)^{0.286}-1 \right)}$

( 5 * ( ( ( ( ( 1 + .2 * ( 350 / 661.5 ) X^2 ) ^ 3.5 - 1 ) * ( 1 - 6.875E-6 * 25500 ) ^ -5.2656 ) + 1 ) ^ .286 - 1 ) ) SQRT

0.835724536

No issue calculating the Mach number in manual mode onto a DM41X or HP41C.
(04-20-2022 05:55 AM)Ángel Martin Wrote: [ -> ]
(04-19-2022 03:40 PM)Thomas Klemm Wrote: [ -> ]Apparently I didn't make that clear: in general you can just copy and paste a listing for the HP-41C into Free42 and it will be parsed.
But for some reason XEQ IND Z is ignored.

Thanks for clarifying Thomas.
Your version is indeed much shorter, and doesn't lack functionality, I'm not wrong.

Best,
ÁM

i just cobbled up together the three AOS versions into a ROM image so you can play around a little. Bulk Key-assignments for AOS57 (Thomas') and AOS67 (Jim's) are also included (not needed for Greg's AOSXM).

As an extra bonus I added Valentin Albillo's "STACK-N" program, which is kind of related to the subject although coming from the opposite side, if you know what I mean.

Enjoy,
ÁM
(04-20-2022 07:07 AM)Chr Yoko Wrote: [ -> ]No issue calculating the Mach number in manual mode onto a DM41X or HP41C.

Mach Formula

I used this Python to RPN converter to translate the following function:
Code:
def mach():     return SQRT( 5 * ( ( ( ( ( 1 + .2 * ( 350 / 661.5 ) ** 2 ) ** 3.5 - 1 ) * ( 1 - 6.875E-6 * 25500 ) ** -5.2656 ) + 1 ) ** .286 - 1 ) )

But alas it gave me an error:
Potential RPN stack overflow detected - expression too complex for 4 level stack - simplify! [5, 1, 0.2, 350, 661.5], line: 4
return SQRT( 5 * ( ( ( ( ( 1 + .2 * ( 350 / 661.5 ) ** 2 ) ** 3.5 - 1 ) * ( 1 - 6.875E-6 * 25500 ) ** -5.2656 ) + 1 ) ** .286 - 1 ) )

The fix was easy. I just had to move the multiplication by 5 to the end:
Code:
def mach():     return SQRT( ( ( ( ( ( 1 + .2 * ( 350 / 661.5 ) ** 2 ) ** 3.5 - 1 ) * ( 1 - 6.875E-6 * 25500 ) ** -5.2656 ) + 1 ) ** .286 - 1 ) * 5 )

This is the generated program for the HP-42S:
Code:
00 { 75-Byte Prgm } 01 1 02 0.2 03 350 04 661.5 05 ÷ 06 X↑2 07 × 08 + 09 3.5 10 Y↑X 11 1 12 - 13 1 14 6.875ᴇ-06 15 25500 16 × 17 - 18 -5.2656 19 Y↑X 20 × 21 1 22 + 23 0.286 24 Y↑X 25 1 26 - 27 5 28 × 29 SQRT 30 END

0.835724535175

Monster Formula

Again the naïve approach fails with:
Potential RPN stack overflow detected - expression too complex for 4 level stack - simplify! ['_result_', 6, 7, 2, 3], line: 4
return 1 - 2 * 3 ** 4 / 5 + SIN( 6 - 7 ** (2 / 3 ) ) * FACT(8) + LN( ( - 9 ** 2 ** 3 * 45 ** ( 6 / 7 ) ) ** 2 )

We have to rearrange the terms a bit:
Code:
def monster():     return LN( ( - ( 9 ** 2 ** 3 * 45 ** ( 6 / 7 ) ) ** 2 ) ) + SIN( 6 - 7 ** 2 ** INV(3) ) * FACT(8) + 1 - 2 * 3 ** 4 / 5

This generated the following program for the HP-42S:
Code:
00 { 58-Byte Prgm } 01 -9 02 2 03 3 04 Y↑X 05 Y↑X 06 45 07 6 08 7 09 ÷ 10 Y↑X 11 × 12 X↑2 13 LN 14 6 15 7 16 2 19 Y↑X 17 3 18 1/X 20 Y↑X 21 - 22 SIN 23 8 24 N! 25 × 26 + 27 1 28 + 29 2 30 3 31 4 32 Y↑X 33 × 34 5 35 ÷ 36 - 37 END