I am particularly proud of the fact that square roots average under 6600cc, about 13 times faster than TI's (and to about 5 digits more precision).

Later when I am home I'll come up with screen shots. I hope these are useful ! There is a lot more work to be done. Maybe even make eZ80 versions ! This has been kind of exhausting, honestly.
EDIT: Screenshot:
For 64-bit floats, results are only good to about 19 digits, though 20 digits are displayed. With that in mind, the biggest error is less than half a digit so I'm calling it rounding error, both of the inputs (constants are only stored to 64 bits precision) and during intermediate calculations.

EDIT: 14 Jan 2019
Here is a screenshot of some of the single-precision routines!

I have been focusing on the single-precision floats this past week or so. I rewrote or re-worked a lot of routines. I got rid of most of the tables by switching to a polynomial approximation for the 2^x routine (thanks to the Sollya program!) and using the B-G algorithm to compute lnSingle. It turned out to be faster this way, anyways.

I implemented sine, cosine, and tangent, the first two, again, using minimax polynomial approximation. I optimized the square-root routine (much faster but a few bytes bigger). I re-implemented the B-G algorithm using math optimizations I came up with a few months ago. I opted for two B-G implementations-- one for lnSingle which requires only 1 iteration for single precision, and one for the inverse trig and hyperbolic functions which needs 2 iterations. For anybody looking to save on size, you can just use the second B-G routine for natural logarithm. It will be a little slower, but it'll work just fine (maybe even give you an extra half-bit of precision ).

I included the Python program that I use for converting numbers to my single precision format. You can use it to convert a single float or a bunch of them. I also included a Python tool I made for computing more efficient coefficients in the B-G algorithm, but that'll only be useful to me and maybe a handful of other people. It's there on the off chance somebody stumbles across my project looking for a B-G implementation.

The single precision floats are largely complete in that I can't think of any other functions that I want to add. There is still work to be done on range reduction and verification, as well as bug fixes and more extensive testing.

Here is a current screenshot of some of the routines and their outputs:

Miscellaneous and Utility
randSingle rand -> z
single2str str(x) -> z Convert a single to a null-terminated string, with formatting
single2TI tifloat(x) -> z Converts a single to a TI-float. Useful for interacting with the TI-OS
ti2single single(tifloat x)->z Converts a TI-float to a single. Useful for interacting with the TI-OS
single2char Honestly, I forgot what it does, but I use it in some string routines. probably converts to a uint8
pushpop pushes the main registers to the stack and sets up a routine so that when your code exits, it restores registers. Replaces manually surrounding code with push...pop

I made the str->single routine better (it had been quickly thrown together and failed on many/most cases due to lost precision). Now it appears that digits get swapped in some cases! I have to look into this.

To Do:
Look into the string->single routine and figure out what is wrong
I still have to look into the bugs observed in the single-precision Mandelbrot set program
Look into the errors in xinv, xlog, and xlog10 (these might all be related, or maybe I accidentally a byte in the built-in constants).
Have to make xsin, xcos, xtan, xsinh, xcosh, xtanh, xtoTI (x-float to TI float), TItox (TI float to x-float), and strtox (string --> x-float).
For all of the trig routines, I still need to apply range-reduction

Once these are done, it's just finding and fixing bugs and optimizing, and the project is as complete as what I wanted to do. BCD floats were a cute idea, but I'm a bit more realistic now Maybe I'll be motivated to add in stuff like gamma / log-gamma ?

There are still bugs that I have to locate and fix, but this project is almost complete!
Every routine that I had planned to implement is now implemented
Cosine and sine now have range reduction. It isn't perfect, but it works for now.
The extended precision floats now have sin/cos/tan along with range reduction.
I had to add a routine for mod 1 in order to implement range reduction.
I now have all of the conversion routines done between strings, floats, and TI floats.

^~^

Combining the single- and extended-precision floats into one app (removing duplicated routines), the extended-precision routines total 7980 bytes, and single-precision routines total 4906 bytes, for a total of 12886 bytes.

EDIT: I had five bugs that needed fixing and I fixed them this morning! Four of them were solved by fixing two issues in the division routine, and the other was xtanh which I rewrote and now it works (I was pretty sure it was variable juggling issues).

Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.