What to start a collection with


I currently don't own any HP calculators, but I have often really liked them and the HP quality. I have played with a few and I think I understand the RPN nature.

My question is, what are some good models to start a collection with? Should I go with some of the really early models first, or should I go with something that is newer (10C series).

Any help would be appreciated.



buy one you will use.


Hi Vince...

I would start with an HP67. In the latter seventies, this was the definitive machine from HP. With it's card reader it's way cool and much fun to play with. This will enable you to collect the software (pre-recorded cards) for this machine as well.

Best regards, Hal


Perhaps you'd like to hear some advice from the curator himself:





If you're on a budget, start with what you can find. Look around. Ask around. You may get lucky. I know I did!

Good luck!



Get a few emulators to start with. Figure out what you like.

Windows (all free):

  1. Debug4x will give you 48GX, 48GII, 49, 49G+, and 50g. Start with the 50g since you can buy them new today.
  2. Free42 is a very cool HP 42S simulator.
  3. V41 is a very complete HP 41CX emulator.
  4. Nonpareil emulates about 20 older HPs including LED models. Run the original HP 35.
  5. EMU71 and EMU41 are CLI-based 71B and 41CX emulators. For 41CX I prefer Nonpareil and V41. For 71B EMU71 rocks.

Linux (all free):

  1. Debug4x. You'll need to setup WINE (assuming x86 or x86_64 box)
  2. x48 is a 48GX/SX emulator.
  3. Free42.
  4. Nonpareil.
  5. EMU71 and EMU41. Install DOSEMU (x86/x86_64 only) or DOSBox (any arch).

Mac (all free):

  1. Debug4x. You'll need to setup Parallels, WINE or something similar.
  2. There is an older EMU48 around. No 49G+ or 50g support.
  3. x48.
  4. Free42.
  5. Nonpareil.
  6. EMU71 and EMU41. Install DOSBox.

50g: (Just too cool, but if you get the 50g and want to spend some $ check out http://www.hrastprogrammer.com/)

  1. 71X: 71B emulator.
  2. 41X: 41C emulator.
  3. 42X: 42S emulator.
  4. 11E: 11C emulator.
  5. 12E: 12C emulator.
  6. 15E: 15C emulator.
  7. 16E: 16C emulator.

I am more of a user than a collector. IMHO as a user you cannot go wrong with a 15C or any programmable RPN/RPL for that matter.

On eBay the 15C, 42S, 41CX, 71B, 67 are usually the most in demand (expensive).

Think twice about the 41CX and 71B. The are expandable with many options. More so if you go the HP-IL route. Be prepared to quickly get addicted and spend a lot of cash.

Lastly I only stared collecting in 2006 when I couldn't get a decent RPN calculator. I still had my original 15C and 48GX, and I realized they would be hard to replace. But with the 50g and now the new 35S, there may be little need to collect (if you are a user).

Edited: 11 June 2007, 6:53 p.m.


I've tried a bunch of emulators on PC, Linux and Palm and one of my favorites is the P41CX emulator that runs on the Palm OS. If you happen to have a Palm (especially if you have one that will do 320x480 resolution) then P41CX is just great. It emulates the HP-41CX - and it also comes with a free emulation of the HP-41CX add-on module called the "Advantage" roms, which has a bunch of very useful programs. P41CX also emulates a printer that can be attached to an HP-41CX - results of printouts from the calculator go to the Palm OS "Memo" application where you can review them. Some of the HP-41CX modules make use of a printer - to do things like amortizations of a mortgage - it is very neat to run these in the emulator. You can find out more about P41CX here:

Palmgear P41CX

The version you pay for includes access to a multitude of other add-on module emulations and only costs $11.00.

In any event, I highly recommend running a bunch of the emulators and reviewing documentation on this site to get an idea of how the calculators work before you decide which real calculators you'd like to buy.

Good Luck,



Many sound suggestions were given in this thread. One statement by Egan compels a follow-up:

On eBay the 15C, 42S, 41CX, 71B, 67 are usually the most in demand (expensive).

There's a good reason for that: These are among the most impressive models ever made by HP.

My list of "best" models (for one reason or another): HP-67/97, HP-41CX, HP-15C, HP-71B, HP-42S, HP-17BII, HP-32SII, HP-48GX

My list of "most distinctive" models (for one reason or another): HP-34C, HP-16C, HP-27S, HP-28S

Most of the above are somewhat expensive (US$150+) on eBay, but a few (e.g., HP-17BII, HP-28S) are more affordable.

-- KS


But one that you are curious about, but unless you want to start with a rebuild project, be careful to buy something that works.


Yeah, decisions, decisions.... We all can only relate to our own background and experiences... When I began my collection I was mainly focused on what I could use and I saw a real desire for a desktop scientific and there were none outside of the old classics. I was focused on getting a 97 to sit on my desk and be a collector's item and also useful... I began to study this site, EBay, etc. for prices and quality etc. At the time I did not look forward to sending $$$$ and getting a broken POS... I found a posting on this site for an HP-45 for $100 and sent the money and waited... What I received was wrapped in a brown paper bag from a supermarket .. the HP-45, case, and battery, no box, or protective padding outside of the case. On opening it turned out to be absolutely mint condition, as if it had never been used (both case and calculator). This hooked me big time into my collection that has all bu the Hp-70. I never got a calculator in as good a condition as the first HP-45 (though close)... I was in high school when the Hp-35 came out so I have memories of all the pocket calculators during the early models. I think the LED models provide the best memories of the early development. Certainly the HP-41 was the peak of performance and capabilities before they became commodities and computational power drove to PC dominance (the market for calculators was then driven by the educational market)

Good Luck and happy shopping, hope you are lucky!


I agree. The 67 and 97 is a great combo. I use the 97 at home and the 67 at the office. I use the mag cards to trade data and programs. The display is much easier on over 40 eyeballs. And the printer is great for documenting programs or debugging in trace mode.

I was too young to afford any of the Classic series; but I was envious of those who could. The 11c was my first HP. Now I collect Classics. I think they are more interesting historically. And the card readers are great. Plus my other hobby is electronics, and repairing the Classics is relatively easy.


Start with what you can get without spending a small fortune. Older HP calculators sometimes show up at thrift stores (though that's becoming less common), garage sales, estate sales, etc.



My advice: Be patient, first of all! (Unless, of course, you have access to unlimited funds :-) )

As others allready said, good HP calculators do not necessarily need to be expensive. Even on eBay, bargains can be found from time to time. With patience, of course...

But one model that is a must for every collector, whatever his interest may be!, is certainly the hp-35!

Greetings, Max


The HP-35 is the first scientific hand held calculator. It's cool to have one, but I did without for quite awhile. I didn't take the plunge until this year, it being the 35th anniversary of the HP-35. The reason I held off is that the 35 is no great shakes as a calculator. It's not programmable, and has just a basic set of functions. to be sure, those were revolutionary in the package HP delivered in 1972. But I'm an enthusiast (what Egan calls "a user") first, and a collector second. I like to do stuff with my calculators. I also like to buy machines I used when I was starting out. for me, that meant the 41CX first.

Egan has given you a very nice survey of what's available. His tastes match mine pretty closely, I've noticed. So for me, an expandable, programmable system has an edge. The 41CX matches this description, and so does the 71B. The 50G has PC connectivity, and SD card memory expansion. It is also the absolute geekiest of HP calculators, in terms of programming, and mathematical diversity. That also means that is the most challenging machine to use effectively. That's a plus for me, since I do that sort of thing for entertainment.

One other machine captured my heart. That was the HP-97. I just love the look of that machine, and its ease of use. it sits on my desk, and gets almost daily use.

My best advice is follow your heart, but don't leave your head out of the conversation. That's been my approach, and it has served me well.




One other machine captured my heart. That was the HP-97. I just love the look of that machine, and its ease of use. it sits on my desk, and gets almost daily use.

I agree 100 percent with this statement :-) The '97 was the first hp calculator in my collection and is still one of my favourites (beside the '25 and the 71B, the only LCD calculator that I really like to use). Many years back, I even used an hp-97 at work, but that wasn't mine then.

In my daily business, I have not much use for a pocket calculator, but for playing around, I prefer either a Curta or the almighty Ti Voyage 200, that beats everything that hp has ever made in every respect. Sad but true...

Greetings, Max

Edited: 12 June 2007, 4:49 a.m.


Thanks everyone for your comments. I have seen the HP-97 and it is really cool looking. That may be a bit much for me though to start out with.

I guess the one thing I kept seeing in the posts is be patient. Sounds like what my folks used to always say about not buying the first car you see, or marry the first girl you meet.

My Dad does have a HP 15C I think (either that or the 11C.. one of those). I also do like the 41C series, but those look like they are quite expensive. I remember a friend of mine having one in college and I fell in love with it and wanted one badly, but just could never part with that type of money.

Tell me a little more about the programing (sorry, I know that is a loaded question). What exactly can it do? Is it easy to understand? I have looked at my dad's book that came with his, and it seem's kinda tough to understand as it does not resemble C or any of those languages. Yes, it has subroutines, but it just seems a bit odd. Do the larger machines like the HP97 program more like a computer or is it sort of the same?

Thanks again!



Most models are RPN. RPN is keystroke programming. Start here:


The 28/48/49/50 series introduced UserRPL. Some models support SysRPL and C. UserRPL meets most needs. UserRPL is somewhat keystroke somewhat structured (think FORTH/LISP).


The 71B has BASIC with optional RPN and FORTH. Assembly is also a possibility.

Some examples below:

Savage Benchmark in BASIC, RPN, FORTH, RPL:

BASIC (71B):

30 A=1
40 FOR I=1 TO 2499

RPN (41CX, 71B):

01 LBL "S"
02 RAD
03 FIX 9
05 HR
06 STO 01
07 2499
08 STO 00
09 1
10 LBL A
11 X^2
13 LN
14 E^X
16 TAN
17 1
18 +
19 DSE 00
20 GTO A
22 HR
23 RCL 01
24 -
25 3600
26 *
27 X<>Y

FORTH (71B):

2499 0 DO
1. F+
F. ." IN "
F. ." SEC"

RPL (48/49/50 series):

1 2499 FOR I
TICKS SWAP - B->R 8192 /

IMHO, you'll be most productive with the 50g--it's my everyday calculator. Multiply studies correlate screen size with productivity. I find the 71B + 41 Translator ROM (gives you RPN and FORTH) the most fun. But, almost nothing compares to the joy of getting the 15C with its limited memory and speed to solve very difficult problems (probably true for any pre-15C model).


I forgot to add. Lua is available for the 50g. If you want a C++/Java like interpreted language check out HPLua. HPLua example:

for i=1,2499 do

Edited: 12 June 2007, 12:06 p.m.


Okay... really dumb question, but why do they have these different languages? Were they seen as improvements over time. Also, what does the benchmark program do, and what does RPL stand for? Reverse Polish Language?
Can anyone also give me the highlights of what is the difefrence with RPL and RPN and what may or may not be the advantages to both.

Sorry for all the dumb questions gang.



May be you can just start with the 35s when it's available.


I second that Dia!

Egan... don't you think the 50G is a bit of overkill? I mean, I have the 48GX, and it is a very fine machine, but I think for the most part it is just overkill and very complicated to use.

For pure scientific, I love my 15C, and for pure business, I love my 17BII. These were great simple to use calcs (well, more simple that the 48gx). I think outside the classroom or academic area the 50G might be just too robust.

Just my thoughts.

- John


Egan... don't you think the 50G is a bit of overkill? I mean, I have the 48GX, and it is a very fine machine, but I think for the most part it is just overkill and very complicated to use.

I was recommending it because it is the best scientific HP you can buy today new. I would never recommend the 33S. As for the 35S. Yes, I'd start there too when it releases. It will be cheaper and easier to program. For my needs I require the 50g (but I also carry my 15C). Too bad the 35S does not have a size advantage, its not much smaller than the 50g.

Edited: 12 June 2007, 2:20 p.m.


Read the links I provided above on RPN and RPL.

BASIC was getting popular in the late 70s, early 80s. BASIC was my first language. I learned it on my first computer--the Apple II+. Sharp and Tandy also released 71B-like machines in 1982 (HP had the 75 in 1982).

FORTH is a popular fast embedded platform (more popular in the 70s/80s). Not a bad fit for the 71B with I/O capabilities. FORTH is still used today (Got a PPC Mac? You got FORTH in the BIOS).

C is obvious. Speed. C became very popular in the 80s and is very popular today.

Lua. Well, its small and fast like FORTH, but is structured like C++/Java (both popular now). FORTH is more like RPN/RPL/Postscript, i.e. stack oriented. Most nubee programmers fear the stack.

Use the right tool for the right job. No single tool will solve all problems efficiency. IANS, there are no universal concepts.

As for the benchmark, read: http://www.technicalc.org/tiplist/en/files/pdf/tips/tip6_50.pdf


.. why do they have these different languages?

The early programmable models all ran some variant of RPN, or else ran BASIC. RPN programming isn't monolithic either. There is a great deal of variation in what different models of calculator can do, although they all bear a close resemblance to one another in terms of programming structure. I think this is because HP invented pocket calculator programming, and was continuing to refine that, and the calculators themselves over time. By the time they released the 41C, they had started to give some thought to backward compatibility. If you bought the card reader for the 41, you could load 67/97 programs - the previous generation - right into the 41. The calculator would translate some instructions into ordinary HP-41C code, and some into special compatibility instructions that the card reader brought along with it.

The principle benefit of RPN programming is that is as close as possible to just entering the keystrokes you would use to solve a problem manually. This "keystroke programming" model is preserved today in the HP-33S, although in a flawed manner. (Search this site with Google to find out more.) The as yet unannounced HP-35S appears to be based on the 33S, but with at least one of the two major flaws of the 33S corrected. It allows "more than 800' data registers, which gives you something to do with the 32K of RAM. Whether it also allows more than 26 labels isn't known at this time We probably won't know for sure until the machine is released. That's rumored to be August 1.

As far as BASIC goes, there were two small machines that ran variants of BASIC. These are the HP-75 and HP-71B. BASIC was an obvious choice for small computers back then. Most would support a BASIC variant and assembler. The 71B had those, plus Forth, the ultimate "postfix" language. As Egan mentioned, the later addition of the 41C translator added RPN to the programming repertoire, although you couldn't do keystroke programming. (You had to create your program in an editor and then convert that into something the emulator could run.)

The RPL calculators were the result of a major change in HP's calculator software. This became visible to HP's customers in 1986 with the release of the HP-28C. Egan's links point you to the excellent treatment of this subject here at the museum. There was no provision for backward compatibility in these machines. But that was the standard approach in the industry in the 1980s.

.. and what does RPL stand for? Reverse Polish Language?

Very close. It's "Reverse Polish Lisp."

Can anyone also give me the highlights of what is the difefrence with RPL and RPN and what may or may not be the advantages to both.

This is a very deep subject, on which members of this forum have divergent views, to say the least. Superficially, RPN is about keystroke programming and RPL is about structure. they bear a spiritual relationship to one another in that a leading exponent of RPN, Dr. William Wickes, led the development of RPL. His book about RPN to RPL transition is enlightening in this regard. It's available on the Museum DVD. There is something close to a consensus that RPL is more difficult to learn, though a leading RPL expert who hangs out here disagrees. I love RPL because it has great depth and expressive power. But I had to pay several weeks of effort to learn it. I'm a systems engineer, with dozens of languages under my belt. But I'm also a guy that learned HP41 RPN as my very first programming language. Those facts are relevant to the time I took to learn RPL. I also wanted to learn RPL in some depth, which you may not have to do if you just need the calculator as a tool.

Sorry for all the dumb questions gang.

Nonsense. As you should be able to tell from the responses, we love questions of this sort. We get to rehash our opinions yet one more time for the benefit of someone that hasn't heard them 30 times already. 8)



Is there a good book that explains RPL?


HP49+ and HP48gII Advanced Users Reference contains a good tutorial on User RPL. This document on hpcalc.org is a PDF from 2000 that covers user RPL with examples. I haven't read it through, but it looks pretty good at a glance.

There are books available for programming RPL, mostly on the HP48. But the 50g is close enough - nearly identical in RPL syntax and structure - so that the books are still useful with today's high end calculators. Samson Cables still carries many of these books. You can sometimes find the same titles on eBay for less, but the supply is spotty. I have Graphics on the HP48G/GX and An Easy Course in Programming the HP48G/GX

I like the former more than the latter, but that may be because I knew most of what the second book had to offer by the time I got my hands on it, whereas I was ignorant of 48G graphics. The User RPL graphics are nearly identical to the implementation on the 50g, allowing for the larger screen on the newer machine.




Can anyone also give me the highlights of what is the difefrence with RPL and RPN and what may or may not be the advantages to both.

If you ask me, both have no real highlights, at least compared to programming languages that you might be familiar with from "real" computers (like Basic, Fortran, C or Java - some of them with user-friendly intuitive interfaces like MS Visual Basic, full-screen colour-coded editors and debuggers).

RPN is very similar to machine-code programming. You need paper and pencil to keep track of your register and memory contents and program flow. Debugging is nearly impossible without a printer and in most cases, it is quicker and easier to type in your program again than to hunt the bug.

About RPL I cannot say much, I'm afraid, because this "programming language" - or whatever one might call it - completely escapes me. My way of thinking (which was good enough to gain me a ph.d. in aerospace engineering) is totally incompatible with this thing. Not, that I did not try, but after working my way through the first 100 pages of the 500(!) pages of the hp-48 programming guide, I threw in the towel. No way am I ever going to write a single line of RPL code, and especially since I have little miracle-gadgets like a Ti Voyage 200 that I can easily program without having to look in the manual once.

Greetings, Max


My way of thinking (which was good enough to gain me a ph.d. in aerospace engineering) is totally incompatible with this thing.

It's true that neither of these languages are remotely similar to standard 3rd, 4th Web 1.0 or Web 2.0 generation programming languages. But others find they can wrap their minds around one, the other or both programming systems. I admit, I had a lot of difficulty in learning RPL. (I've had extended discussions about this on this forum. Search with Google if you are interested.) But I finally cracked that nut. But my education and career experience is in computer systems and networking, though nowhere near at the PHD level. I think this backround helped a lot with my struggles with RPL.

On the RPN side, it sounds to me like you were trying to program one of the non-printing LED models and/or a 10, 12, 11, or 15C. Those have no alphanumeric capability, and you have to decode numeric representations of the keystrokes in order to read the "source code." The coding used keystroke "coordinates." On the HP-67 for example, the STO key is in the third row and the third column, so its coordinate is 3,3. Decoding those numbers is feasible, but difficult, so I can understand your frustration at trying to program in that environment.

But I first learned RPN keystroke programming on the HP41C. This calculator was the first to include nearly full alphanumeric capability. (Not all the lower case letters were available, at first.) This allowed program listings to be viewed one line at a time in the calculator's display, and the commands had names instead of keystroke coordinates. This made it more feasible, but still not ideal, to debug a program on the calculator. And yes, I frequently resorted to paper and pencil to grasp what was going on with my code, or someone else's. But you know, some allowance has to be made for the fact that those calculators embody 1970s and 1980s technology. The comparison that makes sense for the 41C is with Applesoft BASIC, not Java or Visual BASIC. (Gods of computing, please forgive me for mentioning VB and Java in the same sentence. Aak! I did it again!)

RPL strikes me as obtuse. But there are those on this forum and elsewhere who swear that they find RPN hard and RPL easy. I think its not a matter of intelligence but of style. You see this sort of divide all over Computer Science. In the world of Unix/Linux scripting for example, the folks that like tidy code in a clean object oriented style go for Python. Those who want a tool that can adapt to their personal style, no matter how quirky or cluttered choose Perl. (That's a gross oversimplification, of course.) Then there is the famous vi vs. emacs split. Examples abound, and I think we are faced with another one here. For RPL, it helps immensely if you are used to and like Forth, which to this day is widely used in embedded systems. The stack oriented, postfix style of Forth is very similar in style to RPL. I would say that RPL is actually more readable than Forth! RPL can still be tough to write and especially, to read. Using the stack for arbitrary object means you can have all these anonymous globs of data hanging out there. It's your job to keep track of which is what and so forth. (Ouch! Forth is worse in this regard, you can have arbitrary numbers of stacks in Forth.) Some folks don't mind the mental gymnastics required to keep track of the stack, but it gives me a headache. You don't have to code this way in RPL, as a matter of fact. You can use named local variables to improve readability at a slight cost in performance.

Anyhow, I hope you take this in the spirit of mutual understanding that it is offered in. Two equally smart people can disagree about what is difficult and what is easy in a programming language, or indeed, on a whole host of other issues.



RPL (48/49/50 series):
1 2499 FOR I
TICKS SWAP - B->R 8192 /

Certain things about the above caught my eye, and I decided to
"improve" on it.
  • In RPL, the square root command has the symbol for its name; SQRT
    would be compiled as a global name, not as the square root
  • A FOR...NEXT loop is used, but its index variable is never used,
    so it would be better to use a START...NEXT loop.
  • The stack manipulation for the initial system time is handled a
    bit clumsily, using two moves where only one move is needed.
  • The result is very likely to differ depending on whether the
    angular mode is RAD, DEG, or GRAD, so this should be forced.

    When I force a mode, I usually prefer to restore the original

  • For the 49 series, operations with "real numbers" are generally
    faster than operations with "exact integers", so let's use real
    numbers only.

    For an integer value -9 through 9, the compilation of either a
    real number or an exact integer is to the address of a ROM object,
    so 2.5 bytes. Otherwise, real number objects are 10.5 bytes, and
    exact integer objects are 5.5 bytes plus 0.5 byte per digit.

  • Binary integers are truncated to the current wordsize when you do
    a mathematical operation on them, so a sufficiently large wordsize
    should be forced.
  • Substituting DUP * for SQ saves a tiny bit of execution time,
    although it uses 5 bytes instead of 2.5 bytes. In this case of a
    loop that repeats 2499 times, I'd prefer to sacrifice the 2.5
    bytes and save a little execution time.
  • A tiny bit of execution time can be saved by disabling last
  • We want to see the result in full precision, so let's force STD
    display mode and leave it in STD even after the program ends.
  • Regarding the timing, first off, the resolution on an RPL model is
    1 "tick" (1/8192, or about 0.000122, second).

    The TICKS command itself takes some time, so the apparent
    execution time of operations between two TICKS commands is an
    overestimation by the time that is takes to perform one TICKS
    operation. This varies among the models, and in any case, timings
    vary among units of the same model and even among repetitions of
    the same program, and I choose to neglect this minor inaccuracy.

    If you want to correct the inaccuracy, then run the program

    \<< TICKS TICKS SWAP - B\->R \>>

    a few times, average the result, and edit my program to subtract
    this average from the result of the B\->R command.

    Depending on free memory, a "garbage collection" may be needed, so
    for timings, a garbage collection is usually forced first. Of
    course, this doesn't guarantee that garbage collection won't be
    needed anyway, but it often makes the timings more repeatable.

    To free up more memory, last stack (UNDO) and last command lines
    saves can be disabled, but remember to restore them to your
    default modes when finished. These operations of
    disabling/enabling these two modes are not programmable.

  • Some other modes, particularly those which affect the CAS on the
    49 series, might have an effect.
The following program can be copied and pasted to a file to be
downloaded to any 48 or 49 series, but in case you prefer to key
it in, "\<<" and "\>>" represent the UserRPL program delimiters,
"\v/" represents the symbol for the square root command, and "\->"
represents the right arrow character. Don't bother keying in the
trailing "decimal points", but for the 49 series, enter this
program in "approximate" mode. Anything starting with an "@"
character through the next "@" character or the end of the line,
whichever comes first, is a comment; don't bother keying in any
%%HP: T(3)F(.);
@ "Savage benchmark" for 48 and 49 series.
@ 48 series checksum: # ECAh
@ 48 series size: 159
@ 49 series checksum: # B0C9h
@ 49 series size: 159.
\<< @
STD @ Force standard display mode.
RCLF @ Get original flags.
-55. SF @ Force last arguments disabled.
64. STWS @ Force wordsize.
RAD @ Force radians mode.
MEM DROP @ Force a GC.
TICKS @ Initial system time.
1. @ Initial value.
1. 2499. @ Loop start/stop values.
DUP * @ Square.
\v/ @ Square root command.
LN @
1. + @
TICKS @ Ending system time.
ROT @ Move initial time to level 1.
- @ Elapsed time.
B\->R @ Convert binary to real.
"Ticks" @
\->TAG @
8192. / @ Convert ticks to seconds.
3. RND @ Round to 3 decimal places.
"Seconds" @
\->TAG @
4. ROLL STOF @ Restore original flags.
\>> @
The 28 series doesn't have a built-in TICKS commands, any tagged
object capability, its RND command works differently, and the
system flags differ from the 48/49 series, so the above program
won't work on them.

Depending on the ROM version, one of the following can be used as
a substitute for the TICKS command:

The 28C must be in HEX binary display mode for these SYSEVAL
addresses, and that's a good idea for the 28S as well.
Double-check that the address is correct before executing SYSEVAL;
a wrong address may very well clear the calculator's memory.

Model 28C ROM version 1BB: #123E SYSEVAL
Model 28C ROM version 1CC: #1266 SYSEVAL
Model 28S ROM version 2BB: #11CAh SYSEVAL
As far as I know, these were the only ROM versions ever released
for the 28 series.

To find the ROM version of a 28C, with the calculator's binary
display mode HEX, use #A SYSEVAL, or for a 28S, #Ah SYSEVAL also

I'll use a character string to "tag" the timing values. The ":"
character isn't easily keyed in on a 28 series (unless you already
have that string stored), so I'll use "=" instead of ": ".

Instead of 3 RND, I'll use 3 FIX RND.

Last arguments disabling is forced by 31 CF.

Of course you can't transfer anything to a 28 series, but I choose
to use the same character translations as for the 48/49 series,
and what I wrote about comments also applies to the 28 series.

@ "Savage benchmark" for 28 series.
@ A 28C must be in HEX mode when this program is entered to ensure
@ that the correct address is supplied to SYSEVAL!
\<< @
RCLF @ Get original flags.
31 CF @ Force last arguments disabled.
64 STWS @ Force wordsize.
RAD @ Force radians mode.
MEM DROP @ Force a GC.

@ Uncomment the binary integer in one of the following 3 lines.
@ #123E @ @ For 28C ROM version 1BB.
@ #1266 @ @ For 28C ROM version 1CC.
@ #11CAh @ @ For 28S ROM version 2BB.

SYSEVAL @ Initial system time.
1 @ Initial value.
1 2499 @ Loop start/stop values.
DUP * @ Square.
\v/ @ Square root command.
LN @
1 + @

@ Uncomment the binary integer in one of the following 3 lines.
@ #123E @ @ For 28C ROM version 1BB.
@ #1266 @ @ For 28C ROM version 1CC.
@ #11CAh @ @ For 28S ROM version 2BB.

SYSEVAL @ Ending system time.
ROT @ Move initial time to level 1.
- @ Elapsed time.
B\->R @ Convert binary to real.
\->STR @ Convert real to character string.
"Ticks=" @
SWAP + @
8192 / @ Convert ticks to seconds.
3 FIX RND @ Round to 3 decimal places.
\->STR @ Convert real to character string.
"Seconds=" @
SWAP + @
4 ROLL STOF @ Restore original flags.
\>> @

All of the RPL models always return the value 2499.99948647 for
the above programs.

My timings, with 10 trials for each model, and with last stack and
last command lines disabled:

28C ROM version 1BB:
3262515 ticks, about 398.3 seconds
3262691 ticks, about 398.3 seconds
3262709 ticks, about 398.3 seconds
3262844 ticks, about 398.3 seconds
3263670 ticks, about 398.4 seconds
3263995 ticks, about 398.4 seconds
3263320 ticks, about 398.4 seconds
3263287 ticks, about 398.4 seconds
3263403 ticks, about 398.4 seconds
3263472 ticks, about 398.4 seconds
Average: 3263190.6 ticks, about 398.3 seconds
Range: 957 ticks, about 0.1168 second

28S ROM version 2BB:
2059531 ticks, about 251.4 seconds
2059943 ticks, about 251.5 seconds
2059854 ticks, about 251.4 seconds
2059888 ticks, about 251.5 seconds
2060079 ticks, about 251.5 seconds
2059892 ticks, about 251.5 seconds
2059946 ticks, about 251.5 seconds
2059652 ticks, about 251.4 seconds
2059838 ticks, about 251.4 seconds
2059848 ticks, about 251.4 seconds
Average: 2059847.1 ticks, about 251.4 seconds
Range: 548 ticks, about 0.06689 second

48SX ROM version E:
1585355 ticks, about 193.5 seconds
1585471 ticks, about 193.5 seconds
1585443 ticks, about 193.5 seconds
1585356 ticks, about 193.5 seconds
1585231 ticks, about 193.5 seconds
1585243 ticks, about 193.5 seconds
1585301 ticks, about 193.5 seconds
1585304 ticks, about 193.5 seconds
1585069 ticks, about 193.5 seconds
1585327 ticks, about 193.5 seconds
Average: 1585310 ticks, about 193.5 seconds
Range: 402 ticks, about 0.04907 second

48GX ROM version R:
968311 ticks, about 118.2 seconds
969964 ticks, about 118.4 seconds
970312 ticks, about 118.4 seconds
970479 ticks, about 118.5 seconds
970334 ticks, about 118.4 seconds
970284 ticks, about 118.4 seconds
969569 ticks, about 118.4 seconds
969730 ticks, about 118.4 seconds
968488 ticks, about 118.2 seconds
967720 ticks, about 118.1 seconds
Average: 969519.1 ticks, about 118.3 seconds
Range: 2759 ticks, about 0.3368 second

49G ROM Version G Revision 2.10-7:
915388 ticks, about 111.7 seconds
915136 ticks, about 111.7 seconds
915163 ticks, about 111.7 seconds
915501 ticks, about 111.8 seconds
915477 ticks, about 111.8 seconds
915516 ticks, about 111.8 seconds
915231 ticks, about 111.7 seconds
915535 ticks, about 111.8 seconds
915502 ticks, about 111.8 seconds
915490 ticks, about 111.8 seconds
Average: 915393.9 ticks, about 111.7 seconds
Range: 399 ticks, about 0.04871 second

49g+ ROM Version G Revision 2.10-7:
523531 ticks, about 63.91 seconds
523570 ticks, about 63.91 seconds
523624 ticks, about 63.92 seconds
523580 ticks, about 63.91 seconds
523575 ticks, about 63.91 seconds
523546 ticks, about 63.91 seconds
523545 ticks, about 63.91 seconds
523564 ticks, about 63.91 seconds
523539 ticks, about 63.91 seconds
523511 ticks, about 63.91 seconds
Average: 523558.5 ticks, about 63.91 seconds
Range: 113 ticks, about 0.01379 second

50g ROM Version G Revision 2.10-7:
526730 ticks, about 64.30 seconds
526688 ticks, about 64.30 seconds
526721 ticks, about 64.30 seconds
526714 ticks, about 64.30 seconds
526572 ticks, about 64.28 seconds
526757 ticks, about 64.30 seconds
526696 ticks, about 64.29 seconds
526681 ticks, about 64.29 seconds
526806 ticks, about 64.31 seconds
526698 ticks, about 64.29 seconds
Average: 526706.3 ticks, about 64.30 seconds
Range: 234 ticks, about 0.02856 second



Certain things about the above caught my eye, and I decided to
"improve" on it.

Yes, they could all be improved. Completeness and thoroughness should not be overlook.

Do the larger machines like the HP97 program more like a computer or is it sort of the same?

The 97 (and all the classics) are keystroke programmable. Essentially, if you can run the calculator well enough manually to solve your problem, you can do keystroke programming. There is no language ar syntax to worry about. To record a program, you just use the same keystrokes you would use to solve the problem manually, and the calculator just records them into program memory.

Augmenting this simple programming logic was conditional branching, which allowed the calculator to make comparisons and jump to different program steps based on the results of those comparisons. The classics had eight conditional branch tests: greater than, less than, equal to, not equal to, which could be used to compare the x register to the y register, or the x register to zero. This of course increased the programming power dramatically, allowing iterative loops to be implemented.
Since you can take right off writing programs, keystroke programming quite a lot of fun, and you can write some pretty capable subroutines. This forum is frequented by some wizards in keystroke programming, so I'm sure I'm not alone in my affinity for it.

Best Regards, Hal


A. Lots of money

B. Lots of Luck

C. Lots of Patience

D. Lots of help from this folks in this forum

E. Understanding spouse

F. All of the above


dona nobis pacem


Hi Ren.

E. Understanding spouse

Yes, you got the real point o' mine... :-)

Best regards.



Of course you're not alone, Giancarlo...



I recommend the 9825 with the hard-to-find optional belt clip.



"I recommend the 9825 with the hard-to-find optional belt clip."

You must have been one of those guys in college who wore his 20" slide rule on his belt, too!?!?


I used to have 9825B but without the "Hard to find belt clip" nor that I have a belt that can handle such a monster.

Possibly Related Threads...
Thread Author Replies Views Last Post
  And the collection grows... Les Koller 1 977 02-05-2014, 05:55 PM
Last Post: Xavier A. (Brazil)
  Calculator collection Miguel Toro 5 1,063 12-05-2013, 04:06 PM
Last Post: Chris Pem10
  Prime: Another Warm Start Helge Gabert 0 314 10-02-2013, 11:57 AM
Last Post: Helge Gabert
  Another non-HP RPN vintage calculator joins the collection Michael de Estrada 2 803 07-23-2013, 04:10 PM
Last Post: Walter B
  The 'Complete' Collection Keith Midson 8 1,565 05-12-2013, 09:52 PM
Last Post: Namir
  OT: My Slide Rule Collection Eddie W. Shore 18 2,573 04-25-2013, 11:47 PM
Last Post: Garth Wilson
  My Mostek collection is complete Michael de Estrada 15 2,355 04-10-2013, 10:01 PM
Last Post: Michael de Estrada
  Just added an HP 50G to the collection! Jedidiah Smith 12 2,010 03-16-2013, 12:43 PM
Last Post: Chris Smith
  A cheaper way to add to your collection Keith Midson 3 976 03-08-2013, 05:50 AM
Last Post: Keith Midson
  The biggest collection update yet Keith Midson 2 739 10-31-2012, 12:16 PM
Last Post: Matt Agajanian

Forum Jump: