# HP Forums

Full Version: Calculator benchmark
You're currently viewing a stripped down version of our content. View the full version with proper formatting.
Pages: 1 2 3
I've written a silly benchmark for my growing calculator collection- it measures the number of keystrokes necessary to transform a table of numbers through some equations. The results are here:

Calculator Benchmark

It's missing something from the HP-48 series- I just bought an HP-49g+ but I'm an RPL newbie. Is there something readily available (on the calculator by default), but better than INPUT for this task? I'm looking for a function that will prompt the user for a number that will be assigned to a variable, but it should offer to just use the old value of the variable instead- hit enter to keep the current value, something like that. It does not appear that INPUT can do this... I think it could insert the old variable value, but then you would have to backspace over it to enter a new value. Am I missing something?
Hi, nice benchmark, I always notice that not all calculators, especially programmable, are easy t use. Same of them didn't spare keystroke at all.

Here how I will setup, enter the table without repetitions to get all individual X and Y results on responsible HP-28S. I presume this can be done exactly the same way on a HP-28Csince I don't use here any specific capability of the 'S' version but only setup the solver menu for interactivity and practical use with spare keystrokes.

It is certainly possible to use the same trick on HP48/50 series, but I am unable to count the exact score since user interface, menu's access and keyboard are quite different on later RPL calculators.

HP-28S
f, [...] and (...) indicate respectively shift key, physical or soft-menu keystrokes.
Code:
```SETUP                                            Description                              Keystrokes                                                f [LOGS]                                         Setup LOGS menu                             2 A  f X²     A    +  B  (LN)  - B  f X²  (LN)  =  [ENTER]                        Enter equation in the stack                14  [SOLV] (STEQ) (SOLVR)                            Start solver menu                           3```
Total 19 keystrokes to setup equation \( A^2+A-LN(B) = LN(B^2) \) ready for efficient use of the table entries in solver.

DATA ENTRY and (X;Y) results DISPLAY through the powerful solver menu interface:
Code:
``` 3.12 (A) 2.56 (B)  (LEFT=)  (RIGHT=)             Enter first data pair                                                                      and displaying X and Y                12            1.28 (B)  (LEFT=)  (RIGHT=)                                                    7            .64 (B)  (LEFT=)  (RIGHT=)                                                    6  6.24 (A)           (LEFT=)                       Y result unchanged                     6 12.48 (A)           (LEFT=)                       Y result unchanged                     7 24.96 (A)  .32 (B)  (LEFT=)  (RIGHT=)                                                   12           .16  (B)  (LEFT=)  (RIGHT=)                                                    6           1.32 (B)  (LEFT=)  (RIGHT=)                                                    7 18.59 (A)           (LEFT=)                       Y result unchanged                     7 17.63 (A)           (LEFT=)                       Y result unchanged                     7           2.64 (B)  (LEFT=)  (RIGHT=)                                                    7           5.28 (B)  (LEFT=)  (RIGHT=)                                                    7```
Total 91 keystrokes for the Table entry and display of each X and Y results.
Score : 110 keystrokes

EDIT:

Just realize by writing this post that two more keystrokes can be spare when entering table 4th and 5th pair:
Since 12.48 is 2 * 6.24, instead of typing 12.48 (A), one may spare a troke by entering A [,] A [+] (A) ( or A [SPACE] A [+](A) ).
And the same trick can be used for the next entry : A [,] A [+] (A) instead of 24.96 (A) since \(24.96=2*12.48\).

The final score of HP-28C/S may be reduce to 108 !
I found a way to spare keystrokes on HP-15C:

HP-15C

SETUP:
Code:
```g P/R  f CLEAR PRGRM                              Enter new program                      4                                       f LBL A  STO 0  GTO 1                               Code to input A and goto display     7  f LBL B  STO 1                                      Code to input B                      5 f LBL 1  RCL 0  **ENTER** g x²  **+**  RCL 1  **g** LN  -  f PSE    Code to display X=A²+A- LN B        16 g LSTx  ENTER  +                                    Code to display Y= LN B² = 2.LN B    4      g P/R  f USER                                     Return to RUN mode and                 4                                                   USER mode easiest start of A & B codes```
Total of setup is 40 keystrokes.

TABLE ENTRY and RESULTS Display: X and Y displayed after each press of A or B key.
Code:
```**2.56  B    3.12  A  **                            // [←]  2.56  B                   Eventual press [←] to clear ERROR 0 when non initialized register R1 (B value) is zero   10                1.28  B                                                                    5                .64  B                                                                    4 6.24  A                                                                                  5 2  RCL*0  A                             (12.48=2* 6.24)                                  5 2  RCL*0  A    .32  B                   (24.96=2*12.48)                                  8                .16  B                                                                    4               1.32  B                                                                    5 18.59  A                                                                                 6 17.63  A                                                                                 6               2.64  B                                                                    5               5.28  B                                                                    5```
Total 69 keystrokes for table entry and individual X and Y result display. if the user is not concentrate enough to read the X value during the pause, one additional press on the [X<>Y] key may exchange X and Y on display.

Score : 109
In case of a full functional and awake user !

**EDIT: keystrokes count and summation corrected
Neat! I'm going to have to get me one of these HP-28s..

I think they broke this to some degree in the HP-49G+, unless the exact solver is still available in it somewhere that I haven't found. In the NUM.SLV / "Solve equation" screen, you can enter the equation (if you hadn't STEQ'd it already), have it query for the variables, and you can hit "EXPR=" (on of the F keys) to evaluate the sides. But the results are not shown until you leave the solver (press ON, then shows left and right).

Update: yeah I checked this in emu48. C.Ret's solution works on the HP-48S and HP-48SX, but does not work on HP-48G. The "improved" solver on the graphing calculators breaks it.

On some calculators you can make two equations into one by using complex numbers: one equation is real, the other is imaginary. Maybe there is something with vectors to extend this further..
Yes, in the HP-28S solver pressing (LEFT=), (RIGHT=) or (EXPR=) temporary display the value and its label on top of the display and enter the value in the stack where it is visible and stay here until the user drop it or clear the whole stack.

The (LEFT=) and (RIGHT=) appear only because I intentionally group the two formulae in one equality.

One big advantage of the Clamshell calculators is the full keyboard for direct alphabetic characters. In contrary to later series, the [alpha] key only serve in rare and specific command-line entries. Easy activation of numerous menus with rows of six soft-menu key spare a lot of prefix key when typing, setting or launching functions.

SHARP PC-1211

SETUP:
Code:
```[MODE][MODE]                             2  Enter program mode 1 "A"AREAD A [ENTER]                    10 ["] are [shift][W], no need to type any space 2 "B"AREAD B [ENTER]                    10 AREAD is abbreviated as [A][.]  3 PRINT AA+A-LN B,LN BB [ENTER]         18  PRINT is abbreviated as [P][.], the comma is [shift][O], no need to type any space  [MODE][MODE]                             2  return to DEF mode (for easiest code launch)```

Total 42 keystrokes to enter program and setup mode. Plese note the heavy use of implicit multiplication.

Code:
```3.12  def-A  [CL]                           def-A is [shift][A] in def mode, [CL] is need when B is set to zero (clear error state)              2.56  def-B                12  display X and Y on some screen               .5B   def-B                5      "               .5B   def-B                5      "       2A    def-A                              4      " 2A    def-A                              4      " 2A    def-A                              4      "               .32   def-B                5      "               .16   def-B                5      "              1.32   def-B                6      " 18.59 def-A                              7      " 17.63 def-A                              7      "                2B  def-B                 4      "                2B  def-B                 4      "```

Total 72 keystrokes to input table values and systematically show X and Y on one display (or print the two values on printer is connected).

Score : 114 keystrokes
And the two X and Y results clearly displayed on both halfs of the display after each entry.

**EDIT: [CL] can be spare by entering B before A to avoid LN(0) error !
>PC-1211..

"2A": EL-512 has this, but it does not work so well. When you enter "Kn" it always multiplies, so you have to enter 1 ahead of time if you don't want it to.

AREAD comand... very nice feature of PC-1211. Do the other BASIC pocket computers have this?

Binding key to line label with "defm", also nice. Actually TI-59 could use this idea, just as you did with the HP-15c. But I do prefer some kind of prompting, remind me what the old values are.
Using newRPL on a 50g:
Entering A: 45 keystrokes
Entering B: 45 keystrokes
Computing X and Y: 14 keystrokes

Using newRPL on a Prime G1:
Computing X and Y: 10 keystrokes (because the x^2 key is not shifted and LN isn't shifted)

Total:
newRPL on Prime = 100 keystrokes
newRPL on 50g = 104 keystrokes

**EDIT**:
Starting with an empty stack, creating the lists for A and B can be done using the interactive stack in 6 and 7 keystrokes respectively (instead of 9+9), lowering the count to 95 for the Prime and 99 for the 50g.

Code:
``` Entering A: 5 ---- 3.12 [Ent] (enter 3.12 to the stack) 1 ---- [Ent] (second 3.12) 1 ---- [Ent] (third 3.12) 3 ---- [Ent] [Ent] [+] (6.24) 3 ---- [Ent] [Ent] [+] (12.48) 3 ---- [Ent] [Ent] [+] (24.96) 1 ---- [Ent] (second 24.96) 1 ---- [Ent] (third 24.96) 6 ---- 18.59 [Ent] 6 ---- 17.63 [Ent] 1 ---- [Ent] (second 17.63) 1 ---- [Ent] (third 17.63) Total = 32 to enter the numbers To make a list (12 ->LIST) 9 ---- 12 [Ent] [Shift][0] [Alpha]+[L]+[Right] [Ent] To store as 'A' ('A' STO): 4 ---- [O] [Alpha]+[A] [M] Total to enter A as a list and store it in variable 'A': 45 Entering B: 5 ---- 2.56 [Ent] (enter 2.56) 3 ---- [Ent] 2 /  (enter 1.28) 3 ---- [Ent] 2 /  (enter 0.64) 1 ---- [Ent] (second 0.64) 1 ---- [Ent] (third 0.64) 3 ---- [Ent] 2 /  (enter 0.32) 3 ---- [Ent] 2 /  (enter 0.16) 5 ---- 1.32 [Ent] (enter 1.32)   1 ---- [Ent] (second 1.32) 1 ---- [Ent] (third 1.32) 3 ---- [Ent] [Ent] +  (enter 2.64) 3 ---- [Ent] [Ent] +  (enter 5.28) Total = 32 keystrokes to enter the numbers + 9 to make a list (same as case for A) + 4 to store it as 'B' Total of 45 keystrokes to input B (by chance is the same as for A) Computing X is 9 keystrokes (leaves X as a list on the stack, add 4 keystrokes if you want to store it on variable X but the benchmark did not specify that, only display): [A] [A] [*] [A] [+] [B] [Shift] [LN] [-] Finally, computing Y is 5 more: [B] [B] [*] [Shift] [LN] Total = 45 + 45 + 9 + 5 =104 keystrokes. On a Prime G1 keyboard, though, computing X is only 7 keystrokes: [A] [x^2] [A] [+] [B] [LN] [-] and computing Y only 3: [B] [x^2] [LN] Hence the total = 45 + 45 + 7 + 3 =100 keystrokes.```

PS: I think this is an interesting benchmark, should probably be moved to the general forum. I'd say if HP calculators are present in the benchmark, it's definitely HP calculator related.
Trying this on my HP-49G+ in "old" RPL... immediately I run into "the + operator does not concatenate or extend lists anymore: use ADD instead". Very unfortunate that ->LIST is buried in menus. Also, Tool/View/Text.. even so, this is quite good.

I can see some of inspiration for the chosen differences in newRPL..
(08-08-2021 09:57 PM)jhallen Wrote: [ -> ]AREAD comand... very nice feature of PC-1211. Do the other BASIC pocket computers have this?

.
Well, the HP-71B has it, called DISP\$.

V.
Thank you for the exercice.

https://github.com/jhallen/calculator/wiki/HP-15c
"Like all good HP calculators, it has the %change operator."
Are you kidding ?
I never use(d) the % key, prefering typing directly hundredth. I'm not alone certainly. Probably for the same reason why this function was later hidden in a submenu.

I like(d) the HP-15C very much.
Surely
Code:
``` RCL 0  ENTER  X^2  +```
is shorter than
Code:
``` RCL 0  X^2  RCL+ 0```
?

Cheers, Werner
(08-08-2021 08:05 PM)jhallen Wrote: [ -> ]Update: yeah I checked this in emu48. C.Ret's solution works on the HP-48S and HP-48SX, but does not work on HP-48G. The "improved" solver on the graphing calculators breaks it.
HP 48GX based on C.Ret one,
(flag 3 unchecked = symbolic function)

[L] SOLVE [_ROOT_softkey] 3 (left SOLVE is hidden on keyboard)
alpha A [L]x^2 alpha A + alpha B [R]LN - 12
alpha B [L] X^2 [R] LN [L] = 8
[L] [EQ softkey] 2 (equivalent to STO into EQ)
[_SOLVR softkey] 1 (activate Solvr menu with 'white' softkeys)

Total : 3+12+8+2+1 = 26

Differently and shorter :
' alpha A y^x 2 + alpha A [R]= [R]LN alpha B y^x 2 16
[L] [EQ softkey] 2

Total : 3 + 16 + 2 + 1 = 22

Regarding results : the 'EXPR=' white softkey returns tagged values on 2 lines :
2: Left: value
1: Right: value
hence only one "EXPR=" white softkey is necessary for each pair of result values
Hah hah, yup. I've updated it.

(08-11-2021 11:49 AM)Werner Wrote: [ -> ]Surely
Code:
``` RCL 0  ENTER  X^2  +```
is shorter than
Code:
``` RCL 0  X^2  RCL+ 0```
?

Cheers, Werner
Not % (which I agree is useless), but %change or delta% equivalent to: (a - b)*100/b.

BTW, I think this Sharp EL-506 also has this key (look above x^2), but later models like the EL-501P don't have it.

EL-501

(08-11-2021 09:00 AM)OlidaBel Wrote: [ -> ]Thank you for the exercice.

https://github.com/jhallen/calculator/wiki/HP-15c
"Like all good HP calculators, it has the %change operator."
Are you kidding ?
I never use(d) the % key, prefering typing directly hundredth. I'm not alone certainly. Probably for the same reason why this function was later hidden in a submenu.

I like(d) the HP-15C very much.
(08-11-2021 01:16 PM)jhallen Wrote: [ -> ]Not % (which I agree is useless), but %change or delta% equivalent to: (a - b)*100/b.

EL-501

[quote='OlidaBel' pid='151034' dateline='1628672448']
Maybe I read to fast, you're right, I agree for the %change.
(08-11-2021 04:33 AM)jhallen Wrote: [ -> ]Trying this on my HP-49G+ in "old" RPL... immediately I run into "the + operator does not concatenate or extend lists anymore: use ADD instead". Very unfortunate that ->LIST is buried in menus. Also, Tool/View/Text.. even so, this is quite good.

I can see some of inspiration for the chosen differences in newRPL..

Yeah, some menus need keyboard shortcuts (List, Matrix, etc.) which are not implemented yet.

Anyway, I just looked at your updated benchmark page, nice to see the 48 (49/50, etc) is still king for number crunching. The stack environment really keeps your productivity up there. There's no doubt it belongs if not at number one, among the top calculators out there, for whatever you throw at it can be done efficiently.
(08-08-2021 08:25 PM)C.Ret Wrote: [ -> ]SHARP PC-1211

Total 42 keystrokes to enter program and setup mode. Plese note the heavy use of implicit multiplication.
Total 72 keystrokes to input table values and systematically show X and Y on one display (or print the two values on printer is connected).
Score : 112 keystrokes
And the two X and Y results clearly displayed on both halfs of the display after each entry.

Very nice to use AREAD with the DEF-key! I used it a lot back in the 80s to chain calculations for circuitry, the last value PRINTed also feeds back into AREAD. This, together with abbreviated commands (A. for AREAD, P. for PRINT, I. for INPUT, F. for FOR, etc) saved a lot of keying.

I tried your program on a PC-1250A. There is no MODE key on the PC-125x, but a mode slider. That saves 2 keystrokes (mode sliding counts as one keystroke; one click action), for a total of 110 keystrokes for the PC-1250A (and all PC-125x).

On the PC-126x, PC-13xx and PC-14xx there is no support for implied multiplication syntax. This adds 4 keystrokes to the program for A*A and LN(B*B). Value 2A becomes 2*A (3 more keystrokes for three inputs) and .5B becomes B/2 (same keystrokes for two inputs), giving 117 keystrokes total for the PC-126x, PC-1350/60 and PC-14xx series (mode switching takes one keystroke or one slider click).

Edit: in hindsight, the PC-14xx supports the SQU function with the [x^2] key and the LN function with the [LN] key, so takes just 13 (or 14 when comma requires SHIFT) keystrokes to enter P.[x^2]A+A-[LN]B,[LN][x^2]B instead of 19 (or 20 when comma requires SHIFT) to type out the full P.A*A+A-LNB,LN(B*B). The PC-13xx and PC-14xx have a dedicated comma key without SHIFT, thus 110 keystrokes for the PC-14xx series. The PC-126x requires SHIFT for the ( and ), thus 117+2=119 keystrokes for the PC-126x series. The PC-1250A has implied multiplication but requires SHIFT with ( and ), thus 112 keystrokes for the PC-125x(A) series.

Alas, SHARP decided to get rid of the AREAD command and the DEF-key for their later models PC-E500(S) and the PC-G8xx series.

- Rob
(08-08-2021 05:42 AM)jhallen Wrote: [ -> ]Is there something readily available (on the calculator by default), but better than INPUT for this task?

Purely from a data entry perspective, my inclination would be to simply use the matrix writer for inputting the data. It's easy to activate (left-shift MTRW), and once you've established the first two entries and started the next row, it "knows" that you are entering a 2-column matrix. Subsequent entries could be entered in sequence with the enter key and possibly RS-COPY and RS-PASTE for the repeated entries if desired. A final ENTER places the resulting matrix on the stack.

You could then use either the matrix commands or convert the result to a list with AXL and process the result as a list of lists. If using the list approach, a final AXL will convert the data back to matrix form.

While I'm sure you could find a solution with fewer keystrokes needed for the computational part (the sheer number of commands available on the 49/50 dictates deep/lengthy menus), I'm looking at this more from a practicality standpoint than a keypress competition. When entering data, I think there's great value in seeing more of the data while doing the entries. Navigating within the matrix for copy/paste/correction is also intuitive. The matrix writer handles this nicely.
(08-09-2021 08:14 PM)Claudio L. Wrote: [ -> ]PS: I think this is an interesting benchmark, should probably be moved to the general forum.

I agree with you it is a good benchmark that qualify equally the calculator and the ingenuity of the drilled user !

Your method building up the two list in the stack really impress me, that’s shame that not "list arithmetic" exist on my HP-28S !

(08-11-2021 11:49 AM)Werner Wrote: [ -> ]
Code:
`RCL 0  ENTER  g X^2  +`
is shorter than
Code:
`RCL 0  g X^2  RCL+0`

Good catch !

(08-11-2021 05:18 AM)Valentin Albillo Wrote: [ -> ]Well, the HP-71B has it, called DISP\$.

I have to admit that I have an hard time to adapt my code using the AREAD instruction to the HP-17B. I lost myself in many complicated detours and useless escape key sequences.
Finally, restarting from an empty scratchpad, I get something competitive :

HP-71B

Setup:
Code:
```EDIT                                     2      Activate new 'workfile' 1 DISP A*A+A-LOG(B);LOG(B*B) [EndLine]  20      Don't have to type the DISP implicit display instruction,LOG( is [f][-]. KEY "(",'A=VAL(DISP\$)@RUN':  [EndLine]  31      KEY is [f][I]and DISP\$ is [f][J][←][g][4] KEY ")",'B=VAL(DISP\$)@RUN':             14      [g][CMDS] [→][→][→][→][→] [ ) ] [→][→][→][→] B [EndLine]```
Total 69 keystrokes for the setup in a fresh workfile.

Note that I am not using the expected A and B keys, you will see why:

Data entry and results display:
Code:
```f USER               2      Activate USER mode  2.56 )  3.12 (       9      display first X and Y results for (3.12,2.56) on the same display. Note that starting with B entry avoïd any LN(0) error  B/2 )                4      set B to 1.28 and display the two corresponding in one display.  B/2 )                4      set B to .64 and display X & Y 2*A (                4      set A to 6.24 and display X & Y 2*A (                4      set A to 12.48 and display results 2*A (  B/2 )         8      set A to 24.96 and B to .32 and display result  B/2 )                4      set B to .16 and display results 1.32 )               5      set B to 1.32 and display results 18.59 (              6      set A and display results 17.63 (              6      set A and display results 2.64 )               5      set B and display results 5.28 )               5      set B and display results```
Total 66 keystrokes for computing the table

Score 135 keystrokes for the HP-71B
Not bad for the "Ugly Duckling" !
SHARP PC-E500(S): 106 keystrokes!

The SHARP PC-E500(S) blows most other calculators out of the water.

[LN] refers the LN key and [x^2] refers to the squaring key. [BASIC] switches modes. Commands are abbreviated as usual: I. is INPUT, P. is PRINT, G. is GOTO, and R. is RUN. Colon is [2nd];

The program:

Code:
```[BASIC]                                      1 enter PRO MODE 1I.A[ENTER]                                  5 2I.B[ENTER]                                  5 3P.[x^2]A+A-[LN]B,[LN][x^2]B:G.1[ENTER]      20```

The table:

Code:
```[BASIC]          1 enter RUN mode [PF1][ENTER]        2 run (function key 1 for RUN) 3.12[ENTER]      5 2.56[ENTER]      5 displays X and Y [ENTER]          1 A is unchanged B/2[ENTER]       4 displays X and Y [ENTER]          1 A is unchanged B/2[ENTER]       4 displays X and Y 2*A[ENTER]       4 [ENTER]          1 B unchanged displays X and Y 2*A[ENTER]       4 [ENTER]          1 B unchanged displays X and Y 2*A[ENTER]       4 B/2[ENTER]       4 displays X and Y [ENTER]          1 B/2[ENTER]       4 displays X and Y [ENTER]          1 B/2[ENTER]       4 displays X and Y 18.59[ENTER]     6 [ENTER]          1 B is unchanged, displays X and Y 17.63[ENTER]     6 [ENTER]          1 B is unchanged, displays X and Y [ENTER]          1 A is unchanged 2*B[ENTER]       4 displays X and Y [ENTER]          1 A is unchanged 2*B[ENTER]       4 displays X and Y```

Edit: just realized that A*A can be [x^2]A and colon is [2nd];

Edit 2: ... oh well, so apparently the browser didn't scroll the table with the PC-1211 program and inputs I looked at, so I missed some inputs (there are 12 results, not 10, for a total of 107 keystrokes). Never do this kind of thing right before dinner time

Edit 3: saved one keystroke (now 106) by using function key F1 instead of R. for RUN, because F1 is by default RUN.

- Rob
Pages: 1 2 3
Reference URL's
• HP Forums: https://www.hpmuseum.org/forum/index.php
• :