Motivation

It all began with my project to develop an HP-32S Layout for PCalc.

At first, it was a purely surface-level clone of the primary functions, but as I delved deeper into secondary functions and submenus, I found myself needing to compare the two designs on a detailed level. My notes on these differences grew to the point that they spawned this article.

I continue to use a late 1980s hardware design as my primary point of comparison since it provides a nice balance point in their design evolution. Function-wise, it does nearly all of what the three primary models in the more primitive Voyager series can do, combined, yet it is not complicated to the point that my intended project of approximating its scope of functions within PCalc is hopeless. As evidence for this last, note the brevity of the list of HP-32SII features in my layout.

On the chance that the author of PCalc is reading this, he is welcome to take it as a list of potential future features, but do note that there is no priority given to any of these. Given the power to dictate his development schedule, I would of course have ideas for which ones to pursue first, but I do not actually need any of this. The program has already justified what I spent on it for licensing and upgrades, and so I find myself without any power in the matter. If this compilation changes anything about the future path of PCalc, it will be pure bonus.

One may ask why I bothered to make this comparison at all, then. Initially, it was to explain assorted infidelities in my HP-32S Lite layout project, as a matter of documentation on what a user can expect from it. Later, I developed an academic interest in comparative tech archaeology, its interest inherent to a certain class of mind. 🤓

Improvements

PCalc improves on HP’s obsolete hardware design in several areas:

• A vast set of built-in constants on the 42 button¹

• A set of conversions on the A>B button that positively spanks HP’s paltry offering²

• Extensive customization via the ⚙️ menu, without which my 32S Lite project would have gotten nowhere

• By default³ PCalc boasts a 128-level stack like HP’s graphing calculators, which is why it offers a stack button: to show all those numbers, which you could not otherwise remember. This feature also replicates the VIEW function of the 32S.

• PCalc is more accurate than an HP-32S owing to its use of modern 64-bit IEEE-754 calculations and not truncating each intermediate result to 12 BCD digits. I used the calculator forensics algorithm to determine this, but rather than count zeroes or nines after the decimal point, I followed up by computing the log ratio⁴ and then dropping the mantissa. The resulting exponent is all we need for a useful ballpark comparison measure:

  • HP-32S: ~10^-7 (ditto HP-32SII since it uses the same processor)
  • PCalc, Apple A15: ~10^-11 (ditto M4)
  • PCalc, Intel i9: ~10^-13

  What this says is that PCalc is at least four orders of magnitude more accurate than the 1980s era hardware design on this test. Not bad!

  Yet, the SwissMicros DM32 trounces them all with its 128-bit floating point math, giving a log accuracy figure on the order of…

  10^-30 !!!

  Be careful, though. The DM32 display can fool you as a result of the designer’s choice to mimic the HP-32S in displaying 12 digits. Since the first inaccuracy is far beyond that point, it correctly rounds to a perfect “9.” You have to press SHOW to see that it does eventually lose accuracy. Thus the value of the log ratio test against an actual perfect score: even down at this extreme, it gives a useful nonzero result.

Missing Features

Alas, it doesn’t go all PCalc’s way. There are quite a lot of missing features relative to ye olde HP-32S:

Programmability

Primitive as the 32S programming features were compared to what you could do on a general-purpose computer of the same era — much less a modern machine — PCalc is not Turing-complete, whereas a 32S is.

That said, there is a surprisingly short list of things that PCalc would need to add to lift this limitation:

• numeric tests⁵
• labels on the “tape,” PCalc’s closest current equivalent to a program memory
• ”goto” function for jumping to those labels, either directly or conditioned on the result of a test
• “return” function for terminating replay of a command sequence

I am not certain whether adding indirect memory addressing⁶ is strictly necessary to achieve Turing completeness, but it would close the final gap with the HP-32S on this front.

I express the list in terms of PCalc’s “tape” feature because that is how HP did it. They call it “keyboard entry programming,” and it turns a passive record of past work into an intentional act. If we set that historical consideration aside, a more PCalc-native way of doing the same thing would be by extending the User Functions feature. To achieve this end, the same few features need to be added regardless.

Complex Numbers

Whereas a 32S implements complex numbers throughout the system, in PCalc they’re an afterthought. The HP-32S Owner’s Manual devotes the seven pages of Chapter 9 to complex numbers, plus scattered references elsewhere in the book, but the PCalc manual devotes a single sentence to the topic, dominated by a link to the Wikipedia article on complex numbers “…for people who need to work with this kind of math.”

Sigh.

Statistics

PCalc lacks all items in the HP-32S Owner’s Manual Function Index containing Σ and σ symbols. It has a few scalar primitives in this vein, but without foundational building blocks like data lists, it cannot even offer basics like summation.

Variables

The 32S uses the overloaded 26 alphabetic keys for named variables with STO/RCL, but the PCalc implementation of multiple memories uses the single-digit system of HP’s Voyager series, giving ten “named” memories. There is no equivalent to the manual variable management of the HP-15S, and you cannot use the OS keyboard to get alphabetic labels. When you say STO 1 in PCalc, it is literally storing it in memory #1, but on a 32S, it would put it in location “W,” the overloaded meaning of the 1 key in that context.

The 27th variable in the HP-32S is called i, whose special power is lost here due to lack of a memory reference feature. There’s a conflict to be aware of here: STO . on a 32S stores x in register i, but on PCalc it sets all memory locations to that value. I believe this to be stock behavior of the PCalc . key which cannot be changed by the user.

There are another six statistics variables in these calculators which also have no equivalent in PCalc because it lacks statistics features.

Storage Arithmetic

The closest PCalc has to this HP feature works in the opposite direction and is limited to a single memory location, “M0.”

On a 32S, you can say STO + A to add the contents of the x register to variable ”A,” but when you press STO in PCalc, the operator keys all gray out, giving the false impression that it has nothing like storage arithmetic. What it does provide is on the Functions → Memory menu in the macOS version. Take the Add Memory function, which adds the contents of the zeroth memory to the x register, a function commonly labeled M+ on other calculators.

PCalc has the other three basic operations plus a power-raising one, which we might label M-, M×, M÷, and Mˣ.

Matrices

These are entirely missing in PCalc.

Built-in Function List Comparison

Another way of approaching these same conclusions is to compare the lists of “functions” each calculator boasts, emblazoned once upon a time on flashy retail boxes to justify price differences. Because the union set of all functions in this comparison comes to over 200, I choose to take an aggregate approach here rather than make you wade through a long data table. I did that work so you don’t have to; you’re welcome!

These results are therefore not detailed, but they are a useful distillation of the facts.

HP vs PCalc, Fight!

I found it easiest to start with the Function Index in Appendix D of the DM32 User’s Manual, where they have already totaled up the count for us: 171 distinct functions. This list ranges from trivial features like + to deeply subtle and complicated ones like ∫ and SOLVE.

The 32SII lacks but one of these. While SwissMicros made many enhancements in the DM32 relative to its predecessor, the sole proprietary new function they added is related to their multiple state management feature set: XEQ State:label.

The 32S repertoire is another story. I took the “Function Index” starting in its Owner’s Manual on p.286, then cross-referenced it against the DM32 list and counted 35 missing features, whose nature you may guess by reading the high-level comparative reviews you may find elsewhere online:

• fraction input/display
• improved equation editor
• expanded statistics facilities
• several more built-in unit conversions

One bit of noteworthy minutiae is that the 32S lacks the four “or equal to” variants of the twelve conditional tests in the 32SII.

Doing the same job with PCalc was more work because its manual lacks the single consolidated list of its every function, as HP and SwissMicros provide in their manuals. I ended up doing it the other way around, starting from the DM32 function list and treating it as an index of possibilities. For each one, I went on a hunting expedition, hoping to locate a correspondence in PCalc proper or its manual.

The number I eventually came up with is 98 functions in common with the DM32 without resorting to user functions.⁷ That leaves 73 missing, mainly in the areas already covered in prior sections.

One standout curiosity I came across is that the DM32 manual lists the parenthesis keys as “functions,” but while PCalc does have them for algebraic entry, I counted them as lacking here because in this context, it refers to argument grouping in the equation editor, a facility PCalc lacks.

PCalc vs HP, Finishing Move!

I then went the other way, skimming through all those PCalc menus looking for functions that I didn’t account for in the first pass above, implicitly meaning they aren’t present in any member of the “32” line. Most fall into one of the categories listed at the top of this article, but there are notable exceptions:

• drop⁸
• cube and cube root
• modulo and remainder
• decrement and increment
• round to floor and ceiling⁹
• percent of total and tax rate calculations a la HP-12C
• reciprocal trig functions: cotangent, cosecant, secant, and their inverses
• hypotenuse, plus “leg” for computing one of the two orthogonal sides given the length of the other two
• computer arithmetic a la HP-16C: bitwise logic operations, bit-shifting, endinanness swapping… It isn’t enough to allow a complete clone, mainly missing a word size setting and the option of selecting the way negative numbers are represented, but it does have interesting oddities like 3-bit shifts, as you might want when working with a 12-bit PDP-8, where several functions group bits into threes, not fours, resulting in octal being more useful than hexadecimal.

The links take you to HP-32S or 32SII implementations of these “missing” functions. The rest are all implementable as user programs, but you will have to seek these out on your own.

There is one other item we can put in PCalc’s column: the algebraic entry option. None of the “32” series has it, so we have to at least mention this heresy, even if this is an RPN site. 😛

License

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

---

1. ^{^} As far as I have been able to find, even the DM32 has but two built-in nontrivial constants: π and e, and the latter is hidden away in the internals.
2. ^{^} I count a mere six conversions in the HP-32S, twelve in the 32SII/DM32, and approximately one bazillon in PCalc, round numbers. 😜
3. ^{^} There is 4-level stack limit option that allows it to better mimic the behavior of classic designs like the HP-32S, without which functions like “roll” don’t work as expected.
4. ^{^} log_e(ideal / actual); perfection is ln(n/n) = 0
5. ^{^} The HP Voyager series got by with just two — x>0 and x≤y — while the 32S expanded that to a comfortable eight, and the 32SII gave us a positively sybaritic fourteen options!
6. ^{^} What HP calls the i register and the corresponding (i) function.
7. ^{^} If we allowed that, we’d have to allow user programs on the HP side, too, which would give the whole game away thanks to the good doctors Church & Turing. PCalc’s finite function list would end up being divided by infinity on the HP side owing to its programmability. While that is a true interpretation, it isn’t particularly useful in this context, where the comparison is being made to the platform that lacks programmability.
8. ^{^} The closest I can come to cloning that on a 32S is CLEAR x +: everything moves down one, and the T register is duplicated down into Z if you have PCalc’s four-register stack limit enabled. It may be viewed as the inverse of pressing Enter while the calculator is in stack-lift mode.
9. ^{^} HP’s PARTS {IP} is not quite the same thing if negative values are a possibility.