#include <boost/math/special_functions/gamma.hpp>
#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable:4127)
+#pragma warning(push)
+#pragma warning(disable : 4127)
#endif
#include <gmp.h>
#ifdef BOOST_MSVC
-# pragma warning(pop)
+#pragma warning(pop)
#endif
#if defined(__MPIR_VERSION) && defined(__MPIR_VERSION_MINOR) && defined(__MPIR_VERSION_PATCHLEVEL)
-# define BOOST_MP_MPIR_VERSION (__MPIR_VERSION * 10000 + __MPIR_VERSION_MINOR * 100 + __MPIR_VERSION_PATCHLEVEL)
+#define BOOST_MP_MPIR_VERSION (__MPIR_VERSION * 10000 + __MPIR_VERSION_MINOR * 100 + __MPIR_VERSION_PATCHLEVEL)
#else
-# define BOOST_MP_MPIR_VERSION 0
+#define BOOST_MP_MPIR_VERSION 0
#endif
+#include <cctype>
#include <cmath>
#include <limits>
#include <climits>
-namespace boost{
-namespace multiprecision{
-namespace backends{
+namespace boost {
+namespace multiprecision {
+namespace backends {
#ifdef BOOST_MSVC
// warning C4127: conditional expression is constant
#pragma warning(push)
-#pragma warning(disable:4127)
+#pragma warning(disable : 4127)
#endif
template <unsigned digits10>
} // namespace backends
-template<>
-struct number_category<backends::gmp_int> : public mpl::int_<number_kind_integer>{};
-template<>
-struct number_category<backends::gmp_rational> : public mpl::int_<number_kind_rational>{};
+template <>
+struct number_category<backends::gmp_int> : public mpl::int_<number_kind_integer>
+{};
+template <>
+struct number_category<backends::gmp_rational> : public mpl::int_<number_kind_rational>
+{};
template <unsigned digits10>
-struct number_category<backends::gmp_float<digits10> > : public mpl::int_<number_kind_floating_point>{};
+struct number_category<backends::gmp_float<digits10> > : public mpl::int_<number_kind_floating_point>
+{};
-namespace backends{
+namespace backends {
//
// Within this file, the only functions we mark as noexcept are those that manipulate
// (but don't create) an mpf_t. All other types may allocate at pretty much any time
// via a user-supplied allocator, and therefore throw.
//
-namespace detail{
+namespace detail {
template <unsigned digits10>
struct gmp_float_imp
{
#ifdef BOOST_HAS_LONG_LONG
- typedef mpl::list<long, boost::long_long_type> signed_types;
- typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
+ typedef mpl::list<long, boost::long_long_type> signed_types;
+ typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
#else
- typedef mpl::list<long> signed_types;
- typedef mpl::list<unsigned long> unsigned_types;
+ typedef mpl::list<long> signed_types;
+ typedef mpl::list<unsigned long> unsigned_types;
#endif
- typedef mpl::list<double, long double> float_types;
- typedef long exponent_type;
+ typedef mpl::list<double, long double> float_types;
+ typedef long exponent_type;
- gmp_float_imp() BOOST_NOEXCEPT {}
+ gmp_float_imp() BOOST_NOEXCEPT
+ {
+ m_data[0]._mp_d = 0; // uninitialized m_data
+ }
gmp_float_imp(const gmp_float_imp& o)
{
// to get the right value, but if it's then used in further calculations
// things go badly wrong!!
//
- mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
- if(o.m_data[0]._mp_d)
+ mpf_init2(m_data, mpf_get_prec(o.data()));
+ if (o.m_data[0]._mp_d)
mpf_set(m_data, o.m_data);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
gmp_float_imp(gmp_float_imp&& o) BOOST_NOEXCEPT
{
- m_data[0] = o.m_data[0];
+ m_data[0] = o.m_data[0];
o.m_data[0]._mp_d = 0;
}
#endif
- gmp_float_imp& operator = (const gmp_float_imp& o)
+ gmp_float_imp& operator=(const gmp_float_imp& o)
{
- if(m_data[0]._mp_d == 0)
- mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
- if(o.m_data[0]._mp_d)
- mpf_set(m_data, o.m_data);
+ if (m_data[0]._mp_d == 0)
+ mpf_init2(m_data, mpf_get_prec(o.data()));
+ if (mpf_get_prec(data()) != mpf_get_prec(o.data()))
+ {
+ mpf_t t;
+ mpf_init2(t, mpf_get_prec(o.data()));
+ mpf_set(t, o.data());
+ mpf_swap(data(), t);
+ mpf_clear(t);
+ }
+ else
+ {
+ if (o.m_data[0]._mp_d)
+ mpf_set(m_data, o.m_data);
+ }
return *this;
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- gmp_float_imp& operator = (gmp_float_imp&& o) BOOST_NOEXCEPT
+ gmp_float_imp& operator=(gmp_float_imp&& o) BOOST_NOEXCEPT
{
mpf_swap(m_data, o.m_data);
return *this;
#ifdef BOOST_HAS_LONG_LONG
#if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX)
- gmp_float_imp& operator = (boost::ulong_long_type i)
+ gmp_float_imp& operator=(boost::ulong_long_type i)
{
*this = static_cast<unsigned long>(i);
return *this;
}
#else
- gmp_float_imp& operator = (boost::ulong_long_type i)
+ gmp_float_imp& operator=(boost::ulong_long_type i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
- boost::ulong_long_type mask = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
- unsigned shift = 0;
- mpf_t t;
+ boost::ulong_long_type mask = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
+ unsigned shift = 0;
+ mpf_t t;
mpf_init2(t, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpf_set_ui(m_data, 0);
- while(i)
+ while (i)
{
mpf_set_ui(t, static_cast<unsigned long>(i & mask));
- if(shift)
+ if (shift)
mpf_mul_2exp(t, t, shift);
mpf_add(m_data, m_data, t);
shift += std::numeric_limits<unsigned long>::digits;
return *this;
}
#endif
- gmp_float_imp& operator = (boost::long_long_type i)
+ gmp_float_imp& operator=(boost::long_long_type i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
bool neg = i < 0;
- *this = static_cast<boost::ulong_long_type>(boost::multiprecision::detail::unsigned_abs(i));
- if(neg)
+ *this = static_cast<boost::ulong_long_type>(boost::multiprecision::detail::unsigned_abs(i));
+ if (neg)
mpf_neg(m_data, m_data);
return *this;
}
#endif
- gmp_float_imp& operator = (unsigned long i)
+ gmp_float_imp& operator=(unsigned long i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpf_set_ui(m_data, i);
return *this;
}
- gmp_float_imp& operator = (long i)
+ gmp_float_imp& operator=(long i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpf_set_si(m_data, i);
return *this;
}
- gmp_float_imp& operator = (double d)
+ gmp_float_imp& operator=(double d)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
mpf_set_d(m_data, d);
return *this;
}
- gmp_float_imp& operator = (long double a)
+ gmp_float_imp& operator=(long double a)
{
+ using std::floor;
using std::frexp;
using std::ldexp;
- using std::floor;
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
- if (a == 0) {
+ if (a == 0)
+ {
mpf_set_si(m_data, 0);
return *this;
}
- if (a == 1) {
+ if (a == 1)
+ {
mpf_set_si(m_data, 1);
return *this;
}
BOOST_ASSERT(!(boost::math::isinf)(a));
BOOST_ASSERT(!(boost::math::isnan)(a));
- int e;
+ int e;
long double f, term;
mpf_set_ui(m_data, 0u);
static const int shift = std::numeric_limits<int>::digits - 1;
- while(f)
+ while (f)
{
// extract int sized bits from f:
- f = ldexp(f, shift);
+ f = ldexp(f, shift);
term = floor(f);
e -= shift;
mpf_mul_2exp(m_data, m_data, shift);
- if(term > 0)
+ if (term > 0)
mpf_add_ui(m_data, m_data, static_cast<unsigned>(term));
else
mpf_sub_ui(m_data, m_data, static_cast<unsigned>(-term));
f -= term;
}
- if(e > 0)
+ if (e > 0)
mpf_mul_2exp(m_data, m_data, e);
- else if(e < 0)
+ else if (e < 0)
mpf_div_2exp(m_data, m_data, -e);
return *this;
}
- gmp_float_imp& operator = (const char* s)
+ gmp_float_imp& operator=(const char* s)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : get_default_precision()));
- if(0 != mpf_set_str(m_data, s, 10))
+ if (0 != mpf_set_str(m_data, s, 10))
BOOST_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid floating point number.")));
return *this;
}
{
mpf_swap(m_data, o.m_data);
}
- std::string str(std::streamsize digits, std::ios_base::fmtflags f)const
+ std::string str(std::streamsize digits, std::ios_base::fmtflags f) const
{
BOOST_ASSERT(m_data[0]._mp_d);
- bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
- bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed;
+ bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific;
+ bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed;
std::streamsize org_digits(digits);
- if(scientific && digits)
+ if (scientific && digits)
++digits;
std::string result;
- mp_exp_t e;
- void *(*alloc_func_ptr) (size_t);
- void *(*realloc_func_ptr) (void *, size_t, size_t);
- void (*free_func_ptr) (void *, size_t);
+ mp_exp_t e;
+ void* (*alloc_func_ptr)(size_t);
+ void* (*realloc_func_ptr)(void*, size_t, size_t);
+ void (*free_func_ptr)(void*, size_t);
mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
- if(mpf_sgn(m_data) == 0)
+ if (mpf_sgn(m_data) == 0)
{
- e = 0;
+ e = 0;
result = "0";
- if(fixed && digits)
+ if (fixed && digits)
++digits;
}
else
{
- char* ps = mpf_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data);
- --e; // To match with what our formatter expects.
- if(fixed && e != -1)
+ char* ps = mpf_get_str(0, &e, 10, static_cast<std::size_t>(digits), m_data);
+ --e; // To match with what our formatter expects.
+ if (fixed && e != -1)
{
// Oops we actually need a different number of digits to what we asked for:
(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
digits += e + 1;
- if(digits == 0)
+ if (digits == 0)
{
// We need to get *all* the digits and then possibly round up,
// we end up with either "0" or "1" as the result.
- ps = mpf_get_str (0, &e, 10, 0, m_data);
+ ps = mpf_get_str(0, &e, 10, 0, m_data);
--e;
unsigned offset = *ps == '-' ? 1 : 0;
- if(ps[offset] > '5')
+ if (ps[offset] > '5')
{
++e;
- ps[offset] = '1';
+ ps[offset] = '1';
ps[offset + 1] = 0;
}
- else if(ps[offset] == '5')
+ else if (ps[offset] == '5')
{
- unsigned i = offset + 1;
- bool round_up = false;
- while(ps[i] != 0)
+ unsigned i = offset + 1;
+ bool round_up = false;
+ while (ps[i] != 0)
{
- if(ps[i] != '0')
+ if (ps[i] != '0')
{
round_up = true;
break;
}
+ ++i;
}
- if(round_up)
+ if (round_up)
{
++e;
- ps[offset] = '1';
+ ps[offset] = '1';
ps[offset + 1] = 0;
}
else
{
- ps[offset] = '0';
+ ps[offset] = '0';
ps[offset + 1] = 0;
}
}
else
{
- ps[offset] = '0';
+ ps[offset] = '0';
ps[offset + 1] = 0;
}
}
- else if(digits > 0)
+ else if (digits > 0)
{
- ps = mpf_get_str (0, &e, 10, static_cast<std::size_t>(digits), m_data);
- --e; // To match with what our formatter expects.
+ mp_exp_t old_e = e;
+ ps = mpf_get_str(0, &e, 10, static_cast<std::size_t>(digits), m_data);
+ --e; // To match with what our formatter expects.
+ if (old_e > e)
+ {
+ // in some cases, when we ask for more digits of precision, it will
+ // change the number of digits to the left of the decimal, if that
+ // happens, account for it here.
+ // example: cout << fixed << setprecision(3) << mpf_float_50("99.9809")
+ digits -= old_e - e;
+ ps = mpf_get_str(0, &e, 10, static_cast<std::size_t>(digits), m_data);
+ --e; // To match with what our formatter expects.
+ }
}
else
{
- ps = mpf_get_str (0, &e, 10, 1, m_data);
+ ps = mpf_get_str(0, &e, 10, 1, m_data);
--e;
unsigned offset = *ps == '-' ? 1 : 0;
- ps[offset] = '0';
- ps[offset + 1] = 0;
+ ps[offset] = '0';
+ ps[offset + 1] = 0;
}
}
result = ps;
}
~gmp_float_imp() BOOST_NOEXCEPT
{
- if(m_data[0]._mp_d)
+ if (m_data[0]._mp_d)
mpf_clear(m_data);
}
void negate() BOOST_NOEXCEPT
BOOST_ASSERT(m_data[0]._mp_d);
mpf_neg(m_data, m_data);
}
- int compare(const gmp_float<digits10>& o)const BOOST_NOEXCEPT
+ int compare(const gmp_float<digits10>& o) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d && o.m_data[0]._mp_d);
return mpf_cmp(m_data, o.m_data);
}
- int compare(long i)const BOOST_NOEXCEPT
+ int compare(long i) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d);
return mpf_cmp_si(m_data, i);
}
- int compare(unsigned long i)const BOOST_NOEXCEPT
+ int compare(unsigned long i) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d);
return mpf_cmp_ui(m_data, i);
}
template <class V>
- typename enable_if<is_arithmetic<V>, int>::type compare(V v)const
+ typename enable_if<is_arithmetic<V>, int>::type compare(V v) const
{
gmp_float<digits10> d;
d = v;
BOOST_ASSERT(m_data[0]._mp_d);
return m_data;
}
- const mpf_t& data()const BOOST_NOEXCEPT
+ const mpf_t& data() const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d);
return m_data;
}
-protected:
- mpf_t m_data;
+
+ protected:
+ mpf_t m_data;
static unsigned& get_default_precision() BOOST_NOEXCEPT
{
static unsigned val = 50;
mpf_set_q(this->m_data, val);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- gmp_float(gmp_float&& o) BOOST_NOEXCEPT : detail::gmp_float_imp<digits10>(static_cast<detail::gmp_float_imp<digits10>&&>(o)) {}
+ gmp_float(gmp_float&& o) BOOST_NOEXCEPT : detail::gmp_float_imp<digits10>(static_cast<detail::gmp_float_imp<digits10>&&>(o))
+ {}
#endif
gmp_float& operator=(const gmp_float& o)
{
gmp_float& operator=(const gmp_rational& o);
gmp_float& operator=(const mpf_t val)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
mpf_set(this->m_data, val);
return *this;
}
gmp_float& operator=(const mpz_t val)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
mpf_set_z(this->m_data, val);
return *this;
}
gmp_float& operator=(const mpq_t val)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
mpf_set_q(this->m_data, val);
return *this;
mpf_set(this->m_data, o.data());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- gmp_float(gmp_float&& o) BOOST_NOEXCEPT : detail::gmp_float_imp<0>(static_cast<detail::gmp_float_imp<0>&&>(o)) {}
+ gmp_float(gmp_float&& o) BOOST_NOEXCEPT : detail::gmp_float_imp<0>(static_cast<detail::gmp_float_imp<0>&&>(o))
+ {}
#endif
gmp_float(const gmp_int& o);
gmp_float(const gmp_rational& o);
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
mpf_set(this->m_data, o.data());
}
+ template <class V>
+ gmp_float(const V& o, unsigned digits10)
+ {
+ mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
+ *this = o;
+ }
+#ifndef BOOST_NO_CXX17_HDR_STRING_VIEW
+ //
+ // Support for new types in C++17
+ //
+ template <class Traits>
+ gmp_float(const std::basic_string_view<char, Traits>& o, unsigned digits10)
+ {
+ using default_ops::assign_from_string_view;
+ mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10));
+ assign_from_string_view(*this, o);
+ }
+#endif
gmp_float& operator=(const gmp_float& o)
{
*static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0> const&>(o);
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
gmp_float& operator=(gmp_float&& o) BOOST_NOEXCEPT
{
- *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0> &&>(o);
+ *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0>&&>(o);
return *this;
}
#endif
template <unsigned D>
gmp_float& operator=(const gmp_float<D>& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
{
mpf_init2(this->m_data, mpf_get_prec(o.data()));
}
gmp_float& operator=(const gmp_rational& o);
gmp_float& operator=(const mpf_t val)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(get_default_precision()));
mpf_set(this->m_data, val);
return *this;
}
gmp_float& operator=(const mpz_t val)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(get_default_precision()));
mpf_set_z(this->m_data, val);
return *this;
}
gmp_float& operator=(const mpq_t val)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(get_default_precision()));
mpf_set_q(this->m_data, val);
return *this;
{
get_default_precision() = v;
}
- unsigned precision()const BOOST_NOEXCEPT
+ unsigned precision() const BOOST_NOEXCEPT
{
return static_cast<unsigned>(multiprecision::detail::digits2_2_10(static_cast<unsigned long>(mpf_get_prec(this->m_data))));
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& result, const gmp_float<D2>& o)
{
- if(eval_is_zero(o))
+ if (eval_is_zero(o))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpf_div(result.data(), result.data(), o.data());
}
template <unsigned digits10>
inline void eval_divide(gmp_float<digits10>& result, unsigned long i)
{
- if(i == 0)
+ if (i == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpf_div_ui(result.data(), result.data(), i);
}
template <unsigned digits10>
inline void eval_add(gmp_float<digits10>& result, long i)
{
- if(i > 0)
+ if (i > 0)
mpf_add_ui(result.data(), result.data(), i);
else
mpf_sub_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
template <unsigned digits10>
inline void eval_subtract(gmp_float<digits10>& result, long i)
{
- if(i > 0)
+ if (i > 0)
mpf_sub_ui(result.data(), result.data(), i);
else
mpf_add_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
inline void eval_multiply(gmp_float<digits10>& result, long i)
{
mpf_mul_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
- if(i < 0)
+ if (i < 0)
mpf_neg(result.data(), result.data());
}
template <unsigned digits10>
inline void eval_divide(gmp_float<digits10>& result, long i)
{
- if(i == 0)
+ if (i == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpf_div_ui(result.data(), result.data(), boost::multiprecision::detail::unsigned_abs(i));
- if(i < 0)
+ if (i < 0)
mpf_neg(result.data(), result.data());
}
//
template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
mpf_sub_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
else
mpf_add_ui(a.data(), x.data(), y);
template <unsigned D1, unsigned D2>
inline void eval_add(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpf_ui_sub(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data());
mpf_neg(a.data(), a.data());
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
mpf_add_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
else
mpf_sub_ui(a.data(), x.data(), y);
template <unsigned D1, unsigned D2>
inline void eval_subtract(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpf_add_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x));
mpf_neg(a.data(), a.data());
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
- if(y < 0)
+ if (y < 0)
{
mpf_mul_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
a.negate();
template <unsigned D1, unsigned D2>
inline void eval_multiply(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
- if(x < 0)
+ if (x < 0)
{
mpf_mul_ui(a.data(), y.data(), boost::multiprecision::detail::unsigned_abs(x));
mpf_neg(a.data(), a.data());
template <unsigned D1, unsigned D2, unsigned D3>
inline void eval_divide(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y)
{
- if(eval_is_zero(y))
+ if (eval_is_zero(y))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpf_div(a.data(), x.data(), y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y)
{
- if(y == 0)
+ if (y == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpf_div_ui(a.data(), x.data(), y);
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, const gmp_float<D2>& x, long y)
{
- if(y == 0)
+ if (y == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
- if(y < 0)
+ if (y < 0)
{
mpf_div_ui(a.data(), x.data(), boost::multiprecision::detail::unsigned_abs(y));
a.negate();
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y)
{
- if(eval_is_zero(y))
+ if (eval_is_zero(y))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpf_ui_div(a.data(), x, y.data());
}
template <unsigned D1, unsigned D2>
inline void eval_divide(gmp_float<D1>& a, long x, const gmp_float<D2>& y)
{
- if(eval_is_zero(y))
+ if (eval_is_zero(y))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
- if(x < 0)
+ if (x < 0)
{
mpf_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data());
mpf_neg(a.data(), a.data());
template <unsigned digits10>
inline void eval_convert_to(unsigned long* result, const gmp_float<digits10>& val) BOOST_NOEXCEPT
{
- if(0 == mpf_fits_ulong_p(val.data()))
+ if (0 == mpf_fits_ulong_p(val.data()))
*result = (std::numeric_limits<unsigned long>::max)();
else
*result = (unsigned long)mpf_get_ui(val.data());
template <unsigned digits10>
inline void eval_convert_to(long* result, const gmp_float<digits10>& val) BOOST_NOEXCEPT
{
- if(0 == mpf_fits_slong_p(val.data()))
+ if (0 == mpf_fits_slong_p(val.data()))
{
*result = (std::numeric_limits<long>::max)();
*result *= mpf_sgn(val.data());
inline void eval_convert_to(boost::long_long_type* result, const gmp_float<digits10>& val)
{
gmp_float<digits10> t(val);
- if(eval_get_sign(t) < 0)
+ if (eval_get_sign(t) < 0)
t.negate();
long digits = std::numeric_limits<boost::long_long_type>::digits - std::numeric_limits<long>::digits;
- if(digits > 0)
+ if (digits > 0)
mpf_div_2exp(t.data(), t.data(), digits);
- if(!mpf_fits_slong_p(t.data()))
+ if (!mpf_fits_slong_p(t.data()))
{
- if(eval_get_sign(val) < 0)
+ if (eval_get_sign(val) < 0)
*result = (std::numeric_limits<boost::long_long_type>::min)();
else
*result = (std::numeric_limits<boost::long_long_type>::max)();
};
*result = mpf_get_si(t.data());
- while(digits > 0)
+ while (digits > 0)
{
*result <<= digits;
digits -= std::numeric_limits<unsigned long>::digits;
mpf_mul_2exp(t.data(), t.data(), digits >= 0 ? std::numeric_limits<unsigned long>::digits : std::numeric_limits<unsigned long>::digits + digits);
unsigned long l = (unsigned long)mpf_get_ui(t.data());
- if(digits < 0)
+ if (digits < 0)
l >>= -digits;
*result |= l;
}
- if(eval_get_sign(val) < 0)
+ if (eval_get_sign(val) < 0)
*result = -*result;
}
template <unsigned digits10>
long digits = std::numeric_limits<boost::long_long_type>::digits - std::numeric_limits<long>::digits;
- if(digits > 0)
+ if (digits > 0)
mpf_div_2exp(t.data(), t.data(), digits);
- if(!mpf_fits_ulong_p(t.data()))
+ if (!mpf_fits_ulong_p(t.data()))
{
*result = (std::numeric_limits<boost::long_long_type>::max)();
return;
}
*result = mpf_get_ui(t.data());
- while(digits > 0)
+ while (digits > 0)
{
*result <<= digits;
digits -= std::numeric_limits<unsigned long>::digits;
mpf_mul_2exp(t.data(), t.data(), digits >= 0 ? std::numeric_limits<unsigned long>::digits : std::numeric_limits<unsigned long>::digits + digits);
unsigned long l = (unsigned long)mpf_get_ui(t.data());
- if(digits < 0)
+ if (digits < 0)
l >>= -digits;
*result |= l;
}
template <unsigned Digits10>
inline void eval_ldexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long e)
{
- if(e > 0)
+ if (e > 0)
mpf_mul_2exp(result.data(), val.data(), e);
- else if(e < 0)
+ else if (e < 0)
mpf_div_2exp(result.data(), val.data(), -e);
else
result = val;
mpir_si v;
mpf_get_d_2exp(&v, val.data());
#else
- long v;
+ long v;
mpf_get_d_2exp(&v, val.data());
#endif
*e = v;
inline std::size_t hash_value(const gmp_float<Digits10>& val)
{
std::size_t result = 0;
- for(int i = 0; i < std::abs(val.data()[0]._mp_size); ++i)
+ for (int i = 0; i < std::abs(val.data()[0]._mp_size); ++i)
boost::hash_combine(result, val.data()[0]._mp_d[i]);
boost::hash_combine(result, val.data()[0]._mp_exp);
boost::hash_combine(result, val.data()[0]._mp_size);
struct gmp_int
{
#ifdef BOOST_HAS_LONG_LONG
- typedef mpl::list<long, boost::long_long_type> signed_types;
- typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
+ typedef mpl::list<long, boost::long_long_type> signed_types;
+ typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
#else
- typedef mpl::list<long> signed_types;
- typedef mpl::list<unsigned long> unsigned_types;
+ typedef mpl::list<long> signed_types;
+ typedef mpl::list<unsigned long> unsigned_types;
#endif
- typedef mpl::list<double, long double> float_types;
+ typedef mpl::list<double, long double> float_types;
gmp_int()
{
}
gmp_int(const gmp_int& o)
{
- if(o.m_data[0]._mp_d)
+ if (o.m_data[0]._mp_d)
mpz_init_set(m_data, o.m_data);
else
mpz_init(this->m_data);
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
gmp_int(gmp_int&& o) BOOST_NOEXCEPT
{
- m_data[0] = o.m_data[0];
+ m_data[0] = o.m_data[0];
o.m_data[0]._mp_d = 0;
}
#endif
mpz_set_f(this->m_data, o.data());
}
explicit gmp_int(const gmp_rational& o);
- gmp_int& operator = (const gmp_int& o)
+ gmp_int& operator=(const gmp_int& o)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set(m_data, o.m_data);
return *this;
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- gmp_int& operator = (gmp_int&& o) BOOST_NOEXCEPT
+ gmp_int& operator=(gmp_int&& o) BOOST_NOEXCEPT
{
mpz_swap(m_data, o.m_data);
return *this;
#endif
#ifdef BOOST_HAS_LONG_LONG
#if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX)
- gmp_int& operator = (boost::ulong_long_type i)
+ gmp_int& operator=(boost::ulong_long_type i)
{
*this = static_cast<unsigned long>(i);
return *this;
}
#else
- gmp_int& operator = (boost::ulong_long_type i)
+ gmp_int& operator=(boost::ulong_long_type i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
- boost::ulong_long_type mask = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
- unsigned shift = 0;
- mpz_t t;
+ boost::ulong_long_type mask = ((((1uLL << (std::numeric_limits<unsigned long>::digits - 1)) - 1) << 1) | 1uLL);
+ unsigned shift = 0;
+ mpz_t t;
mpz_set_ui(m_data, 0);
mpz_init_set_ui(t, 0);
- while(i)
+ while (i)
{
mpz_set_ui(t, static_cast<unsigned long>(i & mask));
- if(shift)
+ if (shift)
mpz_mul_2exp(t, t, shift);
mpz_add(m_data, m_data, t);
shift += std::numeric_limits<unsigned long>::digits;
return *this;
}
#endif
- gmp_int& operator = (boost::long_long_type i)
+ gmp_int& operator=(boost::long_long_type i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
bool neg = i < 0;
- *this = boost::multiprecision::detail::unsigned_abs(i);
- if(neg)
+ *this = boost::multiprecision::detail::unsigned_abs(i);
+ if (neg)
mpz_neg(m_data, m_data);
return *this;
}
#endif
- gmp_int& operator = (unsigned long i)
+ gmp_int& operator=(unsigned long i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_ui(m_data, i);
return *this;
}
- gmp_int& operator = (long i)
+ gmp_int& operator=(long i)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_si(m_data, i);
return *this;
}
- gmp_int& operator = (double d)
+ gmp_int& operator=(double d)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_d(m_data, d);
return *this;
}
- gmp_int& operator = (long double a)
+ gmp_int& operator=(long double a)
{
+ using std::floor;
using std::frexp;
using std::ldexp;
- using std::floor;
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
- if (a == 0) {
+ if (a == 0)
+ {
mpz_set_si(m_data, 0);
return *this;
}
- if (a == 1) {
+ if (a == 1)
+ {
mpz_set_si(m_data, 1);
return *this;
}
BOOST_ASSERT(!(boost::math::isinf)(a));
BOOST_ASSERT(!(boost::math::isnan)(a));
- int e;
+ int e;
long double f, term;
mpz_set_ui(m_data, 0u);
static const int shift = std::numeric_limits<int>::digits - 1;
- while(f)
+ while (f)
{
// extract int sized bits from f:
- f = ldexp(f, shift);
+ f = ldexp(f, shift);
term = floor(f);
e -= shift;
mpz_mul_2exp(m_data, m_data, shift);
- if(term > 0)
+ if (term > 0)
mpz_add_ui(m_data, m_data, static_cast<unsigned>(term));
else
mpz_sub_ui(m_data, m_data, static_cast<unsigned>(-term));
f -= term;
}
- if(e > 0)
+ if (e > 0)
mpz_mul_2exp(m_data, m_data, e);
- else if(e < 0)
+ else if (e < 0)
mpz_div_2exp(m_data, m_data, -e);
return *this;
}
- gmp_int& operator = (const char* s)
+ gmp_int& operator=(const char* s)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
- std::size_t n = s ? std::strlen(s) : 0;
- int radix = 10;
- if(n && (*s == '0'))
+ std::size_t n = s ? std::strlen(s) : 0;
+ int radix = 10;
+ if (n && (*s == '0'))
{
- if((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
+ if ((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
{
radix = 16;
- s +=2;
+ s += 2;
n -= 2;
}
else
n -= 1;
}
}
- if(n)
+ if (n)
{
- if(0 != mpz_set_str(m_data, s, radix))
+ if (0 != mpz_set_str(m_data, s, radix))
BOOST_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid integer.")));
}
else
}
gmp_int& operator=(const mpf_t val)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_f(this->m_data, val);
return *this;
}
gmp_int& operator=(const mpz_t val)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set(this->m_data, val);
return *this;
}
gmp_int& operator=(const mpq_t val)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_q(this->m_data, val);
return *this;
template <unsigned Digits10>
gmp_int& operator=(const gmp_float<Digits10>& o)
{
- if(m_data[0]._mp_d == 0)
+ if (m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_f(this->m_data, o.data());
return *this;
}
gmp_int& operator=(const gmp_rational& o);
- void swap(gmp_int& o)
+ void swap(gmp_int& o)
{
mpz_swap(m_data, o.m_data);
}
- std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f)const
+ std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f) const
{
BOOST_ASSERT(m_data[0]._mp_d);
int base = 10;
- if((f & std::ios_base::oct) == std::ios_base::oct)
+ if ((f & std::ios_base::oct) == std::ios_base::oct)
base = 8;
- else if((f & std::ios_base::hex) == std::ios_base::hex)
+ else if ((f & std::ios_base::hex) == std::ios_base::hex)
base = 16;
//
// sanity check, bases 8 and 16 are only available for positive numbers:
//
- if((base != 10) && (mpz_sgn(m_data) < 0))
+ if ((base != 10) && (mpz_sgn(m_data) < 0))
BOOST_THROW_EXCEPTION(std::runtime_error("Formatted output in bases 8 or 16 is only available for positive numbers"));
- void *(*alloc_func_ptr) (size_t);
- void *(*realloc_func_ptr) (void *, size_t, size_t);
- void (*free_func_ptr) (void *, size_t);
- const char* ps = mpz_get_str (0, base, m_data);
- std::string s = ps;
+ void* (*alloc_func_ptr)(size_t);
+ void* (*realloc_func_ptr)(void*, size_t, size_t);
+ void (*free_func_ptr)(void*, size_t);
+ const char* ps = mpz_get_str(0, base, m_data);
+ std::string s = ps;
mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
-
- if((base != 10) && (f & std::ios_base::showbase))
+ if (f & std::ios_base::uppercase)
+ for (size_t i = 0; i < s.length(); ++i)
+ s[i] = std::toupper(s[i]);
+ if ((base != 10) && (f & std::ios_base::showbase))
{
- int pos = s[0] == '-' ? 1 : 0;
- const char* pp = base == 8 ? "0" : "0x";
+ int pos = s[0] == '-' ? 1 : 0;
+ const char* pp = base == 8 ? "0" : (f & std::ios_base::uppercase) ? "0X" : "0x";
s.insert(static_cast<std::string::size_type>(pos), pp);
}
- if((f & std::ios_base::showpos) && (s[0] != '-'))
+ if ((f & std::ios_base::showpos) && (s[0] != '-'))
s.insert(static_cast<std::string::size_type>(0), 1, '+');
return s;
}
~gmp_int() BOOST_NOEXCEPT
{
- if(m_data[0]._mp_d)
+ if (m_data[0]._mp_d)
mpz_clear(m_data);
}
void negate() BOOST_NOEXCEPT
BOOST_ASSERT(m_data[0]._mp_d);
mpz_neg(m_data, m_data);
}
- int compare(const gmp_int& o)const BOOST_NOEXCEPT
+ int compare(const gmp_int& o) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d && o.m_data[0]._mp_d);
return mpz_cmp(m_data, o.m_data);
}
- int compare(long i)const BOOST_NOEXCEPT
+ int compare(long i) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d);
return mpz_cmp_si(m_data, i);
}
- int compare(unsigned long i)const BOOST_NOEXCEPT
+ int compare(unsigned long i) const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d);
return mpz_cmp_ui(m_data, i);
}
template <class V>
- int compare(V v)const
+ int compare(V v) const
{
gmp_int d;
d = v;
BOOST_ASSERT(m_data[0]._mp_d);
return m_data;
}
- const mpz_t& data()const BOOST_NOEXCEPT
+ const mpz_t& data() const BOOST_NOEXCEPT
{
BOOST_ASSERT(m_data[0]._mp_d);
return m_data;
}
-protected:
+
+ protected:
mpz_t m_data;
};
}
inline void eval_divide(gmp_int& t, const gmp_int& o)
{
- if(eval_is_zero(o))
+ if (eval_is_zero(o))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpz_tdiv_q(t.data(), t.data(), o.data());
}
}
inline void eval_divide(gmp_int& t, unsigned long i)
{
- if(i == 0)
+ if (i == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpz_tdiv_q_ui(t.data(), t.data(), i);
}
inline void eval_add(gmp_int& t, long i)
{
- if(i > 0)
+ if (i > 0)
mpz_add_ui(t.data(), t.data(), i);
else
mpz_sub_ui(t.data(), t.data(), boost::multiprecision::detail::unsigned_abs(i));
}
inline void eval_multiply_add(gmp_int& t, const gmp_int& a, long i)
{
- if(i > 0)
+ if (i > 0)
mpz_addmul_ui(t.data(), a.data(), i);
else
mpz_submul_ui(t.data(), a.data(), boost::multiprecision::detail::unsigned_abs(i));
}
inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, long i)
{
- if(i > 0)
+ if (i > 0)
mpz_submul_ui(t.data(), a.data(), i);
else
mpz_addmul_ui(t.data(), a.data(), boost::multiprecision::detail::unsigned_abs(i));
}
inline void eval_subtract(gmp_int& t, long i)
{
- if(i > 0)
+ if (i > 0)
mpz_sub_ui(t.data(), t.data(), i);
else
mpz_add_ui(t.data(), t.data(), boost::multiprecision::detail::unsigned_abs(i));
inline void eval_multiply(gmp_int& t, long i)
{
mpz_mul_ui(t.data(), t.data(), boost::multiprecision::detail::unsigned_abs(i));
- if(i < 0)
+ if (i < 0)
mpz_neg(t.data(), t.data());
}
inline void eval_modulus(gmp_int& t, long i)
}
inline void eval_divide(gmp_int& t, long i)
{
- if(i == 0)
+ if (i == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpz_tdiv_q_ui(t.data(), t.data(), boost::multiprecision::detail::unsigned_abs(i));
- if(i < 0)
+ if (i < 0)
mpz_neg(t.data(), t.data());
}
template <class UI>
}
inline void eval_divide(gmp_int& t, const gmp_int& p, const gmp_int& o)
{
- if(eval_is_zero(o))
+ if (eval_is_zero(o))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpz_tdiv_q(t.data(), p.data(), o.data());
}
}
inline void eval_divide(gmp_int& t, const gmp_int& p, unsigned long i)
{
- if(i == 0)
+ if (i == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpz_tdiv_q_ui(t.data(), p.data(), i);
}
inline void eval_add(gmp_int& t, const gmp_int& p, long i)
{
- if(i > 0)
+ if (i > 0)
mpz_add_ui(t.data(), p.data(), i);
else
mpz_sub_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
}
inline void eval_subtract(gmp_int& t, const gmp_int& p, long i)
{
- if(i > 0)
+ if (i > 0)
mpz_sub_ui(t.data(), p.data(), i);
else
mpz_add_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
inline void eval_multiply(gmp_int& t, const gmp_int& p, long i)
{
mpz_mul_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
- if(i < 0)
+ if (i < 0)
mpz_neg(t.data(), t.data());
}
inline void eval_modulus(gmp_int& t, const gmp_int& p, long i)
}
inline void eval_divide(gmp_int& t, const gmp_int& p, long i)
{
- if(i == 0)
+ if (i == 0)
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpz_tdiv_q_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i));
- if(i < 0)
+ if (i < 0)
mpz_neg(t.data(), t.data());
}
{
BOOST_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour"));
}
- else if(0 == mpz_fits_ulong_p(val.data()))
- {
- *result = (std::numeric_limits<unsigned long>::max)();
- }
else
*result = (unsigned long)mpz_get_ui(val.data());
}
inline void eval_convert_to(long* result, const gmp_int& val)
{
- if(0 == mpz_fits_slong_p(val.data()))
+ if (0 == mpz_fits_slong_p(val.data()))
{
- *result = mpz_sgn(val.data()) < 0 ? (std::numeric_limits<long>::min)() : (std::numeric_limits<long>::max)();
+ *result = mpz_sgn(val.data()) < 0 ? (std::numeric_limits<long>::min)() : (std::numeric_limits<long>::max)();
}
else
*result = (signed long)mpz_get_si(val.data());
inline unsigned eval_lsb(const gmp_int& val)
{
int c = eval_get_sign(val);
- if(c == 0)
+ if (c == 0)
{
BOOST_THROW_EXCEPTION(std::range_error("No bits were set in the operand."));
}
- if(c < 0)
+ if (c < 0)
{
BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined."));
}
inline unsigned eval_msb(const gmp_int& val)
{
int c = eval_get_sign(val);
- if(c == 0)
+ if (c == 0)
{
BOOST_THROW_EXCEPTION(std::range_error("No bits were set in the operand."));
}
- if(c < 0)
+ if (c < 0)
{
BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined."));
}
}
inline void eval_qr(const gmp_int& x, const gmp_int& y,
- gmp_int& q, gmp_int& r)
+ gmp_int& q, gmp_int& r)
{
mpz_tdiv_qr(q.data(), r.data(), x.data(), y.data());
}
inline typename enable_if<is_unsigned<Integer>, Integer>::type eval_integer_modulus(const gmp_int& x, Integer val)
{
#if defined(__MPIR_VERSION) && (__MPIR_VERSION >= 3)
- if((sizeof(Integer) <= sizeof(mpir_ui)) || (val <= (std::numeric_limits<mpir_ui>::max)()))
+ if ((sizeof(Integer) <= sizeof(mpir_ui)) || (val <= (std::numeric_limits<mpir_ui>::max)()))
#else
- if((sizeof(Integer) <= sizeof(long)) || (val <= (std::numeric_limits<unsigned long>::max)()))
+ if ((sizeof(Integer) <= sizeof(long)) || (val <= (std::numeric_limits<unsigned long>::max)()))
#endif
{
return static_cast<Integer>(mpz_tdiv_ui(x.data(), val));
}
inline void eval_powm(gmp_int& result, const gmp_int& base, const gmp_int& p, const gmp_int& m)
{
- if(eval_get_sign(p) < 0)
+ if (eval_get_sign(p) < 0)
{
BOOST_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
}
template <class Integer>
inline typename enable_if<
- mpl::and_<
- is_unsigned<Integer>,
- mpl::bool_<sizeof(Integer) <= sizeof(unsigned long)>
- >
->::type eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m)
+ mpl::and_<
+ is_unsigned<Integer>,
+ mpl::bool_<sizeof(Integer) <= sizeof(unsigned long)> > >::type
+eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m)
{
mpz_powm_ui(result.data(), base.data(), p, m.data());
}
template <class Integer>
inline typename enable_if<
- mpl::and_<
- is_signed<Integer>,
- mpl::bool_<sizeof(Integer) <= sizeof(unsigned long)>
- >
->::type eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m)
+ mpl::and_<
+ is_signed<Integer>,
+ mpl::bool_<sizeof(Integer) <= sizeof(unsigned long)> > >::type
+eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m)
{
- if(p < 0)
+ if (p < 0)
{
BOOST_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
}
{
// We should really use mpz_limbs_read here, but that's unsupported on older versions:
std::size_t result = 0;
- for(int i = 0; i < std::abs(val.data()[0]._mp_size); ++i)
+ for (int i = 0; i < std::abs(val.data()[0]._mp_size); ++i)
boost::hash_combine(result, val.data()[0]._mp_d[i]);
boost::hash_combine(result, val.data()[0]._mp_size);
return result;
struct gmp_rational
{
#ifdef BOOST_HAS_LONG_LONG
- typedef mpl::list<long, boost::long_long_type> signed_types;
- typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
+ typedef mpl::list<long, boost::long_long_type> signed_types;
+ typedef mpl::list<unsigned long, boost::ulong_long_type> unsigned_types;
#else
- typedef mpl::list<long> signed_types;
- typedef mpl::list<unsigned long> unsigned_types;
+ typedef mpl::list<long> signed_types;
+ typedef mpl::list<unsigned long> unsigned_types;
#endif
- typedef mpl::list<double, long double> float_types;
+ typedef mpl::list<double, long double> float_types;
gmp_rational()
{
gmp_rational(const gmp_rational& o)
{
mpq_init(m_data);
- if(o.m_data[0]._mp_num._mp_d)
+ if (o.m_data[0]._mp_num._mp_d)
mpq_set(m_data, o.m_data);
}
gmp_rational(const gmp_int& o)
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
gmp_rational(gmp_rational&& o) BOOST_NOEXCEPT
{
- m_data[0] = o.m_data[0];
+ m_data[0] = o.m_data[0];
o.m_data[0]._mp_num._mp_d = 0;
o.m_data[0]._mp_den._mp_d = 0;
}
mpq_init(m_data);
mpq_set_z(m_data, o);
}
- gmp_rational& operator = (const gmp_rational& o)
+ gmp_rational& operator=(const gmp_rational& o)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set(m_data, o.m_data);
return *this;
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
- gmp_rational& operator = (gmp_rational&& o) BOOST_NOEXCEPT
+ gmp_rational& operator=(gmp_rational&& o) BOOST_NOEXCEPT
{
mpq_swap(m_data, o.m_data);
return *this;
#endif
#ifdef BOOST_HAS_LONG_LONG
#if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX)
- gmp_rational& operator = (boost::ulong_long_type i)
+ gmp_rational& operator=(boost::ulong_long_type i)
{
*this = static_cast<unsigned long>(i);
return *this;
}
#else
- gmp_rational& operator = (boost::ulong_long_type i)
+ gmp_rational& operator=(boost::ulong_long_type i)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
gmp_int zi;
zi = i;
mpq_set_z(m_data, zi.data());
return *this;
}
- gmp_rational& operator = (boost::long_long_type i)
+ gmp_rational& operator=(boost::long_long_type i)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
bool neg = i < 0;
- *this = boost::multiprecision::detail::unsigned_abs(i);
- if(neg)
+ *this = boost::multiprecision::detail::unsigned_abs(i);
+ if (neg)
mpq_neg(m_data, m_data);
return *this;
}
#endif
#endif
- gmp_rational& operator = (unsigned long i)
+ gmp_rational& operator=(unsigned long i)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set_ui(m_data, i, 1);
return *this;
}
- gmp_rational& operator = (long i)
+ gmp_rational& operator=(long i)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set_si(m_data, i, 1);
return *this;
}
- gmp_rational& operator = (double d)
+ gmp_rational& operator=(double d)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set_d(m_data, d);
return *this;
}
- gmp_rational& operator = (long double a)
+ gmp_rational& operator=(long double a)
{
- using std::frexp;
- using std::ldexp;
- using std::floor;
using default_ops::eval_add;
using default_ops::eval_subtract;
+ using std::floor;
+ using std::frexp;
+ using std::ldexp;
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
- if (a == 0) {
+ if (a == 0)
+ {
mpq_set_si(m_data, 0, 1);
return *this;
}
- if (a == 1) {
+ if (a == 1)
+ {
mpq_set_si(m_data, 1, 1);
return *this;
}
BOOST_ASSERT(!(boost::math::isinf)(a));
BOOST_ASSERT(!(boost::math::isnan)(a));
- int e;
+ int e;
long double f, term;
mpq_set_ui(m_data, 0, 1);
mpq_set_ui(m_data, 0u, 1);
static const int shift = std::numeric_limits<int>::digits - 1;
- while(f)
+ while (f)
{
// extract int sized bits from f:
- f = ldexp(f, shift);
+ f = ldexp(f, shift);
term = floor(f);
e -= shift;
mpq_mul_2exp(m_data, m_data, shift);
eval_add(*this, t);
f -= term;
}
- if(e > 0)
+ if (e > 0)
mpq_mul_2exp(m_data, m_data, e);
- else if(e < 0)
+ else if (e < 0)
mpq_div_2exp(m_data, m_data, -e);
return *this;
}
- gmp_rational& operator = (const char* s)
+ gmp_rational& operator=(const char* s)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
- if(0 != mpq_set_str(m_data, s, 10))
+ if (0 != mpq_set_str(m_data, s, 10))
BOOST_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid rational number.")));
return *this;
}
gmp_rational& operator=(const gmp_int& o)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set_z(m_data, o.data());
return *this;
}
gmp_rational& operator=(const mpq_t o)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set(m_data, o);
return *this;
}
gmp_rational& operator=(const mpz_t o)
{
- if(m_data[0]._mp_den._mp_d == 0)
+ if (m_data[0]._mp_den._mp_d == 0)
mpq_init(m_data);
mpq_set_z(m_data, o);
return *this;
{
mpq_swap(m_data, o.m_data);
}
- std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags /*f*/)const
+ std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags /*f*/) const
{
BOOST_ASSERT(m_data[0]._mp_num._mp_d);
// TODO make a better job of this including handling of f!!
- void *(*alloc_func_ptr) (size_t);
- void *(*realloc_func_ptr) (void *, size_t, size_t);
- void (*free_func_ptr) (void *, size_t);
- const char* ps = mpq_get_str (0, 10, m_data);
- std::string s = ps;
+ void* (*alloc_func_ptr)(size_t);
+ void* (*realloc_func_ptr)(void*, size_t, size_t);
+ void (*free_func_ptr)(void*, size_t);
+ const char* ps = mpq_get_str(0, 10, m_data);
+ std::string s = ps;
mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);
return s;
}
~gmp_rational()
{
- if(m_data[0]._mp_num._mp_d || m_data[0]._mp_den._mp_d)
+ if (m_data[0]._mp_num._mp_d || m_data[0]._mp_den._mp_d)
mpq_clear(m_data);
}
void negate()
BOOST_ASSERT(m_data[0]._mp_num._mp_d);
mpq_neg(m_data, m_data);
}
- int compare(const gmp_rational& o)const
+ int compare(const gmp_rational& o) const
{
BOOST_ASSERT(m_data[0]._mp_num._mp_d && o.m_data[0]._mp_num._mp_d);
return mpq_cmp(m_data, o.m_data);
}
template <class V>
- int compare(V v)const
+ int compare(V v) const
{
gmp_rational d;
d = v;
return compare(d);
}
- int compare(unsigned long v)const
+ int compare(unsigned long v) const
{
BOOST_ASSERT(m_data[0]._mp_num._mp_d);
return mpq_cmp_ui(m_data, v, 1);
}
- int compare(long v)const
+ int compare(long v) const
{
BOOST_ASSERT(m_data[0]._mp_num._mp_d);
return mpq_cmp_si(m_data, v, 1);
BOOST_ASSERT(m_data[0]._mp_num._mp_d);
return m_data;
}
- const mpq_t& data()const
+ const mpq_t& data() const
{
BOOST_ASSERT(m_data[0]._mp_num._mp_d);
return m_data;
}
-protected:
+
+ protected:
mpq_t m_data;
};
}
inline void eval_divide(gmp_rational& t, const gmp_rational& o)
{
- if(eval_is_zero(o))
+ if (eval_is_zero(o))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpq_div(t.data(), t.data(), o.data());
}
}
inline void eval_divide(gmp_rational& t, const gmp_rational& p, const gmp_rational& o)
{
- if(eval_is_zero(o))
+ if (eval_is_zero(o))
BOOST_THROW_EXCEPTION(std::overflow_error("Division by zero."));
mpq_div(t.data(), p.data(), o.data());
}
inline std::size_t hash_value(const gmp_rational& val)
{
std::size_t result = 0;
- for(int i = 0; i < std::abs(val.data()[0]._mp_num._mp_size); ++i)
+ for (int i = 0; i < std::abs(val.data()[0]._mp_num._mp_size); ++i)
boost::hash_combine(result, val.data()[0]._mp_num._mp_d[i]);
- for(int i = 0; i < std::abs(val.data()[0]._mp_den._mp_size); ++i)
+ for (int i = 0; i < std::abs(val.data()[0]._mp_den._mp_size); ++i)
boost::hash_combine(result, val.data()[0]._mp_den._mp_d[i]);
boost::hash_combine(result, val.data()[0]._mp_num._mp_size);
return result;
template <unsigned D>
inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_float<D>& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : this->get_default_precision()));
mpf_set(this->m_data, o.data());
return *this;
template <unsigned Digits10>
inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_int& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : this->get_default_precision()));
mpf_set_z(this->data(), o.data());
return *this;
template <unsigned Digits10>
inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_rational& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : this->get_default_precision()));
mpf_set_q(this->data(), o.data());
return *this;
}
inline gmp_float<0>& gmp_float<0>::operator=(const gmp_int& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(this->get_default_precision()));
mpf_set_z(this->data(), o.data());
return *this;
}
inline gmp_float<0>& gmp_float<0>::operator=(const gmp_rational& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(this->get_default_precision()));
mpf_set_q(this->data(), o.data());
return *this;
}
inline gmp_int& gmp_int::operator=(const gmp_rational& o)
{
- if(this->m_data[0]._mp_d == 0)
+ if (this->m_data[0]._mp_d == 0)
mpz_init(this->m_data);
mpz_set_q(this->m_data, o.data());
return *this;
} //namespace backends
+using boost::multiprecision::backends::gmp_float;
using boost::multiprecision::backends::gmp_int;
using boost::multiprecision::backends::gmp_rational;
-using boost::multiprecision::backends::gmp_float;
-template <>
-struct component_type<number<gmp_rational> >
+template <expression_template_option ExpressionTemplates>
+struct component_type<number<gmp_rational, ExpressionTemplates> >
{
- typedef number<gmp_int> type;
+ typedef number<gmp_int, ExpressionTemplates> type;
};
template <expression_template_option ET>
return result;
}
-namespace detail{
+namespace detail {
#ifdef BOOST_NO_SFINAE_EXPR
-template<>
-struct is_explicitly_convertible<canonical<mpf_t, gmp_int>::type, gmp_int> : public mpl::true_ {};
-template<>
-struct is_explicitly_convertible<canonical<mpq_t, gmp_int>::type, gmp_int> : public mpl::true_ {};
-template<unsigned Digits10>
-struct is_explicitly_convertible<gmp_float<Digits10>, gmp_int> : public mpl::true_ {};
-template<>
-struct is_explicitly_convertible<gmp_rational, gmp_int> : public mpl::true_ {};
-template<unsigned D1, unsigned D2>
-struct is_explicitly_convertible<gmp_float<D1>, gmp_float<D2> > : public mpl::true_ {};
+template <>
+struct is_explicitly_convertible<canonical<mpf_t, gmp_int>::type, gmp_int> : public mpl::true_
+{};
+template <>
+struct is_explicitly_convertible<canonical<mpq_t, gmp_int>::type, gmp_int> : public mpl::true_
+{};
+template <unsigned Digits10>
+struct is_explicitly_convertible<gmp_float<Digits10>, gmp_int> : public mpl::true_
+{};
+template <>
+struct is_explicitly_convertible<gmp_rational, gmp_int> : public mpl::true_
+{};
+template <unsigned D1, unsigned D2>
+struct is_explicitly_convertible<gmp_float<D1>, gmp_float<D2> > : public mpl::true_
+{};
#endif
{
static long value()
{
- return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
+ return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
}
};
{
static long value()
{
- return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
+ return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
}
};
{
static long value()
{
- return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
+ return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
}
};
{
static long value()
{
- return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
+ return multiprecision::detail::digits10_2_2(gmp_float<0>::default_precision());
}
};
-}
+} // namespace detail
-template<>
-struct number_category<detail::canonical<mpz_t, gmp_int>::type> : public mpl::int_<number_kind_integer>{};
-template<>
-struct number_category<detail::canonical<mpq_t, gmp_rational>::type> : public mpl::int_<number_kind_rational>{};
-template<>
-struct number_category<detail::canonical<mpf_t, gmp_float<0> >::type> : public mpl::int_<number_kind_floating_point>{};
+template <>
+struct number_category<detail::canonical<mpz_t, gmp_int>::type> : public mpl::int_<number_kind_integer>
+{};
+template <>
+struct number_category<detail::canonical<mpq_t, gmp_rational>::type> : public mpl::int_<number_kind_rational>
+{};
+template <>
+struct number_category<detail::canonical<mpf_t, gmp_float<0> >::type> : public mpl::int_<number_kind_floating_point>
+{};
+namespace detail {
+template <>
+struct is_variable_precision<backends::gmp_float<0> > : public true_type
+{};
+} // namespace detail
-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;
-typedef number<gmp_int > mpz_int;
-typedef number<gmp_rational > mpq_rational;
+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;
+typedef number<gmp_int> mpz_int;
+typedef number<gmp_rational> mpq_rational;
-} // namespace multiprecision
+} // namespace multiprecision
-namespace math { namespace tools{
+namespace math { namespace tools {
- template <>
- inline int digits<boost::multiprecision::mpf_float>()
+template <>
+inline int digits<boost::multiprecision::mpf_float>()
#ifdef BOOST_MATH_NOEXCEPT
- BOOST_NOEXCEPT
+ BOOST_NOEXCEPT
#endif
- {
- return multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::default_precision());
- }
- template <>
- inline int digits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
+{
+ return multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::default_precision());
+}
+template <>
+inline int digits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
- BOOST_NOEXCEPT
+ BOOST_NOEXCEPT
#endif
- {
- return multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::default_precision());
- }
+{
+ return multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::default_precision());
+}
- template <>
- inline boost::multiprecision::mpf_float
- max_value<boost::multiprecision::mpf_float>()
- {
- boost::multiprecision::mpf_float result(0.5);
- mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
- return result;
- }
+template <>
+inline boost::multiprecision::mpf_float
+max_value<boost::multiprecision::mpf_float>()
+{
+ boost::multiprecision::mpf_float result(0.5);
+ mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
+ return result;
+}
- template <>
- inline boost::multiprecision::mpf_float
- min_value<boost::multiprecision::mpf_float>()
- {
- boost::multiprecision::mpf_float result(0.5);
- mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::min)() / 64 + 1);
- return result;
- }
+template <>
+inline boost::multiprecision::mpf_float
+min_value<boost::multiprecision::mpf_float>()
+{
+ boost::multiprecision::mpf_float result(0.5);
+ mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::min)() / 64 + 1);
+ return result;
+}
- template <>
- inline boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>
- max_value<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
- {
- boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> result(0.5);
- mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
- return result;
- }
+template <>
+inline boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>
+max_value<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
+{
+ boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> result(0.5);
+ mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
+ return result;
+}
- template <>
- inline boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>
- min_value<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
- {
- boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> result(0.5);
- mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
- return result;
- }
+template <>
+inline boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off>
+min_value<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >()
+{
+ boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> result(0.5);
+ mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
+ return result;
+}
- template <>
- inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
+template <>
+inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
#ifdef BOOST_MATH_NOEXCEPT
- BOOST_NOEXCEPT
+ BOOST_NOEXCEPT
#endif
- {
- return multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::default_precision());
- }
- template <>
- inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
+{
+ return multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::default_precision());
+}
+template <>
+inline int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
#ifdef BOOST_MATH_NOEXCEPT
- BOOST_NOEXCEPT
+ BOOST_NOEXCEPT
#endif
- {
- return multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::default_precision());
- }
-
- template <>
- inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >
- max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
- {
- return max_value<boost::multiprecision::mpf_float>().backend();
- }
-
- template <>
- inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >
- min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
- {
- return min_value<boost::multiprecision::mpf_float>().backend();
- }
+{
+ return multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::default_precision());
+}
- template <>
- inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off>
- max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
- {
- return max_value<boost::multiprecision::mpf_float>().backend();
- }
+template <>
+inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >
+max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
+{
+ return max_value<boost::multiprecision::mpf_float>().backend();
+}
- template <>
- inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off>
- min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
- {
- return min_value<boost::multiprecision::mpf_float>().backend();
- }
+template <>
+inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >
+min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >()
+{
+ return min_value<boost::multiprecision::mpf_float>().backend();
+}
+template <>
+inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off>
+max_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
+{
+ return max_value<boost::multiprecision::mpf_float>().backend();
+}
-}} // namespaces math::tools
+template <>
+inline boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off>
+min_value<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::gmp_float<0> >, boost::multiprecision::et_off> >()
+{
+ return min_value<boost::multiprecision::mpf_float>().backend();
+}
+}} // namespace math::tools
-} // namespace boost
+} // namespace boost
-namespace std{
+namespace std {
//
// numeric_limits [partial] specializations for the types declared in this header:
//
-template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >
{
typedef boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> number_type;
-public:
+
+ public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
//
// min and max values chosen so as to not cause segfaults when calling
// mpf_get_str on 64-bit Linux builds. Possibly we could use larger
// exponent values elsewhere.
//
- static number_type (min)()
+ static number_type(min)()
{
initializer.do_nothing();
static std::pair<bool, number_type> value;
- if(!value.first)
+ if (!value.first)
{
- value.first = true;
+ value.first = true;
value.second = 1;
mpf_div_2exp(value.second.backend().data(), value.second.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
}
return value.second;
}
- static number_type (max)()
+ static number_type(max)()
{
initializer.do_nothing();
static std::pair<bool, number_type> value;
- if(!value.first)
+ if (!value.first)
{
- value.first = true;
+ value.first = true;
value.second = 1;
mpf_mul_2exp(value.second.backend().data(), value.second.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1);
}
{
return -(max)();
}
- BOOST_STATIC_CONSTEXPR int digits = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301L ? 2 : 1));
+ BOOST_STATIC_CONSTEXPR int digits = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301L ? 2 : 1));
BOOST_STATIC_CONSTEXPR int digits10 = Digits10;
// Have to allow for a possible extra limb inside the gmp data structure:
- BOOST_STATIC_CONSTEXPR int max_digits10 = Digits10 + 3 + ((GMP_LIMB_BITS * 301L) / 1000L);
- BOOST_STATIC_CONSTEXPR bool is_signed = true;
- BOOST_STATIC_CONSTEXPR bool is_integer = false;
- BOOST_STATIC_CONSTEXPR bool is_exact = false;
- BOOST_STATIC_CONSTEXPR int radix = 2;
- static number_type epsilon()
+ BOOST_STATIC_CONSTEXPR int max_digits10 = Digits10 + 3 + ((GMP_LIMB_BITS * 301L) / 1000L);
+ BOOST_STATIC_CONSTEXPR bool is_signed = true;
+ BOOST_STATIC_CONSTEXPR bool is_integer = false;
+ BOOST_STATIC_CONSTEXPR bool is_exact = false;
+ BOOST_STATIC_CONSTEXPR int radix = 2;
+ static number_type epsilon()
{
initializer.do_nothing();
static std::pair<bool, number_type> value;
- if(!value.first)
+ if (!value.first)
{
- value.first = true;
+ value.first = true;
value.second = 1;
mpf_div_2exp(value.second.backend().data(), value.second.backend().data(), std::numeric_limits<number_type>::digits - 1);
}
// returns epsilon/2
initializer.do_nothing();
static std::pair<bool, number_type> value;
- if(!value.first)
+ if (!value.first)
{
- value.first = true;
+ value.first = true;
value.second = 1;
}
return value.second;
}
- BOOST_STATIC_CONSTEXPR long min_exponent = LONG_MIN;
- BOOST_STATIC_CONSTEXPR long min_exponent10 = (LONG_MIN / 1000) * 301L;
- BOOST_STATIC_CONSTEXPR long max_exponent = LONG_MAX;
- BOOST_STATIC_CONSTEXPR long max_exponent10 = (LONG_MAX / 1000) * 301L;
- BOOST_STATIC_CONSTEXPR bool has_infinity = false;
- BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
- BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
- BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
- BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
+ BOOST_STATIC_CONSTEXPR long min_exponent = LONG_MIN;
+ BOOST_STATIC_CONSTEXPR long min_exponent10 = (LONG_MIN / 1000) * 301L;
+ BOOST_STATIC_CONSTEXPR long max_exponent = LONG_MAX;
+ BOOST_STATIC_CONSTEXPR long max_exponent10 = (LONG_MAX / 1000) * 301L;
+ BOOST_STATIC_CONSTEXPR bool has_infinity = false;
+ BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
+ BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
+ BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
+ BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
BOOST_STATIC_CONSTEXPR number_type infinity() { return number_type(); }
BOOST_STATIC_CONSTEXPR number_type quiet_NaN() { return number_type(); }
BOOST_STATIC_CONSTEXPR number_type signaling_NaN() { return number_type(); }
BOOST_STATIC_CONSTEXPR number_type denorm_min() { return number_type(); }
- BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
- BOOST_STATIC_CONSTEXPR bool is_bounded = true;
- BOOST_STATIC_CONSTEXPR bool is_modulo = false;
- BOOST_STATIC_CONSTEXPR bool traps = true;
- BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
+ BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
+ BOOST_STATIC_CONSTEXPR bool is_bounded = true;
+ BOOST_STATIC_CONSTEXPR bool is_modulo = false;
+ BOOST_STATIC_CONSTEXPR bool traps = true;
+ BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
BOOST_STATIC_CONSTEXPR float_round_style round_style = round_indeterminate;
-private:
+ private:
struct data_initializer
{
data_initializer()
(std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<digits10> > >::min)();
(std::numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<digits10> > >::max)();
}
- void do_nothing()const{}
+ void do_nothing() const {}
};
static const data_initializer initializer;
};
-template<unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
+template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates>
const typename numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::data_initializer numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::initializer;
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#endif
-template<boost::multiprecision::expression_template_option ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >
{
typedef boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> number_type;
-public:
+
+ public:
BOOST_STATIC_CONSTEXPR bool is_specialized = false;
- static number_type (min)() { return number_type(); }
- static number_type (max)() { return number_type(); }
- static number_type lowest() { return number_type(); }
- BOOST_STATIC_CONSTEXPR int digits = 0;
- BOOST_STATIC_CONSTEXPR int digits10 = 0;
- BOOST_STATIC_CONSTEXPR int max_digits10 = 0;
- BOOST_STATIC_CONSTEXPR bool is_signed = false;
- BOOST_STATIC_CONSTEXPR bool is_integer = false;
- BOOST_STATIC_CONSTEXPR bool is_exact = false;
- BOOST_STATIC_CONSTEXPR int radix = 0;
- static number_type epsilon() { return number_type(); }
- static number_type round_error() { return number_type(); }
- BOOST_STATIC_CONSTEXPR int min_exponent = 0;
- BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
- BOOST_STATIC_CONSTEXPR int max_exponent = 0;
- BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
- BOOST_STATIC_CONSTEXPR bool has_infinity = false;
- BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
- BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
- BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
- BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
- static number_type infinity() { return number_type(); }
- static number_type quiet_NaN() { return number_type(); }
- static number_type signaling_NaN() { return number_type(); }
- static number_type denorm_min() { return number_type(); }
- BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
- BOOST_STATIC_CONSTEXPR bool is_bounded = false;
- BOOST_STATIC_CONSTEXPR bool is_modulo = false;
- BOOST_STATIC_CONSTEXPR bool traps = false;
- BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
- BOOST_STATIC_CONSTEXPR float_round_style round_style = round_indeterminate;
+ static number_type(min)() { return number_type(); }
+ static number_type(max)() { return number_type(); }
+ static number_type lowest() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR int digits = 0;
+ BOOST_STATIC_CONSTEXPR int digits10 = 0;
+ BOOST_STATIC_CONSTEXPR int max_digits10 = 0;
+ BOOST_STATIC_CONSTEXPR bool is_signed = false;
+ BOOST_STATIC_CONSTEXPR bool is_integer = false;
+ BOOST_STATIC_CONSTEXPR bool is_exact = false;
+ BOOST_STATIC_CONSTEXPR int radix = 0;
+ static number_type epsilon() { return number_type(); }
+ static number_type round_error() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR int min_exponent = 0;
+ BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
+ BOOST_STATIC_CONSTEXPR int max_exponent = 0;
+ BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
+ BOOST_STATIC_CONSTEXPR bool has_infinity = false;
+ BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
+ BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
+ BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
+ BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
+ static number_type infinity() { return number_type(); }
+ static number_type quiet_NaN() { return number_type(); }
+ static number_type signaling_NaN() { return number_type(); }
+ static number_type denorm_min() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
+ BOOST_STATIC_CONSTEXPR bool is_bounded = false;
+ BOOST_STATIC_CONSTEXPR bool is_modulo = false;
+ BOOST_STATIC_CONSTEXPR bool traps = false;
+ BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
+ BOOST_STATIC_CONSTEXPR float_round_style round_style = round_indeterminate;
};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#endif
-template<boost::multiprecision::expression_template_option ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >
{
typedef boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> number_type;
-public:
+
+ public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
//
// Largest and smallest numbers are bounded only by available memory, set
// to zero:
//
- static number_type (min)()
+ static number_type(min)()
{
return number_type();
}
- static number_type (max)()
+ static number_type(max)()
{
return number_type();
}
- static number_type lowest() { return (min)(); }
- BOOST_STATIC_CONSTEXPR int digits = INT_MAX;
- BOOST_STATIC_CONSTEXPR int digits10 = (INT_MAX / 1000) * 301L;
- BOOST_STATIC_CONSTEXPR int max_digits10 = digits10 + 3;
- BOOST_STATIC_CONSTEXPR bool is_signed = true;
- BOOST_STATIC_CONSTEXPR bool is_integer = true;
- BOOST_STATIC_CONSTEXPR bool is_exact = true;
- BOOST_STATIC_CONSTEXPR int radix = 2;
- static number_type epsilon() { return number_type(); }
- static number_type round_error() { return number_type(); }
- BOOST_STATIC_CONSTEXPR int min_exponent = 0;
- BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
- BOOST_STATIC_CONSTEXPR int max_exponent = 0;
- BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
- BOOST_STATIC_CONSTEXPR bool has_infinity = false;
- BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
- BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
- BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
- BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
- static number_type infinity() { return number_type(); }
- static number_type quiet_NaN() { return number_type(); }
- static number_type signaling_NaN() { return number_type(); }
- static number_type denorm_min() { return number_type(); }
- BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
- BOOST_STATIC_CONSTEXPR bool is_bounded = false;
- BOOST_STATIC_CONSTEXPR bool is_modulo = false;
- BOOST_STATIC_CONSTEXPR bool traps = false;
- BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
- BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
+ static number_type lowest() { return (min)(); }
+ BOOST_STATIC_CONSTEXPR int digits = INT_MAX;
+ BOOST_STATIC_CONSTEXPR int digits10 = (INT_MAX / 1000) * 301L;
+ BOOST_STATIC_CONSTEXPR int max_digits10 = digits10 + 3;
+ BOOST_STATIC_CONSTEXPR bool is_signed = true;
+ BOOST_STATIC_CONSTEXPR bool is_integer = true;
+ BOOST_STATIC_CONSTEXPR bool is_exact = true;
+ BOOST_STATIC_CONSTEXPR int radix = 2;
+ static number_type epsilon() { return number_type(); }
+ static number_type round_error() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR int min_exponent = 0;
+ BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
+ BOOST_STATIC_CONSTEXPR int max_exponent = 0;
+ BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
+ BOOST_STATIC_CONSTEXPR bool has_infinity = false;
+ BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
+ BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
+ BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
+ BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
+ static number_type infinity() { return number_type(); }
+ static number_type quiet_NaN() { return number_type(); }
+ static number_type signaling_NaN() { return number_type(); }
+ static number_type denorm_min() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
+ BOOST_STATIC_CONSTEXPR bool is_bounded = false;
+ BOOST_STATIC_CONSTEXPR bool is_modulo = false;
+ BOOST_STATIC_CONSTEXPR bool traps = false;
+ BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
+ BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#endif
-template<boost::multiprecision::expression_template_option ExpressionTemplates>
+template <boost::multiprecision::expression_template_option ExpressionTemplates>
class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >
{
typedef boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> number_type;
-public:
+
+ public:
BOOST_STATIC_CONSTEXPR bool is_specialized = true;
//
// Largest and smallest numbers are bounded only by available memory, set
// to zero:
//
- static number_type (min)()
+ static number_type(min)()
{
return number_type();
}
- static number_type (max)()
+ static number_type(max)()
{
return number_type();
}
static number_type lowest() { return (min)(); }
// Digits are unbounded, use zero for now:
- BOOST_STATIC_CONSTEXPR int digits = INT_MAX;
- BOOST_STATIC_CONSTEXPR int digits10 = (INT_MAX / 1000) * 301L;
- BOOST_STATIC_CONSTEXPR int max_digits10 = digits10 + 3;
- BOOST_STATIC_CONSTEXPR bool is_signed = true;
- BOOST_STATIC_CONSTEXPR bool is_integer = false;
- BOOST_STATIC_CONSTEXPR bool is_exact = true;
- BOOST_STATIC_CONSTEXPR int radix = 2;
- static number_type epsilon() { return number_type(); }
- static number_type round_error() { return number_type(); }
- BOOST_STATIC_CONSTEXPR int min_exponent = 0;
- BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
- BOOST_STATIC_CONSTEXPR int max_exponent = 0;
- BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
- BOOST_STATIC_CONSTEXPR bool has_infinity = false;
- BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
- BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
- BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
- BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
- static number_type infinity() { return number_type(); }
- static number_type quiet_NaN() { return number_type(); }
- static number_type signaling_NaN() { return number_type(); }
- static number_type denorm_min() { return number_type(); }
- BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
- BOOST_STATIC_CONSTEXPR bool is_bounded = false;
- BOOST_STATIC_CONSTEXPR bool is_modulo = false;
- BOOST_STATIC_CONSTEXPR bool traps = false;
- BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
- BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
+ BOOST_STATIC_CONSTEXPR int digits = INT_MAX;
+ BOOST_STATIC_CONSTEXPR int digits10 = (INT_MAX / 1000) * 301L;
+ BOOST_STATIC_CONSTEXPR int max_digits10 = digits10 + 3;
+ BOOST_STATIC_CONSTEXPR bool is_signed = true;
+ BOOST_STATIC_CONSTEXPR bool is_integer = false;
+ BOOST_STATIC_CONSTEXPR bool is_exact = true;
+ BOOST_STATIC_CONSTEXPR int radix = 2;
+ static number_type epsilon() { return number_type(); }
+ static number_type round_error() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR int min_exponent = 0;
+ BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
+ BOOST_STATIC_CONSTEXPR int max_exponent = 0;
+ BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
+ BOOST_STATIC_CONSTEXPR bool has_infinity = false;
+ BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
+ BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
+ BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
+ BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
+ static number_type infinity() { return number_type(); }
+ static number_type quiet_NaN() { return number_type(); }
+ static number_type signaling_NaN() { return number_type(); }
+ static number_type denorm_min() { return number_type(); }
+ BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
+ BOOST_STATIC_CONSTEXPR bool is_bounded = false;
+ BOOST_STATIC_CONSTEXPR bool is_modulo = false;
+ BOOST_STATIC_CONSTEXPR bool traps = false;
+ BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
+ BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
projects / ceph.git / blobdiff