This is an idea that I have had for a loooong time that I finally got up the nerve to implement. In fact, this idea was one of the first candidates for my float library. It was daunting,but well worth it and easy to generalize to larger precisions

I want to display ##x## as a base-10 string. My starting goal is to get it into a format like ##x=10^{n}y##, where ##n## is an integer. I'm not going to be too picky about ##n##, so long as ##y## is smallish in magnitude. For example, if ##y\in[.1,10]##, then it is a lot easier to convert ##y## to a string and append an e##n## to that string. It would be like a pseudo scientific notation. From there, I can work on the formatting and making it look pretty.

So what I do first, is get an approximate value for ##n##. My floats are already in a format of ##x=2^{e}\cdot m##, so ##n\approx e\cdot log_{10}2##. Since ##e## is an 8-bit signed integer in this case, and we are only looking for an integer result, we can approximate this further by getting ##log_{10}2## to 8 bits of precision. Finally, ##n\approx \lfloor \frac{77e}{256}\rfloor##. In assembly, this translates to "Multiply by 77 and take the overflow."

Now that I have ##n##, I want to compute ##y## This is done as ##y=\frac{x}{10^{n}}##. Luckily, this sort of exponentiation is easy. For example, ##10^{13}=10^{1+4+8}=10^{1}\cdot 10^{4}\cdot 10^{8}##. In this case, ##0\le n\le 38##, so if we precompute a table for ##10^{1},10^{2},10^{4},10^{8},10^{16},10^{32}##, then we will only ever need at most 5 multiplications to compute ##10^{n}##. With this, we compute ##y##, which should be on ##y\in [.5,20]##. From there, we proceed to convert y to a string and perform any fancy formatting our hearts desire.


Applying this algorithm to the 80-bit floats will make it a lot faster to convert. It won't be as fast as converting a BCD float like TI's, but it will be more on the order of 40,000cc instead of 400,000cc

The Toom-Cook algorithm basically generalizes multiplying integers as multiplying polynomials.For example, if we want to multiply 47*81, we can think of it as multiplying (7+4x)*(1+8x) and evaluating at x=10 (since our numbers were in base 10). This seems like a lot of unnecessary complexity, and it is for such small numbers, but let's look at a few key ideas.

If you are given 3 points on a plane, you can construct a unique quadratic function that passes through each point. The key here is that it is unique meaning there are no other degree-2 polynomials that pass through each point-- there is only one and that one must exists. On the other hand given 4 points, there might be a parabola that passes through each point, but it is not a guarantee and is in fact unlikely. As well, given three points, there exist infinitely many cubic polynomials (or quartic or quintic, etc.) that pass through each point. In general, if you have n+1 points, you are guaranteed to be able to find a unique polynomial of degree n that is the only such polynomial that passes through each point.

Guarantees and uniqueness are cool and all, but actually constructing the polynomials from those points can be tricky (but still "quickly" doable in a computational sense)! Luckily for our case, the points won't be totally arbitrary. Let's look back at our Toom-Cook example of multiplying 47*81. The polynomial product is (7+4x)*(1+8x), which we know should be a quadratic equation. Then if we evaluate this product at three easy points, we should be able to reconstruct the result. Specifically, let's evaluate at x=-1, x=0, and x=1:
(7-4)*(1-8)=-21
7*1=7
(7+4)*(1+8)=99

The easiest way to reconstruct the polynomial by hand, in my opinion, is to use matrices to represent a system of equations. In this case, with a_i being the points we evaluated at -1,0, and 1:

[[  1   (-1)¹    (-1)²   a₀]
 [  1   0¹       0²      a₁]
 [  1   1¹       1²      a₂]]


   [[  1  -1   1   a₀]
=   [  1   0   0   a₁]
    [  1   1   1   a₂]]

And now we reduce this to reduced row-eschelon form.

   [[  0   1   0   (a₂-a₀)/2]
=>  [  1   0   0   a₁]
    [  1   0   1   (a₂+a₀)/2]]


   [[  0   1   0   (a₂-a₀)/2]
=>  [  1   0   0   a₁]
    [  0   0   1   (a₂+a₀)/2-a₁]]


Now that we know the resulting coefficients, let's construct our polynomial:
a₁+(a₂-a₀)x/2+((a₂+a₀)/2-a₁)x²
=7+60x+32x²
Let's evaluate this at x=10 and we have 3200+600+7 = 3807 which is indeed 47*81.

The nice thing about this is, since we've already solved the system of equations, we can reuse this and we don't need to compute it every time. We just compute the product at -1, 0, and , then plug it into our formula et voila. In fact, let's make a BASIC program that multiplies two ten-digit numbers and returns a 20-digit result. Input is passed through two 2-element lists, L1 and L2, and use those elements as 5-digit 'digits' to compute the product.
{1.-1
sum(L1Ans)sum(L2Ans->A
L1(1)L2(1->B
sum(L1)sum(L2->C
.5(C-A
{B,Ans,Ans+A-B->L1
0->C
L1e-5->L1    ;engineering E
For(K,1,3
C+L1(k->L1(K
e-5int(Ans->C
End
C->L1(4
e5fPart(L1->L1
The output is a 20-digit integer comprised of four 5-digit numbers. The first element is the lowest 5 digits, the fourth element is the upper 5 digits.