gmp_float

#include <boost/multiprecision/gmp.hpp>

namespace boost{ namespace multiprecision{

template <unsigned Digits10>
class gmp_float;

typedef number<gmp_float<50> >    mpf_float_50;
typedef number<gmp_float<100> >   mpf_float_100;
typedef number<gmp_float<500> >   mpf_float_500;
typedef number<gmp_float<1000> >  mpf_float_1000;
typedef number<gmp_float<0> >     mpf_float;

}} // namespaces

The gmp_float back-end is used in conjunction with number : it acts as a thin wrapper around the GMP mpf_t to provide an real-number type that is a drop-in replacement for the native C++ floating-point types, but with much greater precision.

Type gmp_float can be used at fixed precision by specifying a non-zero Digits10 template parameter, or at variable precision by setting the template argument to zero. The typedefs mpf_float_50, mpf_float_100, mpf_float_500, mpf_float_1000 provide arithmetic types at 50, 100, 500 and 1000 decimal digits precision respectively. The typedef mpf_float provides a variable precision type whose precision can be controlled via the numbers member functions.

	Note
	This type only provides standard library and `numeric_limits` support when the precision is fixed at compile time.

As well as the usual conversions from arithmetic and string types, instances of number<mpf_float<N> > are copy constructible and assignable from:

The GMP native types mpf_t, mpz_t, mpq_t.
The number wrappers around those types: number<mpf_float<M> >, number<gmp_int>, number<gmp_rational>.

It's also possible to access the underlying mpf_t via the data() member function of gmp_float.

Things you should know when using this type:

Default constructed gmp_floats have the value zero (this is the GMP library's default behavior).
No changes are made to the GMP library's global settings, so this type can be safely mixed with existing GMP code.
This backend supports rvalue-references and is move-aware, making instantiations of number on this backend move aware.
It is not possible to round-trip objects of this type to and from a string and get back exactly the same value. This appears to be a limitation of GMP.
Since the underlying GMP types have no notion of infinities or NaNs, care should be taken to avoid numeric overflow or division by zero. That latter will result in a std::overflow_error being thrown, while generating excessively large exponents may result in instability of the underlying GMP library (in testing, converting a number with an excessively large or small exponent to a string caused GMP to segfault).
This type can equally be used with MPIR as the underlying implementation - indeed that is the recommended option on Win32.
Conversion from a string results in a std::runtime_error being thrown if the string can not be interpreted as a valid floating-point number.
Division by zero results in a std::overflow_error being thrown.

GMP example:

#include <boost/multiprecision/gmp.hpp>
#include <boost/math/special_functions/gamma.hpp>
#include <iostream>

int main()
{
   using namespace boost::multiprecision;

   // Operations at variable precision and limited standard library support:
   mpf_float a = 2;
   mpf_float::default_precision(1000);
   std::cout << mpf_float::default_precision() << std::endl;
   std::cout << sqrt(a) << std::endl; // print root-2

   // Operations at fixed precision and full standard library support:
   mpf_float_100 b = 2;
   std::cout << std::numeric_limits<mpf_float_100>::digits << std::endl;
   // We can use any C++ std lib function:
   std::cout << log(b) << std::endl; // print log(2)
   // We can also use any function from Boost.Math:
   std::cout << boost::math::tgamma(b) << std::endl;
   // These even work when the argument is an expression template:
   std::cout << boost::math::tgamma(b * b) << std::endl;

   // Access the underlying representation:
   mpf_t f;
   mpf_init(f);
   mpf_set(f, a.backend().data());
   mpf_clear(f);
   return 0;
}