(2025-05-26) Herding the cattle better with advanced HP 12C techniques
----------------------------------------------------------------------
This surely is not my last 12C-related post here, but probably my final post
about porting Bulls and Cows onto this surprisingly capable pocket machine. 
As you might have told, the previous version was quite slow, especially on 
the initial target number generation phase, and required rather complicated 
setup. Within the previous week, I discovered a bunch of "hidden" 12C 
functionality that not only allowed me to make that phase a bit faster, but 
also to simplify the setup and to compress the entire program code. Let's 
dig into that a bit, shall we?

If you remember, I had written in my previous posts that the 12C doesn't have
indirect memory addressing and indirect jumps. The latter, as far as I know, 
still holds true (unfortunately), but the former turned out to be pretty 
much false. The 12C, in fact, DOES have indirect memory addressing. What's 
more, it even has some special-purpose registers that can only be accessed 
indirectly! But let's begin from the very beginning.

Among other financial-specific functions, two of them pose a particular
interest: NPV (net present value) and IRR (internal rate of return). Not 
digging into much specifics, I'll only tell you that the NPV function 
computes the value of a polynomial (with the argument transformed in a 
simple way) and the IRR function finds _roots_ of that polynomial. Yes, the 
12C has a built-in polynomial solver, although it's not documented as such. 
I have added all the detailed info on how to make use of this in my "Tricks" 
section of the document ([1]), so feel free to read that section if you're 
interested in polynomials in general, but here, I'm gonna focus on how the 
_coefficients_ for those polynomials are input and stored, because that's 
what's important for understanding the indirect addressing feature. 
Officially, the manual says that you start entering the coefficients (in the 
Horner order, from the free coefficient A0 to the highest degree coefficient 
An) with the "cash flow" keys: CFo for A0 and then subsequent presses of CFj 
for Aj. The manual also says you can recall and edit the coefficients by 
pressing RCL CFj. What's really happening behind the scenes is:

1. Whenever you press CFo, the number in the X register is stored into R0 and
the number 0 is stored into Rn.
2. Whenever you press CFj, the contents of Rn is autoincremented and the
number in the X register is stored into whatever register Rn is pointing to 
after this increment. If the register index is just 1 more than what's 
available, the machine writes the number into RFV.
3. Whenever you press RCL CFj, the number stored into whatever register Rn is
pointing to gets copied into the X register, and THEN Rn gets 
autodecremented. Again, if Rn was pointing to a register index just 1 more 
than what's available, the contents of RFV would be returned.

So yeah, that's your indirect register addressing for ya. Just put an index
one less than you need into Rn and you can write to the register under that 
index using the CFj command. Yes, this works for R0 too if you say 1 CHS STO 
n, for instance, putting -1 into Rn: it will pre-increment and write to R0 
when you press CFj. When you need to indirectly read from a register, just 
put its unaltered index into Rn and issue RCL CFj, and you're good to go. 
But wait, there's more! There's much more.

You see, the NPV/IRR functions also allow you to specify _repeating_ cash
flows with a separate Nj function. Essentially, that repeats the last 
polynomial coefficient CFj Nj times (up to 99), allowing you to also 
increase the degree of the polynomial without having to waste extra storage 
space. What's interesting for us is that the Nj registers to not overlap 
with the main register area. In fact, physically, they are stored in three 
separate 7-byte blocks of memory. Why so? Because every Nj register can only 
hold integers, and those integers can only be from 0 to 99 (yes, whoever 
tells you it's 1 to 99 is wrong, it's 0 to 99). So, how do we access those 
special registers? Same way but the operations don't alter the contents of 
Rn: you first set the index to Rn and then use Nj for writing and RCL Nj for 
reading. Now, how many Nj registers are available? Alas, despite this memory 
area is independent, the amount of available Nj registers is strictly equal 
to the amount of available coefficients, which is the amount of available 
main area registers plus one (because of the RFV register). This means that, 
for instance, in order to have 10 Nj registers available, you need r-09 to 
be displayed on the g MEM screen, which means 85 program steps at most. Oh, 
and one more thing: they all get initialized to 1, not 0. And there is some 
inconvenience when trying to reset them all to 1 because they survive the f 
FIN command, and f REG cannot be called programmatically.

But why would I ever need ten extra registers that can only hold integers
from 0 to 99? Well, for starters, this makes a perfect flag array for 
generating numbers with unique digits. Just like in... you know... Bulls and 
Cows. Having a set of flags for marking which digits already have been used 
means a much faster and cleaner algorithm. Now, only three "minor" 
challenges needed to be overcome for the ultimate Bulls and Cows version for 
the 12C to appear:

1) switching to a PRNG that wouldn't depend on Rn,
2) incorporating a mechanism to reset the Nj flags after the target number
has been generated,
3) squeezing all the code to the hard limit of 85 steps.

The first challenge was rather easy to tackle because, besides the shortcut
12x function that multiplies by 12 and automatically saves the result into 
Rn, we also have the 12/ function that divides by 12 and automatically saves 
the result into Ri. After some testing, I had come up with the formula S[n] 
= frac(exp(S[n-1] + 7) / 12) which takes the same 7 steps and achieves 
equally good statistical results. The second challenge, on the other hand, 
was tightly intertwined with the third one. Every time I came up with a nice 
flag clearing algorithm, I found that I fully ran out of steps. Finally, I 
decided that I would calculate the outer digit as a single digit (as opposed 
to the the entire integer part of whatever remained of the target) and use 
the digit as the index to reset the flag as well. Still several steps more 
than necessary though. And then it dawned on me: why not just use Rn as the 
outer digit intermediate storage, since I had to populate it anyway? And 
after that, everything finally clicked into place and, after using the 
CL.STAT trick to clear the registers R1 to R6 at once (and reallocating the 
constants 10 and 10000 to R7 and R8), the new Bulls and Cows version takes 
exactly 85 steps and has been published in the document under the 
UltimateMoo12 name. Because this, in my opinion, is the pinnacle of digital 
cattle herding on a purely financial calculator. But the real value is 
contained in all those techniques I have learned throughout this 
optimization process. I have been capturing them all in the document's 
"Tricks" section as well for everyone to see and try out. Because people 
deserve to know what's really possible even on the original 884 KHz model.

And you know what? I have a feeling that all that still is just a tip of the
iceberg.

--- Luxferre ---

[1]: gopher://hoi.st:70/0/docs/own/hp-12c-soft.txt