Is there any C/C++ library for decimals that are small (<= 16 bytes) and statically allocated?

Question

What i need is a C++ library (preferably C++, C will do as well) that implements any sort of decimal number - be they floating-point or not.

My requirements in terms of precision are rather humble - max of 10 digits after the point, and at least 20 digits before (i.e., {20digits}.{10digits}. The bottleneck in my case is space and efficiency - there will be an enormous amount of decimals (probably in the count of hundreds of millions) that i need to store and do operations on. There's also a need for storing them in files as well, so the ABI should be stable as well; or at least there should be an ability to extract the underlying parts (e.g., mantissa+exponent in case of floating-point).

I guess that implementation using int128 and fixed point at the 10th digit would suit me, though i would rather not implement it myself. However, if i need to, i don't mind doing so, in which case any related libraries that would help me implement arithmetic (and in the future, probably more advanced) operations would also be welcome.

Ive already looked into boost::multiprecision and libmpdec but they both allocate memory. libmpdec can be configured to only use statically allocated decimals, but there is still a problem of mpd_t structure being huge (48 bytes, i think).

Answer 1

The GNU Multiple Precision Arithmetic Library (GMP) could be worth a shot. Especially since the homepage mentions

There are several categories of functions in GMP:

1. High-level signed integer arithmetic functions (mpz). There are about 150 arithmetic and logic functions in this category.
2. High-level rational arithmetic functions (mpq). This category consists of about 35 functions, but all mpz functions can be used too, by applying them to the numerator and denominator separately.
3. High-level floating-point arithmetic functions (mpf). This is the GMP function category to use if the C type `double' doesn't give enough precision for an application. There are about 70 functions in this category. New projects should strongly consider using the much more complete GMP extension library mpfr instead of mpf.
4. C++ class based interface to all of the above. (The C functions and types can of course be used directly from C++ too.)
5. Low-level positive-integer, hard-to-use, very low overhead functions are found in the mpn category. No memory management is performed; the caller must ensure enough space is available for the results. The set of functions is not always regular, nor is the calling interface. These functions accept input arguments in the form of pairs consisting of a pointer to the least significant word, and an integral size telling how many limbs (= words) there are in that argument. The functions in the other categories call mpn for almost all their calculations. Of these functions about 60 are public.