I'm still learning how to work with GitHub/git, but you can help or access the code for this project here.

The library of "single precision" floats (they don't conform to IEEE standards ) needs a lot of work using my newer knowledge. However, it does have abs, add, sub, rsub, negate, arithmetic mean, square root, geometric mean, Borschardt-Gauss, compare, 1/x, division, multiplication, e^x, 2^x, 10^x, x^y, ln(x), log2(x), log10(x), log_y(x), atanh, acosh, asinh, atan, asin, acos, rand, float→TI float, float→str, str→float.

The extended precision floats (15-bit exponent, 64-bit mantissa) are not as compete yet, but I have implemented: add, sub, rsub, arithmetic mean, multiplication, division, square roots, geometric mean, Borschardt-Gauss, acos, asin, atan, acosh, asinh, atanh, ln(x), and float→str.

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!

Fantastic work as always Xeda!

Will you be incorporating this library into KnightOS?

As awesome as that would be, I don't think I'm up to that task. If somebody else wants to, I encourage it!

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:


The current list of single-precision routines:

Code:

Update:
For the extended-precision floats, I added:

Code:

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 ?

Updates!

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).

I'm posting to announce a new addition to the library: 24-bit floats! I basically wrote all of these in the last 48 hours and I'm pretty burned-out:
https://github.com/Zeda/z80float/tree/master/f24

These floats are a fantastic balance of speed and usefulness on the Z80, and I think all of the routines fit into about 2500 bytes, so they are compact, too. I think I handled 0/inf/NaN a lot better with these routines (in that I made sure each routine handled them)

I still need to write conversion routines, but that can wait for another time, maybe next year if someone else doesn't get to it first