Question

While writing several math utilities I bumped into need to implement generic utility that can perform comparisons between any two fundamental arithmetic types. As I began coding, it became clear that this operation is not as straightforward as it seems, since I need correct handling of corner cases, especially when the types have different precision, i.e. rounding strategy during conversion between types becomes important. Consider:

float a1 = 4.8f;
int a2 = 4;
assert(a2 != (int) a1); //fails erroneously since we truncated a1

float b1 = 40000000.0f; //can represent only 40000000 and 40000004 accurately
long b2 = 40000002;
assert(b1 != (float) b2); //fails erroneously since we now truncated b2

The above can be implemented using c++0x type traits to automatically select the appropriate algorithm according to the template arguments supplied to the comparison function. However, this is quite complex and there’s quite a lot of places where bugs can creep, so I don’t think inventing everything myself is worthwhile. Does anyone know a library that implements the above correctly?

Answer 1

You may want to look into GNU’s MP Bignum library at http://gmplib.org/. From their page:

GMP is a free library for arbitrary precision arithmetic, operating on
signed integers, rational numbers, and floating point numbers. There
is no practical limit to the precision except the ones implied by the
available memory in the machine GMP runs on. GMP has a rich set of
functions, and the functions have a regular interface.

GMP is carefully designed to be as fast as possible, both for small
operands and for huge operands. The speed is achieved by using
fullwords as the basic arithmetic type, by using fast algorithms, with
highly optimised assembly code for the most common inner loops for a
lot of CPUs, and by a general emphasis on speed.