Enter RPN

R47: The HP-12c Platinum Overlap
Login

R47: The HP-12c Platinum Overlap

Help

Scope

HP-12c Platinum (parens, 2005)

Yes, I wrote “Platinum.”

Those who previously read my article on the R47 as an HP-16C Superset may have expected this follow-on article to compare the R47 to the original HP-12C, sometimes miscalled the “Gold” version as if that was a later blinged-up variant. What I realized on beginning is that the parallel with this doubly-improved 2005 version — the one I call “parens” — makes for a closer horse race: all but one of the changes HP made to it are also present in the R47 in equal or better measure.

Let’s start with…

What Remains the Same

Backspace!

In 1981 when the HP-11C came out, backspace was hot stuff. You couldn’t count on having it even on all personal computers of the time; one had to step up to a minicomputer before it became de rigueur. I doubt the 11C was the first handheld calculator to offer this feature, but I do recall being pleasantly surprised to find it on the Casio scientific I received in the late 1980s, to the point that I refused to use anything else for years after, because even by then it wasn’t ubiquitous.

The thing is, the original HP-12C was released at the same time as the 11C, and it lacked this super-handy feature! On the 12C, in place of the ⬅︎ button off the upper left corner of the ENTER key was CL𝑥, which had been the 🟦-shifted function of the same key on the 11C.

Why, HP, why?

The Platinum at last returns the backspace operation as 🟦 -, which makes a twisted type of sense — we are “minusing” a digit from the entry — but it would have been better to move the two tests to the operator keys like on the HP-11C and make ⬅︎/CL𝑥 work as on the HP-11/15/16C.

This, incidentally, is one of the reasons I believe the HP-10C had such a short life, 1982-1984: it mimicked this odd design decision.1 At least it had the excuse of having a single shift key, giving a choice of CL𝑥 or ⬅︎ here.

The R47 solves all this. The ⬅︎ key is up where HP put it on all the Pioneeers, at the right end of the row containing ENTER or INPUT, depending on the model. This key’s 🟦-shifted function is the CLR menu, which may be thought of as extending the bracketed set of 🟧 CLEAR functions on the HP 12c Platinum:

12c R47 equivalent
Σ CLΣ
PRGM DELETE DELPall
FIN CLTVM
REG CLREGS

While there is a direct equivalent to the Platinum’s 🟦 CL𝑥 on this same menu, the R47 also offers the option of a long-press on the backspace key to get the same function.

There are further differences, but to avoid becoming distracted we will put off discussing those until later.

Undo!

The single-level undo scheme in the R47 and the Platinum is limiting by modern standards, yet it’s useful to the point of being hard to live without once used to having it.

The primordial LAST𝑥 feature2 serves but a small part of the same purpose; undo performs a complete restoration of the calculator’s immediate state prior to the last operation, including stack contents. I find this distinction tremendously useful while iterating my way toward a solution. LAST𝑥 is more an optimization to be used once the algorithm is settling down, ideally reduced to a program, where it saves the need for a temporary register when chain calculations won’t serve in reusing a prior result.

The R47 gives various ways to split the difference:

These may then be RCL’d later, avoiding the need for an undo.

And when it’s gone all pear-shaped, 🟦 LOADST, presuming you had the foresight to keep a checkpoint with SAVEST!

Greater Programming Memory

Relative to the HP-12C, the Platinum raises the primary programming limit from 99 steps to 400.

The limit on the number of programs you can have in an R47 and the maximum size of each has more to do with host system memory than hard-coded constants. The limits on a DM42 converted to a C47 differ from the DM42n-based R47, which in turn differ from those of the simulator running on a big ol’ PC. Regardless, you are unlikely to run out of program memory with the smallest of these, all but eliminating any incentive we might have to dig deeper and quantify the precise limits.

Percent of Total

One of the stranger choices HP made back in the day was to relegate the %T function to their financial calculators. I ask you, what is “financial” about this basic operation? I recently applied it to the supply of capacitors available from a major warehouser, and it was from the perspective of a mere end user, not that of the company’s CFO. Percentages are a highly scientific concept; one of my firm personal beliefs is that it is a sign of fuzzy thinking when someone gives you a comparison between two numbers without giving any type of percentage. (Doubly so when they don’t even give you the baseline, as in the too-common games people play with bogus Y axes in charts.)

It is for this reason that I wrote a series of programs for older HP calculators to supply this missing operation. With the R47, we don’t need any of that: it’s on 🟦 FIN %T. It remains slightly irritating to find it grouped with the “financial” features, but I do understand the historical context that forced the choice.

𝑥²

It seems strange to point it out, but HP did not grant us the 𝑥² operation in their financial line until the 17B, released in January 1988. This echoed down through the other Pioneers in that line — the 14B and the 10B — over the following few years, but this feature did not come to the 12 series until the original Platinum was released in 2003.

I suppose the reason is that this operation is technically optional in RPN, being trivially implemented as ENTER ×. Certainly beyond that there is little reason not to go straight to yˣ. In particular, I’ve always viewed the 𝑥³ function found on some other calculators as a sign of design filler, needed when the creators could not think up something better to put there. (Ditto the cube root.)

Yet, 𝑥² is surprisingly valuable on the Platinum when it comes to saving steps within its memory limits, where the other available alternative also costs two instructions: 2 yˣ. While that same savings is scarcely tempting on an R47 from a memory management standpoint, a first-class 𝑥² function reduces SLOC, an inherently valuable design goal.

It is for this reason I do not begrudge it the space it takes on the R47 keyboard despite its ~10:1 oversubscription ratio.3

What Changes

Trivially, a description of the differences between the HP 12c Platinum and the R47 amounts to nearly the latter’s entire documentation set. What we will do instead here is treat the R47 as a financial calculator in the 12c mold and see what essential differences make themselves evident within that purposely narrowed scope.

Spoiler: This section explains why I titled this article thus even though I initially intended to draw similar parallels with the R47 as I did for the HP-16C. I cannot in fairness class the R47 as a Platinum “superset.”

Algebraic Entry Option

The HP 12c Platinum powers up into RPN mode OOTB, and beginning with the Ver 02 redesign released in 2005, it includes the parenthesis keys needed along with that.

The R47 has parentheses in its 🟧 EQN NEW menu for equation entry, which can in turn be seen as a type of algebraic entry, but if this suffices to make it an “algebraic calculator,“ then so is an HP-32SII.

Time Value of Money

I will not attempt to replace C47 App Note 12 here, but there is more to be said when it comes to a comparison between it and the Platinum. The primary thing to realize is that this feature set is incomplete relative even to an original HP-12C.

As evidence, consider the hard-coded strike-thru modifier on the R47’s 🟦 FIN 🟦 TVM 🟦 CASHFL menu.4 Whereas the Platinum raised the number of cash flow values it can track in functions like NPV (net present value) from 20 to 81, we track zero cash flows with the built-in R47 financial features.

The same is true for:

I suppose we must be awaiting someone who cares to contribute these features.

Meantime, hang onto those HP-12Cs and Platinums. As we see, the R47 doesn’t wholly obsolete them.5

Form Factor

While I could have made the same argument within my HP-16C comparison, it is rare in using one of those that you find yourself standing up, with the calculator in both hands, ENTER equidistant between your thumbs, as the compact Voyager line is best used. These are calculators for active professionals, moving about and interacting with the real world, only briefly pausing to crunch numbers before moving on. This is one major reason the HP-16C was never replaced: it was always competing with a big monitor and keyboard. Even a VT100 outclasses a 16C from a sheer data-entry standpoint.

While the same could be said for many prototypical HP 12c Platinum users — a good many of whom will be tied to desks during the workday — there are enough other use cases to keep this line in continuous production since 1981. Take the real estate agent touring available properties within the price range of a prospective client. Why run back to the car for a laptop when the conversation turns to financing? Why burn precious battery life on a smartphone app when a certain amount must be reserved for…you know…making and taking calls?

And so we come to another reason why the R47 is unlikely to wipe out the worldwide Platinum market.

Besides, with a golden-ratio aspect where the short side is equal to π inches, how can you go wrong? 🤓

Logarithms

I was surprised on learning that the HP-12C offered the LN function at all, but what I wish to focus here is the lack of a base-10 log function, often called the “common” log and paired with it. I am aware of the details of application that make one a “financial” log and the other a “scientific“ log, but what concerns me here is that the R47 doesn’t make you choose. While we have seen in this section already that there are advantages to the Platinum, what I expect never to see on a future R47 eBay listing is the following reminder:

`log_10(n) = ln(n) / ln(10)`

I tell you true, I saw this hand-written hint masking-taped to an HP-12C between bezel and emblem, a certain sign that it might be time to consider switching to an R47! It grants us not only both major types of logarithm as top-level keys, we get more variants on its 🟦 EXP menu:

Date & Time Arithmetic

One of the more impressive features of the HP-12C — extending even into the early reign of the Platinum — is its facility with date and time arithmetic. This was absolutely essential on a financial calculator offering features like mortgage payoff calculations, bond yields, and so forth. Scientific calculators tended to lack this type of thing entirely, and when it did exist, it often did come in second place to a 12C. This is true even between it and the otherwise high-end HP-15C, which lacked the calendar features of the 12C.

The R47 flips that on its head with its first-class date and time data types. Follow those links for the “why.”

If this was the big final reason you were hanging onto your Platinum, it’s time to let go because the R47 smokes it on this test.

…mostly, that is! The R47 lacks the Platinum’s 🟦 12× and 12÷ functions for converting between decimal years and months.6

Programming

We spoke of 🟧 CLEAR PRGM above, but clearing programs isn’t an all-or-nothing affair on the R47. A more common path is:

🟦 CLR 🟦 DELETE 🟦 DELITM PROGS

That then lets you delete a single program by alpha LBL, reflecting the fact that the R47 programming model is a vast improvement over the HP-42S programming mode, which was in turn a significant improvement over the HP-41 series, which for the longest time was the pinnacle of RPN programming. Mathematically:

R47 ≫ HP-42S > HP-41CX ≫ HP-11/15C > HP-12C

While HP did increase the limit on program steps from the original HP-12C’s 99 to 400 in the Platinum — changing GTO from taking a two-digit argument to three as a direct result — it is as nothing compared to what may be achieved on an R47. One could impose a matching 400-step limit on the R47 and still run circles around a Platinum, programming-wise. While R47 does not offer anything we might term structured programming, it’s a huge improvement:

That last is tricky. Above, we said we weren’t going to be distracted by this type of thing, but it must be said that the maximum compression ratio from converting a Platinum program to the R47 will necessarily be N:1 anywhere the R47 provides a direct feature that would’ve required an N-step Platinum program, if it could be constructed within the available space at all. (Example.) If we limit ourselves to just the greatly-improved math engine, we still save steps by avoiding the need for manual workarounds when we would run up against one of the Platinum’s many limitations.

I hesitate to estimate how much shorter an average HP 12c Platinum program can get when translated to maximally-efficient R47 code, but I wouldn’t be surprised to see a broad distribution with a median around 2:1.

One may ask, “Why bother, given the R47’s greater memory?” The reason is that shorter programs are less likely to contain bugs:

  1. The number of bugs in software is directly correlated to source lines of code.7
  2. Calling into the R47’s built-in function library means you’re calling pre-debugged code over hand-coding it.

Anytime you find yourself with an application where you might need to create a program, the R47 is the clear winner except when one of the above differences trumps it.

(You may now wish to return to my R47 article index.)

License

This work is © 2025 by Warren Young and is licensed under CC BY-NC-SA 4.0

  1. ^ Indeed, the 10C looks more like a cost-reduced 12C than an 11C, once you dig past the scientific vs financial surface details.
  2. ^ LAST𝑥 remains in the Platinum, but to make room for the equals operation that takes over as that key’s primary function in ALG mode, it had to be moved from 🟦 ENTER to 🟦 +.
  3. ^ Take the number of available keys on the R47 — that is, leave out the function keys, the shifts, and ones which absolutely must be present for it to be a calculator — and then take into account the 2-shift system roughly tripling that prior result. Divide that into the number of operations defined within the R47 firmware, and we conclude that every top-level key and every shifted variant of same had ten more competing with it for the space while the R47 was being designed and developed.
  4. ^ If you dig down into the code, you find a call to the itemToBeCoded no-op function here.
  5. ^ When it comes to cost per feature within the Platinum’s scope, the R47 never will replace mass-market business/financial calculator lines. On a pure bang-per-buck basis, I expect the R47 gives greater value, but for those with needs fully covered by the likes of the 12C and its successors, it will be difficult to argue in favor of the R47. Not impossible, mind. Even ignoring all the functionality unlikely to benefit such a user, the R47 offers ancillary features like a much-improved screen, the ability to see all 4 levels of the stack, a far better backup story, and so forth. And who knows, if the national debt goes on increasing as it has, our financial elite might find they need more than 10-digit mantissas plus a 2-digit exponent!
  6. ^ These features also adjust the interest rate in the i register, which is undoubtedly handy when using this machine in the intended manner. Problem is, this type of hidden interdependence keeps one from using the financial registers as general-purpose. Contrast the “𝐈” register in the 11/15C which has an entirely different intended purpose, but which can be pressed into service as another general-purpose register when it is not needed for indirection.
  7. ^ Halving the SLOC tends to halve the bug count for each pairing of programmer and language.