Chris@16: ///////////////////////////////////////////////////////////////
Chris@16: //  Copyright 2013 John Maddock. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
Chris@16: 
Chris@16: #ifndef BOOST_MP_FLOAT128_HPP
Chris@16: #define BOOST_MP_FLOAT128_HPP
Chris@16: 
Chris@16: #include <boost/config.hpp>
Chris@16: #include <boost/scoped_array.hpp>
Chris@16: #include <boost/multiprecision/number.hpp>
Chris@16: 
Chris@16: #if defined(BOOST_INTEL) && !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
Chris@16: #  if defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION >= 1310) && defined(__GNUC__)
Chris@16: #    if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
Chris@16: #      define BOOST_MP_USE_FLOAT128
Chris@16: #    endif
Chris@16: #  endif
Chris@16: 
Chris@16: #  ifndef BOOST_MP_USE_FLOAT128
Chris@16: #    define BOOST_MP_USE_QUAD
Chris@16: #  endif
Chris@16: #endif
Chris@16: 
Chris@16: #if defined(__GNUC__) && !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
Chris@16: #  define BOOST_MP_USE_FLOAT128
Chris@16: #endif
Chris@16: 
Chris@16: #if !defined(BOOST_MP_USE_FLOAT128) && !defined(BOOST_MP_USE_QUAD)
Chris@16: #  error "Sorry compiler is neither GCC, not Intel, don't know how to configure this header."
Chris@16: #endif
Chris@16: #if defined(BOOST_MP_USE_FLOAT128) && defined(BOOST_MP_USE_QUAD)
Chris@16: #  error "Oh dear, both BOOST_MP_USE_FLOAT128 and BOOST_MP_USE_QUAD are defined, which one should I be using?"
Chris@16: #endif
Chris@16: 
Chris@16: #if defined(BOOST_MP_USE_FLOAT128)
Chris@16: 
Chris@16: extern "C" {
Chris@16: #include <quadmath.h>
Chris@16: }
Chris@16: 
Chris@16: typedef __float128 float128_type;
Chris@16: 
Chris@16: #elif defined(BOOST_MP_USE_QUAD)
Chris@16: 
Chris@16: #include <boost/multiprecision/detail/float_string_cvt.hpp>
Chris@16: 
Chris@16: typedef _Quad float128_type;
Chris@16: 
Chris@16: extern "C" {
Chris@16: _Quad __ldexpq(_Quad, int);
Chris@16: _Quad __frexpq(_Quad, int*);
Chris@16: _Quad __fabsq(_Quad);
Chris@16: _Quad __floorq(_Quad);
Chris@16: _Quad __ceilq(_Quad);
Chris@16: _Quad __sqrtq(_Quad);
Chris@16: _Quad __truncq(_Quad);
Chris@16: _Quad __expq(_Quad);
Chris@16: _Quad __powq(_Quad, _Quad);
Chris@16: _Quad __logq(_Quad);
Chris@16: _Quad __log10q(_Quad);
Chris@16: _Quad __sinq(_Quad);
Chris@16: _Quad __cosq(_Quad);
Chris@16: _Quad __tanq(_Quad);
Chris@16: _Quad __asinq(_Quad);
Chris@16: _Quad __acosq(_Quad);
Chris@16: _Quad __atanq(_Quad);
Chris@16: _Quad __sinhq(_Quad);
Chris@16: _Quad __coshq(_Quad);
Chris@16: _Quad __tanhq(_Quad);
Chris@16: _Quad __fmodq(_Quad, _Quad);
Chris@16: _Quad __atan2q(_Quad, _Quad);
Chris@16: 
Chris@16: #define ldexpq __ldexpq
Chris@16: #define frexpq __frexpq
Chris@16: #define fabsq __fabsq
Chris@16: #define floorq __floorq
Chris@16: #define ceilq __ceilq
Chris@16: #define sqrtq __sqrtq
Chris@16: #define truncq __truncq
Chris@16: #define expq __expq
Chris@16: #define powq __powq
Chris@16: #define logq __logq
Chris@16: #define log10q __log10q
Chris@16: #define sinq __sinq
Chris@16: #define cosq __cosq
Chris@16: #define tanq __tanq
Chris@16: #define asinq __asinq
Chris@16: #define acosq __acosq
Chris@16: #define atanq __atanq
Chris@16: #define sinhq __sinhq
Chris@16: #define coshq __coshq
Chris@16: #define tanhq __tanhq
Chris@16: #define fmodq __fmodq
Chris@16: #define atan2q __atan2q
Chris@16: }
Chris@16: 
Chris@16: inline _Quad isnanq(_Quad v)
Chris@16: {
Chris@16:    return v != v;
Chris@16: }
Chris@16: inline _Quad isinfq(_Quad v)
Chris@16: {
Chris@16:    return __fabsq(v) > 1.18973149535723176508575932662800702e4932Q;
Chris@16: }
Chris@16: 
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost{
Chris@16: namespace multiprecision{
Chris@16: namespace backends{
Chris@16: 
Chris@16: struct float128_backend;
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: using backends::float128_backend;
Chris@16: 
Chris@16: template<>
Chris@16: struct number_category<backends::float128_backend> : public mpl::int_<number_kind_floating_point> {};
Chris@16: template<>
Chris@16: struct number_category<float128_type> : public mpl::int_<number_kind_floating_point> {};
Chris@16: 
Chris@16: typedef number<float128_backend, et_off> float128;
Chris@16: 
Chris@16: namespace backends{
Chris@16: 
Chris@16: struct float128_backend
Chris@16: {
Chris@16:    typedef mpl::list<signed char, short, int, long, long long>   signed_types;
Chris@16:    typedef mpl::list<unsigned char, unsigned short, 
Chris@16:       unsigned int, unsigned long, unsigned long long>           unsigned_types;
Chris@16:    typedef mpl::list<float, double, long double>                 float_types;
Chris@16:    typedef int                                                   exponent_type;
Chris@16: 
Chris@16: private:
Chris@16:    float128_type m_value;
Chris@16: public:
Chris@101:    BOOST_CONSTEXPR float128_backend() BOOST_NOEXCEPT : m_value(0) {}
Chris@101:    BOOST_CONSTEXPR float128_backend(const float128_backend& o) BOOST_NOEXCEPT : m_value(o.m_value) {}
Chris@101:    float128_backend& operator = (const float128_backend& o) BOOST_NOEXCEPT
Chris@16:    {
Chris@16:       m_value = o.m_value;
Chris@16:       return *this;
Chris@16:    }
Chris@16:    template <class T>
Chris@101:    BOOST_CONSTEXPR float128_backend(const T& i, const typename enable_if_c<is_convertible<T, float128_type>::value>::type* = 0) BOOST_NOEXCEPT
Chris@16:       : m_value(i) {}
Chris@16:    template <class T>
Chris@101:    typename enable_if_c<is_arithmetic<T>::value || is_convertible<T, float128_type>::value, float128_backend&>::type operator = (const T& i) BOOST_NOEXCEPT
Chris@16:    {
Chris@16:       m_value = i;
Chris@16:       return *this;
Chris@16:    }
Chris@16:    float128_backend& operator = (const char* s)
Chris@16:    {
Chris@16: #ifndef BOOST_MP_USE_QUAD
Chris@16:       char* p_end;
Chris@16:       m_value = strtoflt128(s, &p_end);
Chris@16:       if(p_end - s != (std::ptrdiff_t)std::strlen(s))
Chris@16:       {
Chris@16:          BOOST_THROW_EXCEPTION(std::runtime_error("Unable to interpret input string as a floating point value"));
Chris@16:       }
Chris@16: #else
Chris@101:       boost::multiprecision::detail::convert_from_string(*this, s);
Chris@16: #endif
Chris@16:       return *this;
Chris@16:    }
Chris@101:    void swap(float128_backend& o) BOOST_NOEXCEPT
Chris@16:    {
Chris@16:       std::swap(m_value, o.value());
Chris@16:    }
Chris@16:    std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
Chris@16:    {
Chris@16: #ifndef BOOST_MP_USE_QUAD
Chris@16:       char buf[100];
Chris@16:       boost::scoped_array<char> buf2;
Chris@16:       std::string format = "%";
Chris@16:       if(f & std::ios_base::showpos)
Chris@16:          format += "+";
Chris@16:       if(f & std::ios_base::showpoint)
Chris@16:          format += "#";
Chris@16:       format += ".*";
Chris@16:       if(digits == 0)
Chris@16:          digits = 36;
Chris@16:       format += "Q";
Chris@16:       if(f & std::ios_base::scientific)
Chris@16:          format += "e";
Chris@16:       else if(f & std::ios_base::fixed)
Chris@16:          format += "f";
Chris@16:       else
Chris@16:          format += "g";
Chris@16: 
Chris@16:       int v = quadmath_snprintf (buf, 100, format.c_str(), digits, m_value);
Chris@16: 
Chris@16:       if((v < 0) || (v >= 99))
Chris@16:       {
Chris@16:          int v_max = v;
Chris@16:          buf2.reset(new char[v+3]);
Chris@16:          v = quadmath_snprintf (&buf2[0], v_max + 3, format.c_str(), digits, m_value);
Chris@16:          if(v >= v_max + 3)
Chris@16:          {
Chris@16:             BOOST_THROW_EXCEPTION(std::runtime_error("Formatting of float128_type failed."));
Chris@16:          }
Chris@16:          return &buf2[0];
Chris@16:       }
Chris@16:       return buf;
Chris@16: #else
Chris@101:       return boost::multiprecision::detail::convert_to_string(*this, digits ? digits : 37, f);
Chris@16: #endif
Chris@16:    }
Chris@101:    void negate() BOOST_NOEXCEPT
Chris@16:    {
Chris@16:       m_value = -m_value;
Chris@16:    }
Chris@16:    int compare(const float128_backend& o)const
Chris@16:    {
Chris@16:       return m_value == o.m_value ? 0 : m_value < o.m_value ? -1 : 1;
Chris@16:    }
Chris@16:    template <class T>
Chris@16:    int compare(const T& i)const
Chris@16:    {
Chris@16:       return m_value == i ? 0 : m_value < i ? -1 : 1;
Chris@16:    }
Chris@16:    float128_type& value()
Chris@16:    {
Chris@16:       return m_value;
Chris@16:    }
Chris@16:    const float128_type& value()const
Chris@16:    {
Chris@16:       return m_value;
Chris@16:    }
Chris@16: };
Chris@16: 
Chris@16: inline void eval_add(float128_backend& result, const float128_backend& a)
Chris@16: {
Chris@16:    result.value() += a.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_add(float128_backend& result, const A& a)
Chris@16: {
Chris@16:    result.value() += a;
Chris@16: }
Chris@16: inline void eval_subtract(float128_backend& result, const float128_backend& a)
Chris@16: {
Chris@16:    result.value() -= a.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_subtract(float128_backend& result, const A& a)
Chris@16: {
Chris@16:    result.value() -= a;
Chris@16: }
Chris@16: inline void eval_multiply(float128_backend& result, const float128_backend& a)
Chris@16: {
Chris@16:    result.value() *= a.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_multiply(float128_backend& result, const A& a)
Chris@16: {
Chris@16:    result.value() *= a;
Chris@16: }
Chris@16: inline void eval_divide(float128_backend& result, const float128_backend& a)
Chris@16: {
Chris@16:    result.value() /= a.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_divide(float128_backend& result, const A& a)
Chris@16: {
Chris@16:    result.value() /= a;
Chris@16: }
Chris@16: 
Chris@16: inline void eval_add(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = a.value() + b.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_add(float128_backend& result, const float128_backend& a, const A& b)
Chris@16: {
Chris@16:    result.value() = a.value() + b;
Chris@16: }
Chris@16: inline void eval_subtract(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = a.value() - b.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_subtract(float128_backend& result, const float128_backend& a, const A& b)
Chris@16: {
Chris@16:    result.value() = a.value() - b;
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_subtract(float128_backend& result, const A& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = a - b.value();
Chris@16: }
Chris@16: inline void eval_multiply(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = a.value() * b.value();
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_multiply(float128_backend& result, const float128_backend& a, const A& b)
Chris@16: {
Chris@16:    result.value() = a.value() * b;
Chris@16: }
Chris@16: inline void eval_divide(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = a.value() / b.value();
Chris@16: }
Chris@16: 
Chris@16: template <class R>
Chris@16: inline void eval_convert_to(R* result, const float128_backend& val)
Chris@16: {
Chris@16:    *result = static_cast<R>(val.value());
Chris@16: }
Chris@16: 
Chris@16: inline void eval_frexp(float128_backend& result, const float128_backend& arg, int* exp)
Chris@16: {
Chris@16:    result.value() = frexpq(arg.value(), exp);
Chris@16: }
Chris@16: 
Chris@16: inline void eval_ldexp(float128_backend& result, const float128_backend& arg, int exp)
Chris@16: {
Chris@16:    result.value() = ldexpq(arg.value(), exp);
Chris@16: }
Chris@16: 
Chris@16: inline void eval_floor(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = floorq(arg.value());
Chris@16: }
Chris@16: inline void eval_ceil(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = ceilq(arg.value());
Chris@16: }
Chris@16: inline void eval_sqrt(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = sqrtq(arg.value());
Chris@16: }
Chris@16: inline int eval_fpclassify(const float128_backend& arg)
Chris@16: {
Chris@16:    return isnanq(arg.value()) ? FP_NAN : isinfq(arg.value()) ? FP_INFINITE : arg.value() == 0 ? FP_ZERO : FP_NORMAL;
Chris@16: }
Chris@16: 
Chris@16: inline void eval_increment(float128_backend& arg)
Chris@16: {
Chris@16:    ++arg.value();
Chris@16: }
Chris@16: inline void eval_decrement(float128_backend& arg)
Chris@16: {
Chris@16:    --arg.value();
Chris@16: }
Chris@16: 
Chris@16: /*********************************************************************
Chris@16: *
Chris@16: * abs/fabs:
Chris@16: *
Chris@16: *********************************************************************/
Chris@16: 
Chris@16: inline void eval_abs(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = fabsq(arg.value());
Chris@16: }
Chris@16: inline void eval_fabs(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = fabsq(arg.value());
Chris@16: }
Chris@16: 
Chris@16: /*********************************************************************
Chris@16: *
Chris@16: * Floating point functions:
Chris@16: *
Chris@16: *********************************************************************/
Chris@16: 
Chris@16: inline void eval_trunc(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    if(isnanq(arg.value()) || isinfq(arg.value()))
Chris@16:    {
Chris@16:       result = boost::math::policies::raise_rounding_error(
Chris@16:             "boost::multiprecision::trunc<%1%>(%1%)", 0, 
Chris@16:             number<float128_backend, et_off>(arg), 
Chris@16:             number<float128_backend, et_off>(arg), 
Chris@16:             boost::math::policies::policy<>()).backend();
Chris@16:       return;
Chris@16:    }
Chris@16:    result.value() = truncq(arg.value());
Chris@16: }
Chris@16: /*
Chris@16: // 
Chris@16: // This doesn't actually work... rely on our own default version instead.
Chris@16: //
Chris@16: inline void eval_round(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    if(isnanq(arg.value()) || isinf(arg.value()))
Chris@16:    {
Chris@16:       result = boost::math::policies::raise_rounding_error(
Chris@16:             "boost::multiprecision::trunc<%1%>(%1%)", 0, 
Chris@16:             number<float128_backend, et_off>(arg), 
Chris@16:             number<float128_backend, et_off>(arg), 
Chris@16:             boost::math::policies::policy<>()).backend();
Chris@16:       return;
Chris@16:    }
Chris@16:    result.value() = roundq(arg.value());
Chris@16: }
Chris@16: */
Chris@16: 
Chris@16: inline void eval_exp(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = expq(arg.value());
Chris@16: }
Chris@16: inline void eval_log(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = logq(arg.value());
Chris@16: }
Chris@16: inline void eval_log10(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = log10q(arg.value());
Chris@16: }
Chris@16: inline void eval_sin(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = sinq(arg.value());
Chris@16: }
Chris@16: inline void eval_cos(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = cosq(arg.value());
Chris@16: }
Chris@16: inline void eval_tan(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = tanq(arg.value());
Chris@16: }
Chris@16: inline void eval_asin(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = asinq(arg.value());
Chris@16: }
Chris@16: inline void eval_acos(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = acosq(arg.value());
Chris@16: }
Chris@16: inline void eval_atan(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = atanq(arg.value());
Chris@16: }
Chris@16: inline void eval_sinh(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = sinhq(arg.value());
Chris@16: }
Chris@16: inline void eval_cosh(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = coshq(arg.value());
Chris@16: }
Chris@16: inline void eval_tanh(float128_backend& result, const float128_backend& arg)
Chris@16: {
Chris@16:    result.value() = tanhq(arg.value());
Chris@16: }
Chris@16: inline void eval_fmod(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = fmodq(a.value(), b.value());
Chris@16: }
Chris@16: inline void eval_pow(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = powq(a.value(), b.value());
Chris@16: }
Chris@16: inline void eval_atan2(float128_backend& result, const float128_backend& a, const float128_backend& b)
Chris@16: {
Chris@16:    result.value() = atan2q(a.value(), b.value());
Chris@16: }
Chris@16: 
Chris@16: } // namespace backends
Chris@16: 
Chris@16: }} // namespaces
Chris@16: 
Chris@16: namespace boost{ 
Chris@16: namespace archive{
Chris@16: 
Chris@16: class binary_oarchive;
Chris@16: class binary_iarchive;
Chris@16: 
Chris@16: }
Chris@16:    
Chris@16: namespace serialization{ namespace float128_detail{
Chris@16: 
Chris@16: template <class Archive>
Chris@16: void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::false_&, const mpl::false_&)
Chris@16: {
Chris@16:    // saving
Chris@16:    // non-binary
Chris@16:    std::string s(val.str(0, std::ios_base::scientific));
Chris@16:    ar & s;
Chris@16: }
Chris@16: template <class Archive>
Chris@16: void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::true_&, const mpl::false_&)
Chris@16: {
Chris@16:    // loading
Chris@16:    // non-binary
Chris@16:    std::string s;
Chris@16:    ar & s;
Chris@16:    val = s.c_str();
Chris@16: }
Chris@16: 
Chris@16: template <class Archive>
Chris@16: void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::false_&, const mpl::true_&)
Chris@16: {
Chris@16:    // saving
Chris@16:    // binary
Chris@16:    ar.save_binary(&val, sizeof(val));
Chris@16: }
Chris@16: template <class Archive>
Chris@16: void do_serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, const mpl::true_&, const mpl::true_&)
Chris@16: {
Chris@16:    // loading
Chris@16:    // binary
Chris@16:    ar.load_binary(&val, sizeof(val));
Chris@16: }
Chris@16: 
Chris@16: } // detail
Chris@16: 
Chris@16: template <class Archive>
Chris@16: void serialize(Archive& ar, boost::multiprecision::backends::float128_backend& val, unsigned int /*version*/)
Chris@16: {
Chris@16:    typedef typename Archive::is_loading load_tag;
Chris@16:    typedef typename mpl::bool_<boost::is_same<Archive, boost::archive::binary_oarchive>::value || boost::is_same<Archive, boost::archive::binary_iarchive>::value> binary_tag;
Chris@16: 
Chris@16:    float128_detail::do_serialize(ar, val, load_tag(), binary_tag());
Chris@16: }
Chris@16: 
Chris@16: }}
Chris@16: 
Chris@16: namespace std{
Chris@16: 
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: class numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >
Chris@16: {
Chris@16:    typedef boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> number_type;
Chris@16: public:
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_specialized = true;
Chris@16:    static number_type (min)() BOOST_NOEXCEPT { return 3.36210314311209350626267781732175260e-4932Q; }
Chris@16:    static number_type (max)() BOOST_NOEXCEPT { return 1.18973149535723176508575932662800702e4932Q; }
Chris@16:    static number_type lowest() BOOST_NOEXCEPT { return -(max)(); }
Chris@16:    BOOST_STATIC_CONSTEXPR int digits = 113;
Chris@16:    BOOST_STATIC_CONSTEXPR int digits10 = 34;
Chris@16:    BOOST_STATIC_CONSTEXPR int max_digits10 = 36;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_signed = true;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_integer = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_exact = false;
Chris@16:    BOOST_STATIC_CONSTEXPR int radix = 2;
Chris@16:    static number_type epsilon() { return 1.92592994438723585305597794258492732e-34Q; }
Chris@16:    static number_type round_error() { return 0.5; }
Chris@16:    BOOST_STATIC_CONSTEXPR int min_exponent = -16381;
Chris@16:    BOOST_STATIC_CONSTEXPR int min_exponent10 = min_exponent * 301L / 1000L;
Chris@16:    BOOST_STATIC_CONSTEXPR int max_exponent = 16384;
Chris@16:    BOOST_STATIC_CONSTEXPR int max_exponent10 = max_exponent * 301L / 1000L;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_infinity = true;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = true;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
Chris@16:    BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
Chris@16:    static number_type infinity() { return 1.0q / 0.0q; }
Chris@16:    static number_type quiet_NaN() { return number_type("nan"); }
Chris@16:    static number_type signaling_NaN() { return 0; }
Chris@16:    static number_type denorm_min() { return 0; }
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_iec559 = true;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_bounded = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_modulo = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool traps = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
Chris@16:    BOOST_STATIC_CONSTEXPR float_round_style round_style = round_to_nearest;
Chris@16: };
Chris@16: 
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_specialized;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::digits;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::digits10;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_digits10;
Chris@101: 
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_signed;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_integer;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_exact;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::radix;
Chris@101: 
Chris@101: 
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::min_exponent;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_exponent;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::min_exponent10;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const int numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::max_exponent10;
Chris@101: 
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_infinity;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_quiet_NaN;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_signaling_NaN;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_denorm_loss;
Chris@101: 
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_iec559;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_bounded;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::is_modulo;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::traps;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const bool numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::tinyness_before;
Chris@101: 
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::round_style;
Chris@101: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@101: const float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::backends::float128_backend, ExpressionTemplates> >::has_denorm;
Chris@101: 
Chris@16: } // namespace std
Chris@16: 
Chris@16: 
Chris@16: #endif