|  | Home | Libraries | People | FAQ | More | 
          #include <boost/multiprecision/float128.hpp>
        
namespace boost{ namespace multiprecision{ class float128_backend; typedef number<float128_backend, et_off> float128; }} // namespaces
          The float128 number type
          is a very thin wrapper around GCC's float128
          or Intel's _Quad data types
          and provides an real-number type that is a drop-in replacement for the
          native C++ floating-point types, but with a 113 bit mantissa, and compatible
          with FORTRAN's 128-bit QUAD real.
        
          All the usual standard library and numeric_limits
          support are available, performance should be equivalent to the underlying
          native types: for example the LINPACK benchmarks for GCC's float128
          and boost::multiprecision::float128 both achieved 5.6 MFLOPS[3].
        
          As well as the usual conversions from arithmetic and string types, instances
          of float128 are copy constructible
          and assignable from GCC's float128
          and Intel's _Quad data
          types.
        
          It's also possible to access the underlying float128
          or _Quad type via the
          data()
          member function of float128_backend.
        
Things you should know when using this type:
float128s
              have the value zero.
            number on this backend
              move aware.
            _Quad
              as the underlying type: this is a current limitation of our code. Round
              tripping when using float128
              as the underlying type is possible (both for GCC and Intel).
            std::runtime_error
              being thrown if the string can not be interpreted as a valid floating-point
              number.
            float128 can be
              used as a literal type (constexpr support).
            float128
              if it's available and _Quad
              if not. You can override the default by defining either BOOST_MP_USE_FLOAT128 or BOOST_MP_USE_QUAD.
            _Quad
              type, the code must be compiled with the compiler option -Qoption,cpp,--extended_float_type.
            gcc,
              you need to use the flag --std=gnu++11/14/17,
              as the numeric literal operator 'operator""Q' is a GNU extension.
              Compilation fails with the flag --std=c++11/14/17.
            #include <boost/multiprecision/float128.hpp> #include <boost/math/special_functions/gamma.hpp> #include <iostream> int main() { using namespace boost::multiprecision; // Operations at 128-bit precision and full numeric_limits support: float128 b = 2; // There are 113-bits of precision: std::cout << std::numeric_limits<float128>::digits << std::endl; // Or 34 decimal places: std::cout << std::numeric_limits<float128>::digits10 << std::endl; // We can use any C++ std lib function, lets print all the digits as well: std::cout << std::setprecision(std::numeric_limits<float128>::max_digits10) << log(b) << std::endl; // print log(2) = 0.693147180559945309417232121458176575 // We can also use any function from Boost.Math: std::cout << boost::math::tgamma(b) << std::endl; // And since we have an extended exponent range we can generate some really large // numbers here (4.02387260077093773543702433923004111e+2564): std::cout << boost::math::tgamma(float128(1000)) << std::endl; // // We can declare constants using GCC or Intel's native types, and the Q suffix, // these can be declared constexpr if required: constexpr float128 pi = 3.1415926535897932384626433832795028841971693993751058Q; return 0; }