Rather than using std:: exception types, the library should use new c8:: types. This will allow the exception types to be precisely specified.

It will sometimes be useful to get the size of a natural in digits.

Change the makefile design to support VPATH and the building of code in a different directory to the sources. This makes it much easier to build multiple versions of the software with different build options and run regression tests against each one.

Add a function to convert a c8::rational to a double, if it will fit. If it won't fit then throw an overflow exception.

This will inevitably lose precision, but that can't be helped.

Add support for a c8::rational class that supports rational numbers.

Add code coverage analysis so that we can check that there is 100% coverage at all times.

The original thought was that there might need to be specific enum classes for each numeric type, but this now seems unlikely and they can all be merged together. The change will simplify some of the code.

In the *_check tests we are not just measuring the time to invoke the operation under test, but we're also measuring some of the overheads of timing things. Need to add a "nop" test that will compute the overhead and subtract it out from the other tests.

Make it easy to test everything.

When multiplying, say, 2 digits by 2 digits, we can unroll a lot of operations and make things run much faster.

Add the bit shift operators. In some ways it's a little odd to have these, but it keeps things consistent.

Add a c8::scale10 class that handles power-of-10 scaled numbers

Support fast multiplies by powers of 2, converting these into left shift operations.

Add function to convert c8::natural to unsigned long long, if it will fit. Throw an overflow exception if it will not fit.

Add ++ and -- (both pre and post versions) to the natural number support.

Each object class needs the ability to be constructed from a serialized buffer. Similarly, each needs the ability to serialize its state into a buffer.

Add a c8::scale2 class that handles power-of-2 scaled numbers

Add function to convert c8::natural to unsigned long long, where the natural number will fit. Throw an overflow exception if it does not

The current c8::rational::to_double() code can't handle the generation of denormalized floating point results, whereas the constructor for c8::rational will accept them. Correct this discrepancy.

Support fast divides by powers of 2, converting them into right shifts.

Add pre and post operator variants

Handle this in the outer layers, rather than the inner layer as this is more consistent with the latest design thoughts.

We want to be able to take a rational number and round it to some level of significance. This will be useful for converting floating point approximations into more precise rationals.

Add unit tests for this function, in the same way as c8::natural.