boost/multiprecision/gmp.hpp
/////////////////////////////////////////////////////////////////////////////// // Copyright 2011 John Maddock. // Copyright 2021 Matt Borland. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_MP_GMP_HPP #define BOOST_MP_GMP_HPP #include <boost/multiprecision/detail/standalone_config.hpp> #include <boost/multiprecision/number.hpp> #include <boost/multiprecision/debug_adaptor.hpp> #include <boost/multiprecision/detail/integer_ops.hpp> #include <boost/multiprecision/detail/float128_functions.hpp> #include <boost/multiprecision/detail/digits.hpp> #include <boost/multiprecision/detail/atomic.hpp> #include <boost/multiprecision/detail/hash.hpp> #include <boost/multiprecision/detail/no_exceptions_support.hpp> #include <boost/multiprecision/detail/assert.hpp> #include <boost/multiprecision/detail/fpclassify.hpp> #include <boost/multiprecision/detail/string_helpers.hpp> #include <algorithm> #include <cctype> #include <cfloat> #include <climits> #include <clocale> #include <cmath> #include <cstdint> #include <cstdlib> #include <cstring> #include <iomanip> #include <iostream> #include <limits> #include <memory> #include <type_traits> #include <utility> // // Some includes we need from Boost.Math, since we rely on that library to provide these functions: // #ifdef BOOST_MP_MATH_AVAILABLE #include <boost/math/special_functions/asinh.hpp> #include <boost/math/special_functions/acosh.hpp> #include <boost/math/special_functions/atanh.hpp> #include <boost/math/special_functions/cbrt.hpp> #include <boost/math/special_functions/expm1.hpp> #include <boost/math/special_functions/gamma.hpp> #endif #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 4127) #endif #include <gmp.h> #ifdef BOOST_MSVC #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) #else #define BOOST_MP_MPIR_VERSION 0 #endif namespace boost { namespace multiprecision { namespace backends { #ifdef BOOST_MSVC // warning C4127: conditional expression is constant #pragma warning(push) //#pragma warning(disable : 4127) #endif template <unsigned digits10> struct gmp_float; struct gmp_int; struct gmp_rational; } // namespace backends template <> struct number_category<backends::gmp_int> : public std::integral_constant<int, number_kind_integer> {}; template <> struct number_category<backends::gmp_rational> : public std::integral_constant<int, number_kind_rational> {}; template <unsigned digits10> struct number_category<backends::gmp_float<digits10> > : public std::integral_constant<int, number_kind_floating_point> {}; 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 { template <unsigned digits10> struct gmp_float_imp { #ifdef BOOST_HAS_LONG_LONG using signed_types = std::tuple<long, long long> ; using unsigned_types = std::tuple<unsigned long, unsigned long long>; #else using signed_types = std::tuple<long> ; using unsigned_types = std::tuple<unsigned long>; #endif using float_types = std::tuple<double, long double>; using exponent_type = long ; gmp_float_imp() noexcept { m_data[0]._mp_d = nullptr; // uninitialized m_data m_data[0]._mp_prec = 1; } gmp_float_imp(const gmp_float_imp& o) { // // We have to do an init followed by a set here, otherwise *this may be at // a lower precision than o: seems like mpf_init_set copies just enough bits // to get the right value, but if it's then used in further calculations // things go badly wrong!! // mpf_init2(m_data, preserve_source_precision() ? mpf_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision())); if (o.m_data[0]._mp_d) mpf_set(m_data, o.m_data); } // rvalue copy gmp_float_imp(gmp_float_imp&& o) noexcept { if ((this->get_default_options() == variable_precision_options::preserve_target_precision) && (mpf_get_prec(o.data()) != boost::multiprecision::detail::digits10_2_2(get_default_precision()))) { mpf_init2(m_data, boost::multiprecision::detail::digits10_2_2(get_default_precision())); *this = static_cast<const gmp_float_imp&>(o); } else { m_data[0] = o.m_data[0]; o.m_data[0]._mp_d = nullptr; } } gmp_float_imp& operator=(const gmp_float_imp& o) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, preserve_source_precision() ? mpf_get_prec(o.data()) : boost::multiprecision::detail::digits10_2_2(get_default_precision())); mpf_set(m_data, o.m_data); } else if (preserve_source_precision() && (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 { mpf_set(m_data, o.m_data); } return *this; } // rvalue assign gmp_float_imp& operator=(gmp_float_imp&& o) noexcept { if ((this->get_default_options() == variable_precision_options::preserve_target_precision) && (mpf_get_prec(o.data()) != mpf_get_prec(data()))) *this = static_cast<const gmp_float_imp&>(o); else { 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=(unsigned long long i) { *this = static_cast<unsigned long>(i); return *this; } #else gmp_float_imp& operator=(unsigned long long i) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } unsigned long long 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 : (unsigned)get_default_precision())); mpf_set_ui(m_data, 0); while (i) { mpf_set_ui(t, static_cast<unsigned long>(i & mask)); if (shift) mpf_mul_2exp(t, t, shift); mpf_add(m_data, m_data, t); shift += std::numeric_limits<unsigned long>::digits; i >>= std::numeric_limits<unsigned long>::digits; } mpf_clear(t); return *this; } #endif gmp_float_imp& operator=(long long i) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } bool neg = i < 0; *this = static_cast<unsigned long long>(boost::multiprecision::detail::unsigned_abs(i)); if (neg) mpf_neg(m_data, m_data); return *this; } #endif gmp_float_imp& operator=(unsigned long i) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } mpf_set_ui(m_data, i); return *this; } gmp_float_imp& operator=(long i) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } mpf_set_si(m_data, i); return *this; } #ifdef BOOST_HAS_INT128 gmp_float_imp& operator=(uint128_type i) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } unsigned long 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 : (unsigned)get_default_precision())); mpf_set_ui(m_data, 0); while (i) { mpf_set_ui(t, static_cast<unsigned long>(i & mask)); if (shift) mpf_mul_2exp(t, t, shift); mpf_add(m_data, m_data, t); shift += std::numeric_limits<unsigned long>::digits; i >>= std::numeric_limits<unsigned long>::digits; } mpf_clear(t); return *this; } gmp_float_imp& operator=(int128_type i) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } bool neg = i < 0; *this = static_cast<uint128_type>(boost::multiprecision::detail::unsigned_abs(i)); if (neg) mpf_neg(m_data, m_data); return *this; } #endif gmp_float_imp& operator=(double d) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } mpf_set_d(m_data, d); return *this; } template <class F> gmp_float_imp& assign_float(F a) { BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp; if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } if (a == 0) { mpf_set_si(m_data, 0); return *this; } if (a == 1) { mpf_set_si(m_data, 1); return *this; } BOOST_MP_ASSERT(!BOOST_MP_ISINF(a)); BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a)); int e; F f, term; mpf_set_ui(m_data, 0u); f = frexp(a, &e); constexpr int shift = std::numeric_limits<int>::digits - 1; while (f) { // extract int sized bits from f: f = ldexp(f, shift); term = floor(f); e -= shift; mpf_mul_2exp(m_data, m_data, shift); 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) mpf_mul_2exp(m_data, m_data, e); else if (e < 0) mpf_div_2exp(m_data, m_data, -e); return *this; } gmp_float_imp& operator=(long double a) { return assign_float(a); } #ifdef BOOST_HAS_FLOAT128 gmp_float_imp& operator= (float128_type a) { return assign_float(a); } #endif gmp_float_imp& operator=(const char* s) { if (m_data[0]._mp_d == nullptr) { mpf_init2(m_data, multiprecision::detail::digits10_2_2(digits10 ? digits10 : (unsigned)get_default_precision())); } if (s && (*s == '+')) ++s; // Leading "+" sign not supported by mpf_set_str: // // Validate the string as mpf_set_str does a poor job of this: // static const char* digits = "0123456789"; const char* p = s; if (*s == '-') ++s; s += boost::multiprecision::detail::find_first_not_of(s, s + std::strlen(s), digits); std::lconv const* l = std::localeconv(); std::size_t len = strlen(l->decimal_point); if (std::find(l->decimal_point, l->decimal_point + len, *s) != l->decimal_point + len) { ++s; s += boost::multiprecision::detail::find_first_not_of(s, s + std::strlen(s), digits); } if ((*s == 'e') || (*s == 'E')) { ++s; if ((*s == '+') || (*s == '-')) ++s; s += boost::multiprecision::detail::find_first_not_of(s, s + std::strlen(s), digits); } if(*s) BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid floating point number."))); s = p; if (0 != mpf_set_str(m_data, s, 10)) BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid floating point number."))); return *this; } void swap(gmp_float_imp& o) noexcept { mpf_swap(m_data, o.m_data); } std::string str(std::streamsize digits, std::ios_base::fmtflags f) const { BOOST_MP_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; std::streamsize org_digits(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_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr); if (mpf_sgn(m_data) == 0) { e = 0; result = "0"; if (fixed && digits) ++digits; } else { char* ps = mpf_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data); --e; // To match with what our formatter expects. if (fixed) { // 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) { // 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(nullptr, &e, 10, 0, m_data); --e; unsigned offset = *ps == '-' ? 1 : 0; if (ps[offset] > '5') { ++e; ps[offset] = '1'; ps[offset + 1] = 0; } else if (ps[offset] == '5') { unsigned i = offset + 1; bool round_up = false; while (ps[i] != 0) { if (ps[i] != '0') { round_up = true; break; } ++i; } if (round_up) { ++e; ps[offset] = '1'; ps[offset + 1] = 0; } else { ps[offset] = '0'; ps[offset + 1] = 0; } } else { ps[offset] = '0'; ps[offset + 1] = 0; } } else if (digits > 0) { mp_exp_t old_e = e; ps = mpf_get_str(nullptr, &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; (*free_func_ptr)((void*)ps, std::strlen(ps) + 1); ps = mpf_get_str(nullptr, &e, 10, static_cast<std::size_t>(digits), m_data); --e; // To match with what our formatter expects. } } else { ps = mpf_get_str(nullptr, &e, 10, 1, m_data); --e; unsigned offset = *ps == '-' ? 1 : 0; ps[offset] = '0'; ps[offset + 1] = 0; } } result = ps; (*free_func_ptr)((void*)ps, std::strlen(ps) + 1); } boost::multiprecision::detail::format_float_string(result, e, org_digits, f, mpf_sgn(m_data) == 0); return result; } ~gmp_float_imp() noexcept { if (m_data[0]._mp_d) { mpf_clear(m_data); } } void negate() noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); mpf_neg(m_data, m_data); } int compare(const gmp_float<digits10>& o) const noexcept { BOOST_MP_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 noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return mpf_cmp_si(m_data, i); } int compare(unsigned long i) const noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return mpf_cmp_ui(m_data, i); } template <class V> typename std::enable_if<boost::multiprecision::detail::is_arithmetic<V>::value, int>::type compare(V v) const { gmp_float<digits10> d; d = v; return compare(d); } mpf_t& data() noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return m_data; } const mpf_t& data() const noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return m_data; } protected: mpf_t m_data; static unsigned& get_default_precision() noexcept { static BOOST_MP_THREAD_LOCAL unsigned val(get_global_default_precision()); return val; } static boost::multiprecision::detail::precision_type& get_global_default_precision() noexcept { static boost::multiprecision::detail::precision_type val(50); return val; } #ifndef BOOST_MT_NO_ATOMIC_INT static std::atomic<variable_precision_options>& get_global_default_options() noexcept #else static variable_precision_options& get_global_default_options() noexcept #endif { #ifndef BOOST_MT_NO_ATOMIC_INT static std::atomic<variable_precision_options> val{variable_precision_options::preserve_related_precision}; #else static variable_precision_options val{variable_precision_options::preserve_related_precision}; #endif return val; } static variable_precision_options& get_default_options()noexcept { static BOOST_MP_THREAD_LOCAL variable_precision_options val(get_global_default_options()); return val; } static bool preserve_source_precision() noexcept { return get_default_options() >= variable_precision_options::preserve_source_precision; } }; class gmp_char_ptr { private: char* ptr_val; void* (*alloc_func_ptr)(size_t); void* (*realloc_func_ptr)(void*, size_t, size_t); void (*free_func_ptr)(void*, size_t); public: gmp_char_ptr() = delete; explicit gmp_char_ptr(char* val_) : ptr_val {val_} { mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr); } ~gmp_char_ptr() noexcept { (*free_func_ptr)((void*)ptr_val, sizeof(*ptr_val)); ptr_val = nullptr; } inline char* get() noexcept { return ptr_val; } }; } // namespace detail template <unsigned digits10> struct gmp_float : public detail::gmp_float_imp<digits10> { gmp_float() { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10)); } gmp_float(const gmp_float& o) : detail::gmp_float_imp<digits10>(o) {} template <unsigned D> gmp_float(const gmp_float<D>& o, typename std::enable_if<D <= digits10>::type* = nullptr); template <unsigned D> explicit gmp_float(const gmp_float<D>& o, typename std::enable_if<!(D <= digits10)>::type* = nullptr); gmp_float(const gmp_int& o); gmp_float(const gmp_rational& o); gmp_float(const mpf_t val) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10)); mpf_set(this->m_data, val); } gmp_float(const mpz_t val) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10)); mpf_set_z(this->m_data, val); } gmp_float(const mpq_t val) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10)); mpf_set_q(this->m_data, val); } // rvalue copy gmp_float(gmp_float&& o) noexcept : detail::gmp_float_imp<digits10>(static_cast<detail::gmp_float_imp<digits10>&&>(o)) {} gmp_float& operator=(const gmp_float& o) { *static_cast<detail::gmp_float_imp<digits10>*>(this) = static_cast<detail::gmp_float_imp<digits10> const&>(o); return *this; } gmp_float& operator=(gmp_float&& o) noexcept { *static_cast<detail::gmp_float_imp<digits10>*>(this) = static_cast<detail::gmp_float_imp<digits10>&&>(o); return *this; } template <unsigned D> gmp_float& operator=(const gmp_float<D>& o); gmp_float& operator=(const gmp_int& o); gmp_float& operator=(const gmp_rational& o); gmp_float& operator=(const mpf_t val) { if (this->m_data[0]._mp_d == nullptr) 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 == nullptr) 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 == nullptr) mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(digits10)); mpf_set_q(this->m_data, val); return *this; } template <class V> typename std::enable_if<std::is_assignable<detail::gmp_float_imp<digits10>, V>::value, gmp_float&>::type operator=(const V& v) { *static_cast<detail::gmp_float_imp<digits10>*>(this) = v; return *this; } }; template <> struct gmp_float<0> : public detail::gmp_float_imp<0> { // // We have a problem with mpf_t in that the precision we request isn't what we get. // As a result the front end can end up chasing it's tail trying to create a variable // with the the correct precision to hold the result of an expression. // See: https://github.com/boostorg/multiprecision/issues/164 // The problem is made worse by the fact that our conversions from base10 to 2 and // vice-versa do not exactly round trip (and probably never will). // The workaround is to keep track of the precision requested, and always return // that as the current actual precision. // private: unsigned requested_precision; public: gmp_float() : requested_precision(get_default_precision()) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } gmp_float(const mpf_t val) : requested_precision(get_default_precision()) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); mpf_set(this->m_data, val); } gmp_float(const mpz_t val) : requested_precision(get_default_precision()) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); mpf_set_z(this->m_data, val); } gmp_float(const mpq_t val) : requested_precision(get_default_precision()) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); mpf_set_q(this->m_data, val); } gmp_float(const gmp_float& o) : detail::gmp_float_imp<0>(o), requested_precision(preserve_source_precision() ? o.requested_precision : get_default_precision()) {} template <unsigned D> gmp_float(const gmp_float<D>& o) { mpf_init2(this->m_data, preserve_related_precision() ? mpf_get_prec(o.data()) : multiprecision::detail::digits10_2_2(get_default_precision())); mpf_set(this->m_data, o.data()); requested_precision = preserve_related_precision() ? D : get_default_precision(); } // rvalue copy gmp_float(gmp_float&& o) noexcept : detail::gmp_float_imp<0>(static_cast<detail::gmp_float_imp<0>&&>(o)), requested_precision((this->get_default_options() != variable_precision_options::preserve_target_precision) ? o.requested_precision : get_default_precision()) {} gmp_float(const gmp_int& o); gmp_float(const gmp_rational& o); gmp_float(const gmp_float& o, unsigned digits10) : requested_precision(digits10) { 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) : requested_precision(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) : requested_precision(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); if(preserve_source_precision()) requested_precision = o.requested_precision; return *this; } // rvalue copy gmp_float& operator=(gmp_float&& o) noexcept { *static_cast<detail::gmp_float_imp<0>*>(this) = static_cast<detail::gmp_float_imp<0>&&>(o); if ((this->get_default_options() != variable_precision_options::preserve_target_precision)) requested_precision = o.requested_precision; return *this; } template <unsigned D> gmp_float& operator=(const gmp_float<D>& o) { if (this->m_data[0]._mp_d == nullptr) { mpf_init2(this->m_data, preserve_related_precision() ? mpf_get_prec(o.data()) : multiprecision::detail::digits10_2_2(get_default_precision())); } else if(preserve_related_precision()) { mpf_set_prec(this->m_data, mpf_get_prec(o.data())); } mpf_set(this->m_data, o.data()); if (preserve_related_precision()) requested_precision = D; return *this; } gmp_float& operator=(const gmp_int& o); gmp_float& operator=(const gmp_rational& o); gmp_float& operator=(const mpf_t val) { if (this->m_data[0]._mp_d == nullptr) { requested_precision = get_default_precision(); mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } mpf_set(this->m_data, val); return *this; } gmp_float& operator=(const mpz_t val) { if (this->m_data[0]._mp_d == nullptr) { requested_precision = get_default_precision(); mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } mpf_set_z(this->m_data, val); return *this; } gmp_float& operator=(const mpq_t val) { if (this->m_data[0]._mp_d == nullptr) { requested_precision = get_default_precision(); mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } mpf_set_q(this->m_data, val); return *this; } template <class V> typename std::enable_if<std::is_assignable<detail::gmp_float_imp<0>, V>::value, gmp_float&>::type operator=(const V& v) { constexpr unsigned d10 = std::is_floating_point<V>::value ? std::numeric_limits<V>::digits10 : std::numeric_limits<V>::digits10 ? 1 + std::numeric_limits<V>::digits10 : 1 + boost::multiprecision::detail::digits2_2_10(std::numeric_limits<V>::digits); if((thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) && (precision() < d10)) this->precision(d10); *static_cast<detail::gmp_float_imp<0>*>(this) = v; return *this; } static unsigned default_precision() noexcept { return get_global_default_precision(); } static void default_precision(unsigned v) noexcept { get_global_default_precision() = v; } static unsigned thread_default_precision() noexcept { return get_default_precision(); } static void thread_default_precision(unsigned v) noexcept { get_default_precision() = v; } unsigned precision() const noexcept { return requested_precision; } void precision(unsigned digits10) noexcept { requested_precision = digits10; mpf_set_prec(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } // // Variable precision options: // static variable_precision_options default_variable_precision_options()noexcept { return get_global_default_options(); } static variable_precision_options thread_default_variable_precision_options()noexcept { return get_default_options(); } static void default_variable_precision_options(variable_precision_options opts) { get_global_default_options() = opts; } static void thread_default_variable_precision_options(variable_precision_options opts) { get_default_options() = opts; } static bool preserve_source_precision() { return get_default_options() >= variable_precision_options::preserve_source_precision; } static bool preserve_related_precision() { return get_default_options() >= variable_precision_options::preserve_related_precision; } static bool preserve_all_precision() { return get_default_options() >= variable_precision_options::preserve_all_precision; } // // swap: // void swap(gmp_float& o) { std::swap(requested_precision, o.requested_precision); gmp_float_imp<0>::swap(o); } }; template <unsigned digits10, class T> inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const gmp_float<digits10>& a, const T& b) noexcept { return a.compare(b) == 0; } template <unsigned digits10, class T> inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const gmp_float<digits10>& a, const T& b) noexcept { return a.compare(b) < 0; } template <unsigned digits10, class T> inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const gmp_float<digits10>& a, const T& b) noexcept { return a.compare(b) > 0; } template <unsigned D1, unsigned D2> inline void eval_add(gmp_float<D1>& result, const gmp_float<D2>& o) { mpf_add(result.data(), result.data(), o.data()); } template <unsigned D1, unsigned D2> inline void eval_subtract(gmp_float<D1>& result, const gmp_float<D2>& o) { mpf_sub(result.data(), result.data(), o.data()); } template <unsigned D1, unsigned D2> inline void eval_multiply(gmp_float<D1>& result, const gmp_float<D2>& o) { mpf_mul(result.data(), result.data(), o.data()); } template <unsigned digits10> inline bool eval_is_zero(const gmp_float<digits10>& val) noexcept { return mpf_sgn(val.data()) == 0; } template <unsigned D1, unsigned D2> inline void eval_divide(gmp_float<D1>& result, const gmp_float<D2>& o) { if (eval_is_zero(o)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpf_div(result.data(), result.data(), o.data()); } template <unsigned digits10> inline void eval_add(gmp_float<digits10>& result, unsigned long i) { mpf_add_ui(result.data(), result.data(), i); } template <unsigned digits10> inline void eval_subtract(gmp_float<digits10>& result, unsigned long i) { mpf_sub_ui(result.data(), result.data(), i); } template <unsigned digits10> inline void eval_multiply(gmp_float<digits10>& result, unsigned long i) { mpf_mul_ui(result.data(), result.data(), i); } template <unsigned digits10> inline void eval_divide(gmp_float<digits10>& result, unsigned long i) { if (i == 0) BOOST_MP_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) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpf_add_ui(result.data(), result.data(), static_cast<local_uint_type>(i)); else if (i < 0) mpf_sub_ui(result.data(), result.data(), static_cast<local_uint_type>(-i)); } template <unsigned digits10> inline void eval_subtract(gmp_float<digits10>& result, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpf_sub_ui(result.data(), result.data(), static_cast<local_uint_type>(i)); else if (i < 0) mpf_add_ui(result.data(), result.data(), static_cast<local_uint_type>(-i)); } template <unsigned digits10> inline void eval_multiply(gmp_float<digits10>& result, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; mpf_mul_ui(result.data(), result.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i))); 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) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; mpf_div_ui(result.data(), result.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i))); if (i < 0) mpf_neg(result.data(), result.data()); } // // Specialised 3 arg versions of the basic operators: // template <unsigned D1, unsigned D2, unsigned D3> inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y) { mpf_add(a.data(), x.data(), y.data()); } template <unsigned D1, unsigned D2> inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y) { mpf_add_ui(a.data(), x.data(), y); } template <unsigned D1, unsigned D2> inline void eval_add(gmp_float<D1>& a, const gmp_float<D2>& x, long y) { 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, unsigned long x, const gmp_float<D2>& y) { mpf_add_ui(a.data(), y.data(), x); } template <unsigned D1, unsigned D2> inline void eval_add(gmp_float<D1>& a, long x, const gmp_float<D2>& y) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (x < 0) { mpf_ui_sub(a.data(), static_cast<local_uint_type>(-x), y.data()); mpf_neg(a.data(), a.data()); } else mpf_add_ui(a.data(), y.data(), static_cast<local_uint_type>(x)); } template <unsigned D1, unsigned D2, unsigned D3> inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y) { mpf_sub(a.data(), x.data(), y.data()); } template <unsigned D1, unsigned D2> inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y) { mpf_sub_ui(a.data(), x.data(), y); } template <unsigned D1, unsigned D2> inline void eval_subtract(gmp_float<D1>& a, const gmp_float<D2>& x, long y) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (y < 0) mpf_add_ui(a.data(), x.data(), static_cast<local_uint_type>(-y)); else mpf_sub_ui(a.data(), x.data(), static_cast<local_uint_type>(y)); } template <unsigned D1, unsigned D2> inline void eval_subtract(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y) { mpf_ui_sub(a.data(), x, y.data()); } template <unsigned D1, unsigned D2> inline void eval_subtract(gmp_float<D1>& a, long x, const gmp_float<D2>& y) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (x < 0) { mpf_add_ui(a.data(), y.data(), static_cast<local_uint_type>(-x)); mpf_neg(a.data(), a.data()); } else mpf_ui_sub(a.data(), static_cast<local_uint_type>(x), y.data()); } template <unsigned D1, unsigned D2, unsigned D3> inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, const gmp_float<D3>& y) { mpf_mul(a.data(), x.data(), y.data()); } template <unsigned D1, unsigned D2> inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, unsigned long y) { mpf_mul_ui(a.data(), x.data(), y); } template <unsigned D1, unsigned D2> inline void eval_multiply(gmp_float<D1>& a, const gmp_float<D2>& x, long y) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (y < 0) { mpf_mul_ui(a.data(), x.data(), static_cast<local_uint_type>(-y)); a.negate(); } else mpf_mul_ui(a.data(), x.data(), static_cast<local_uint_type>(y)); } template <unsigned D1, unsigned D2> inline void eval_multiply(gmp_float<D1>& a, unsigned long x, const gmp_float<D2>& y) { mpf_mul_ui(a.data(), y.data(), x); } template <unsigned D1, unsigned D2> inline void eval_multiply(gmp_float<D1>& a, long x, const gmp_float<D2>& y) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (x < 0) { mpf_mul_ui(a.data(), y.data(), static_cast<local_uint_type>(-x)); mpf_neg(a.data(), a.data()); } else mpf_mul_ui(a.data(), y.data(), static_cast<local_uint_type>(x)); } 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)) BOOST_MP_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) BOOST_MP_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) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (y < 0) { mpf_div_ui(a.data(), x.data(), static_cast<local_uint_type>(-y)); a.negate(); } else mpf_div_ui(a.data(), x.data(), static_cast<local_uint_type>(y)); } 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)) BOOST_MP_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)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); if (x < 0) { mpf_ui_div(a.data(), boost::multiprecision::detail::unsigned_abs(x), y.data()); mpf_neg(a.data(), a.data()); } else { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; mpf_ui_div(a.data(), static_cast<local_uint_type>(x), y.data()); } } template <unsigned digits10> inline int eval_get_sign(const gmp_float<digits10>& val) noexcept { return mpf_sgn(val.data()); } template <unsigned digits10> inline void eval_convert_to(unsigned long* result, const gmp_float<digits10>& val) noexcept { if (0 == mpf_fits_ulong_p(val.data())) *result = (std::numeric_limits<unsigned long>::max)(); else *result = static_cast<unsigned long>(mpf_get_ui(val.data())); } template <unsigned digits10> inline void eval_convert_to(long* result, const gmp_float<digits10>& val) noexcept { if (0 == mpf_fits_slong_p(val.data())) { *result = (std::numeric_limits<long>::max)(); *result *= mpf_sgn(val.data()); } else *result = static_cast<long>(mpf_get_si(val.data())); } #ifdef BOOST_MP_STANDALONE template <unsigned digits10> inline void eval_convert_to(long double* result, const gmp_float<digits10>& val) noexcept { mp_exp_t exp = 0; detail::gmp_char_ptr val_char_ptr {mpf_get_str(nullptr, &exp, 10, LDBL_DIG, val.data())}; auto temp_string = std::string(val_char_ptr.get()); if(exp > 0 && static_cast<std::size_t>(exp) < temp_string.size()) { if(temp_string.front() == '-') { ++exp; } temp_string.insert(static_cast<std::size_t>(exp), static_cast<std::size_t>(1u), '.'); } *result = std::strtold(temp_string.c_str(), nullptr); if((temp_string.size() == 2ul && *result < 0.0l) || (static_cast<std::size_t>(exp) > temp_string.size())) { *result *= std::pow(10l, exp-1); } } #endif // BOOST_MP_STANDALONE template <unsigned digits10> inline void eval_convert_to(double* result, const gmp_float<digits10>& val) noexcept { *result = mpf_get_d(val.data()); } #ifdef BOOST_HAS_LONG_LONG template <unsigned digits10> inline void eval_convert_to(long long* result, const gmp_float<digits10>& val) { gmp_float<digits10> t(val); if (eval_get_sign(t) < 0) t.negate(); long digits = std::numeric_limits<long long>::digits - std::numeric_limits<long>::digits; if (digits > 0) mpf_div_2exp(t.data(), t.data(), digits); if (!mpf_fits_slong_p(t.data())) { if (eval_get_sign(val) < 0) *result = (std::numeric_limits<long long>::min)(); else *result = (std::numeric_limits<long long>::max)(); return; }; *result = mpf_get_si(t.data()); 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 = static_cast<unsigned long>(mpf_get_ui(t.data())); if (digits < 0) l >>= -digits; *result |= l; } if (eval_get_sign(val) < 0) *result = -*result; } template <unsigned digits10> inline void eval_convert_to(unsigned long long* result, const gmp_float<digits10>& val) { gmp_float<digits10> t(val); long digits = std::numeric_limits<long long>::digits - std::numeric_limits<long>::digits; if (digits > 0) mpf_div_2exp(t.data(), t.data(), digits); if (!mpf_fits_ulong_p(t.data())) { *result = (std::numeric_limits<long long>::max)(); return; } *result = mpf_get_ui(t.data()); 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 = static_cast<unsigned long>(mpf_get_ui(t.data())); if (digits < 0) l >>= -digits; *result |= l; } } #endif #ifdef BOOST_HAS_FLOAT128 template <unsigned digits10> inline void eval_convert_to(float128_type* result, const gmp_float<digits10>& val) { *result = float128_procs::strtoflt128(val.str(0, std::ios_base::scientific).c_str(), nullptr); } #endif // // Native non-member operations: // template <unsigned Digits10> inline void eval_sqrt(gmp_float<Digits10>& result, const gmp_float<Digits10>& val) { mpf_sqrt(result.data(), val.data()); } template <unsigned Digits10> inline void eval_abs(gmp_float<Digits10>& result, const gmp_float<Digits10>& val) { mpf_abs(result.data(), val.data()); } template <unsigned Digits10> inline void eval_fabs(gmp_float<Digits10>& result, const gmp_float<Digits10>& val) { mpf_abs(result.data(), val.data()); } template <unsigned Digits10> inline void eval_ceil(gmp_float<Digits10>& result, const gmp_float<Digits10>& val) { mpf_ceil(result.data(), val.data()); } template <unsigned Digits10> inline void eval_floor(gmp_float<Digits10>& result, const gmp_float<Digits10>& val) { mpf_floor(result.data(), val.data()); } template <unsigned Digits10> inline void eval_trunc(gmp_float<Digits10>& result, const gmp_float<Digits10>& val) { mpf_trunc(result.data(), val.data()); } template <unsigned Digits10> inline void eval_ldexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long e) { if (e > 0) mpf_mul_2exp(result.data(), val.data(), static_cast<mp_bitcnt_t>(e)); else if (e < 0) mpf_div_2exp(result.data(), val.data(), static_cast<mp_bitcnt_t>(-e)); else result = val; } template <unsigned Digits10> inline void eval_frexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, int* e) { #if (BOOST_MP_MPIR_VERSION >= 20600) && (BOOST_MP_MPIR_VERSION < 30000) mpir_si v; mpf_get_d_2exp(&v, val.data()); #else long v; mpf_get_d_2exp(&v, val.data()); #endif *e = static_cast<int>(v); eval_ldexp(result, val, -v); } template <unsigned Digits10> inline void eval_frexp(gmp_float<Digits10>& result, const gmp_float<Digits10>& val, long* e) { #if (BOOST_MP_MPIR_VERSION >= 20600) && (BOOST_MP_MPIR_VERSION < 30000) mpir_si v; mpf_get_d_2exp(&v, val.data()); *e = v; eval_ldexp(result, val, -v); #else mpf_get_d_2exp(e, val.data()); eval_ldexp(result, val, -*e); #endif } template <unsigned Digits10> 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) boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_d[i]); boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_exp, val.data()[0]._mp_size); return result; } struct gmp_int { #ifdef BOOST_HAS_LONG_LONG using signed_types = std::tuple<long, long long> ; using unsigned_types = std::tuple<unsigned long, unsigned long long>; #else using signed_types = std::tuple<long> ; using unsigned_types = std::tuple<unsigned long>; #endif using float_types = std::tuple<double, long double>; gmp_int() { mpz_init(this->m_data); } gmp_int(const gmp_int& o) { if (o.m_data[0]._mp_d) mpz_init_set(m_data, o.m_data); else mpz_init(this->m_data); } // rvalue gmp_int(gmp_int&& o) noexcept { m_data[0] = o.m_data[0]; o.m_data[0]._mp_d = nullptr; } explicit gmp_int(const mpf_t val) { mpz_init(this->m_data); mpz_set_f(this->m_data, val); } gmp_int(const mpz_t val) { mpz_init_set(this->m_data, val); } gmp_int(long i) { mpz_init_set_si(this->m_data, i); } gmp_int(unsigned long i) { mpz_init_set_ui(this->m_data, i); } explicit gmp_int(const mpq_t val) { mpz_init(this->m_data); mpz_set_q(this->m_data, val); } template <unsigned Digits10> explicit gmp_int(const gmp_float<Digits10>& o) { mpz_init(this->m_data); mpz_set_f(this->m_data, o.data()); } explicit gmp_int(const gmp_rational& o); gmp_int& operator=(const gmp_int& o) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); mpz_set(m_data, o.m_data); return *this; } // rvalue copy gmp_int& operator=(gmp_int&& o) noexcept { mpz_swap(m_data, o.m_data); return *this; } #ifdef BOOST_HAS_LONG_LONG #if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX) gmp_int& operator=(unsigned long long i) { *this = static_cast<unsigned long>(i); return *this; } #else gmp_int& operator=(unsigned long long i) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); unsigned long long 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) { mpz_set_ui(t, static_cast<unsigned long>(i & mask)); if (shift) mpz_mul_2exp(t, t, shift); mpz_add(m_data, m_data, t); shift += std::numeric_limits<unsigned long>::digits; i >>= std::numeric_limits<unsigned long>::digits; } mpz_clear(t); return *this; } #endif gmp_int& operator=(long long i) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); bool neg = i < 0; *this = boost::multiprecision::detail::unsigned_abs(i); if (neg) mpz_neg(m_data, m_data); return *this; } #endif #ifdef BOOST_HAS_INT128 gmp_int& operator=(uint128_type i) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); uint128_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) { mpz_set_ui(t, static_cast<unsigned long>(i & mask)); if (shift) mpz_mul_2exp(t, t, shift); mpz_add(m_data, m_data, t); shift += std::numeric_limits<unsigned long>::digits; i >>= std::numeric_limits<unsigned long>::digits; } mpz_clear(t); return *this; } gmp_int& operator=(int128_type i) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); bool neg = i < 0; *this = boost::multiprecision::detail::unsigned_abs(i); if (neg) mpz_neg(m_data, m_data); return *this; } #endif gmp_int& operator=(unsigned long i) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); mpz_set_ui(m_data, i); return *this; } gmp_int& operator=(long i) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); mpz_set_si(m_data, i); return *this; } gmp_int& operator=(double d) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); mpz_set_d(m_data, d); return *this; } template <class F> gmp_int& assign_float(F a) { BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp; if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); if (a == 0) { mpz_set_si(m_data, 0); return *this; } if (a == 1) { mpz_set_si(m_data, 1); return *this; } BOOST_MP_ASSERT(!BOOST_MP_ISINF(a)); BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a)); int e; F f, term; mpz_set_ui(m_data, 0u); f = frexp(a, &e); constexpr int shift = std::numeric_limits<int>::digits - 1; while (f != static_cast<F>(0.0f)) { // extract int sized bits from f: f = ldexp(f, shift); term = floor(f); e -= shift; mpz_mul_2exp(m_data, m_data, shift); 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) mpz_mul_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(e)); else if (e < 0) mpz_div_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(-e)); return *this; } gmp_int& operator=(long double a) { return assign_float(a); } gmp_int& operator=(const char* s) { if (m_data[0]._mp_d == nullptr) mpz_init(this->m_data); 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'))) { radix = 16; s += 2; n -= 2; } else { radix = 8; n -= 1; } } if (n) { if (0 != mpz_set_str(m_data, s, radix)) BOOST_MP_THROW_EXCEPTION(std::runtime_error(std::string("The string \"") + s + std::string("\"could not be interpreted as a valid integer."))); } else mpz_set_ui(m_data, 0); return *this; } #ifdef BOOST_HAS_FLOAT128 gmp_int& operator=(float128_type a) { return assign_float(a); } #endif gmp_int& operator=(const mpf_t val) { if (m_data[0]._mp_d == nullptr) 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 == nullptr) 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 == nullptr) 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 == nullptr) 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) { mpz_swap(m_data, o.m_data); } std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f) const { BOOST_MP_ASSERT(m_data[0]._mp_d); int base = 10; if ((f & std::ios_base::oct) == std::ios_base::oct) base = 8; 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)) BOOST_MP_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(nullptr, 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 (f & std::ios_base::uppercase) for (size_t i = 0; i < s.length(); ++i) s[i] = static_cast<char>(std::toupper(s[i])); if ((base != 10) && (f & std::ios_base::showbase)) { 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] != '-')) s.insert(static_cast<std::string::size_type>(0), 1, '+'); return s; } ~gmp_int() noexcept { if (m_data[0]._mp_d) mpz_clear(m_data); } void negate() noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); mpz_neg(m_data, m_data); } int compare(const gmp_int& o) const noexcept { BOOST_MP_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 noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return mpz_cmp_si(m_data, i); } int compare(unsigned long i) const noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return mpz_cmp_ui(m_data, i); } template <class V> int compare(V v) const { gmp_int d; d = v; return compare(d); } mpz_t& data() noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return m_data; } const mpz_t& data() const noexcept { BOOST_MP_ASSERT(m_data[0]._mp_d); return m_data; } protected: mpz_t m_data; }; template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_eq(const gmp_int& a, const T& b) { return a.compare(b) == 0; } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_lt(const gmp_int& a, const T& b) { return a.compare(b) < 0; } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_arithmetic<T>::value, bool>::type eval_gt(const gmp_int& a, const T& b) { return a.compare(b) > 0; } inline bool eval_is_zero(const gmp_int& val) { return mpz_sgn(val.data()) == 0; } inline void eval_add(gmp_int& t, const gmp_int& o) { mpz_add(t.data(), t.data(), o.data()); } inline void eval_multiply_add(gmp_int& t, const gmp_int& a, const gmp_int& b) { mpz_addmul(t.data(), a.data(), b.data()); } inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, const gmp_int& b) { mpz_submul(t.data(), a.data(), b.data()); } inline void eval_subtract(gmp_int& t, const gmp_int& o) { mpz_sub(t.data(), t.data(), o.data()); } inline void eval_multiply(gmp_int& t, const gmp_int& o) { mpz_mul(t.data(), t.data(), o.data()); } inline void eval_divide(gmp_int& t, const gmp_int& o) { if (eval_is_zero(o)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_tdiv_q(t.data(), t.data(), o.data()); } inline void eval_modulus(gmp_int& t, const gmp_int& o) { mpz_tdiv_r(t.data(), t.data(), o.data()); } inline void eval_add(gmp_int& t, unsigned long i) { mpz_add_ui(t.data(), t.data(), i); } inline void eval_multiply_add(gmp_int& t, const gmp_int& a, unsigned long i) { mpz_addmul_ui(t.data(), a.data(), i); } inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, unsigned long i) { mpz_submul_ui(t.data(), a.data(), i); } inline void eval_subtract(gmp_int& t, unsigned long i) { mpz_sub_ui(t.data(), t.data(), i); } inline void eval_multiply(gmp_int& t, unsigned long i) { mpz_mul_ui(t.data(), t.data(), i); } inline void eval_modulus(gmp_int& t, unsigned long i) { mpz_tdiv_r_ui(t.data(), t.data(), i); } inline void eval_divide(gmp_int& t, unsigned long i) { if (i == 0) BOOST_MP_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) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpz_add_ui(t.data(), t.data(), static_cast<local_uint_type>(i)); else if (i < 0) mpz_sub_ui(t.data(), t.data(), static_cast<local_uint_type>(-i)); } inline void eval_multiply_add(gmp_int& t, const gmp_int& a, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpz_addmul_ui(t.data(), a.data(), static_cast<local_uint_type>(i)); else mpz_submul_ui(t.data(), a.data(), static_cast<local_uint_type>(-i)); } inline void eval_multiply_subtract(gmp_int& t, const gmp_int& a, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpz_submul_ui(t.data(), a.data(), static_cast<local_uint_type>(i)); else mpz_addmul_ui(t.data(), a.data(), static_cast<local_uint_type>(-i)); } inline void eval_subtract(gmp_int& t, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpz_sub_ui(t.data(), t.data(), static_cast<local_uint_type>(i)); else if (i < 0) mpz_add_ui(t.data(), t.data(), static_cast<local_uint_type>(-i)); } inline void eval_multiply(gmp_int& t, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; mpz_mul_ui(t.data(), t.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i))); if (i < 0) mpz_neg(t.data(), t.data()); } inline void eval_modulus(gmp_int& t, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; mpz_tdiv_r_ui(t.data(), t.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i))); } inline void eval_divide(gmp_int& t, long i) { if (i == 0) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; mpz_tdiv_q_ui(t.data(), t.data(), static_cast<local_uint_type>(boost::multiprecision::detail::unsigned_abs(i))); if (i < 0) mpz_neg(t.data(), t.data()); } template <class UI> inline void eval_left_shift(gmp_int& t, UI i) { mpz_mul_2exp(t.data(), t.data(), static_cast<unsigned long>(i)); } template <class UI> inline void eval_right_shift(gmp_int& t, UI i) { mpz_fdiv_q_2exp(t.data(), t.data(), static_cast<unsigned long>(i)); } template <class UI> inline void eval_left_shift(gmp_int& t, const gmp_int& v, UI i) { mpz_mul_2exp(t.data(), v.data(), static_cast<unsigned long>(i)); } template <class UI> inline void eval_right_shift(gmp_int& t, const gmp_int& v, UI i) { mpz_fdiv_q_2exp(t.data(), v.data(), static_cast<unsigned long>(i)); } inline void eval_bitwise_and(gmp_int& result, const gmp_int& v) { mpz_and(result.data(), result.data(), v.data()); } inline void eval_bitwise_or(gmp_int& result, const gmp_int& v) { mpz_ior(result.data(), result.data(), v.data()); } inline void eval_bitwise_xor(gmp_int& result, const gmp_int& v) { mpz_xor(result.data(), result.data(), v.data()); } inline void eval_add(gmp_int& t, const gmp_int& p, const gmp_int& o) { mpz_add(t.data(), p.data(), o.data()); } inline void eval_subtract(gmp_int& t, const gmp_int& p, const gmp_int& o) { mpz_sub(t.data(), p.data(), o.data()); } inline void eval_multiply(gmp_int& t, const gmp_int& p, const gmp_int& o) { mpz_mul(t.data(), p.data(), o.data()); } inline void eval_divide(gmp_int& t, const gmp_int& p, const gmp_int& o) { if (eval_is_zero(o)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_tdiv_q(t.data(), p.data(), o.data()); } inline void eval_modulus(gmp_int& t, const gmp_int& p, const gmp_int& o) { mpz_tdiv_r(t.data(), p.data(), o.data()); } inline void eval_add(gmp_int& t, const gmp_int& p, unsigned long i) { mpz_add_ui(t.data(), p.data(), i); } inline void eval_subtract(gmp_int& t, const gmp_int& p, unsigned long i) { mpz_sub_ui(t.data(), p.data(), i); } inline void eval_multiply(gmp_int& t, const gmp_int& p, unsigned long i) { mpz_mul_ui(t.data(), p.data(), i); } inline void eval_modulus(gmp_int& t, const gmp_int& p, unsigned long i) { mpz_tdiv_r_ui(t.data(), p.data(), i); } inline void eval_divide(gmp_int& t, const gmp_int& p, unsigned long i) { if (i == 0) BOOST_MP_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) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpz_add_ui(t.data(), p.data(), static_cast<local_uint_type>(i)); else mpz_sub_ui(t.data(), p.data(), static_cast<local_uint_type>(-i)); } inline void eval_subtract(gmp_int& t, const gmp_int& p, long i) { using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (i > 0) mpz_sub_ui(t.data(), p.data(), static_cast<local_uint_type>(i)); else mpz_add_ui(t.data(), p.data(), static_cast<local_uint_type>(-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) mpz_neg(t.data(), t.data()); } inline void eval_modulus(gmp_int& t, const gmp_int& p, long i) { mpz_tdiv_r_ui(t.data(), p.data(), boost::multiprecision::detail::unsigned_abs(i)); } inline void eval_divide(gmp_int& t, const gmp_int& p, long i) { if (i == 0) BOOST_MP_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) mpz_neg(t.data(), t.data()); } inline void eval_bitwise_and(gmp_int& result, const gmp_int& u, const gmp_int& v) { mpz_and(result.data(), u.data(), v.data()); } inline void eval_bitwise_or(gmp_int& result, const gmp_int& u, const gmp_int& v) { mpz_ior(result.data(), u.data(), v.data()); } inline void eval_bitwise_xor(gmp_int& result, const gmp_int& u, const gmp_int& v) { mpz_xor(result.data(), u.data(), v.data()); } inline void eval_complement(gmp_int& result, const gmp_int& u) { mpz_com(result.data(), u.data()); } inline int eval_get_sign(const gmp_int& val) { return mpz_sgn(val.data()); } inline void eval_convert_to(unsigned long* result, const gmp_int& val) { if (mpz_sgn(val.data()) < 0) { BOOST_MP_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour")); } else *result = static_cast<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())) { *result = mpz_sgn(val.data()) < 0 ? (std::numeric_limits<long>::min)() : (std::numeric_limits<long>::max)(); } else *result = static_cast<long>(mpz_get_si(val.data())); } inline void eval_convert_to(long double* result, const gmp_int& val) { detail::gmp_char_ptr val_char_ptr {mpz_get_str(nullptr, 10, val.data())}; *result = std::strtold(val_char_ptr.get(), nullptr); } inline void eval_convert_to(double* result, const gmp_int& val) { *result = mpz_get_d(val.data()); } #ifdef BOOST_HAS_LONG_LONG inline void eval_convert_to(unsigned long long* result, const gmp_int& val) { if (mpz_sgn(val.data()) < 0) { BOOST_MP_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour")); } *result = 0; gmp_int t(val); unsigned parts = sizeof(unsigned long long) / sizeof(unsigned long); for (unsigned i = 0; i < parts; ++i) { unsigned long long part = mpz_get_ui(t.data()); if (i) *result |= part << (i * sizeof(unsigned long) * CHAR_BIT); else *result = part; mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT); } } inline void eval_convert_to(long long* result, const gmp_int& val) { int s = mpz_sgn(val.data()); *result = 0; gmp_int t(val); unsigned parts = sizeof(unsigned long long) / sizeof(unsigned long); unsigned long long unsigned_result = 0; for (unsigned i = 0; i < parts; ++i) { unsigned long long part = mpz_get_ui(t.data()); if (i) unsigned_result |= part << (i * sizeof(unsigned long) * CHAR_BIT); else unsigned_result = part; mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT); } // // Overflow check: // bool overflow = false; if (mpz_sgn(t.data())) { overflow = true; } if ((s > 0) && (unsigned_result > static_cast<unsigned long long>((std::numeric_limits<long long>::max)()))) overflow = true; if((s < 0) && (unsigned_result > 1u - static_cast<unsigned long long>((std::numeric_limits<long long>::min)() + 1))) overflow = true; if(overflow) *result = s < 0 ? (std::numeric_limits<long long>::min)() : (std::numeric_limits<long long>::max)(); else *result = s < 0 ? -static_cast<long long>(unsigned_result - 1u) - 1 : static_cast<long long>(unsigned_result); } #endif #ifdef BOOST_HAS_INT128 inline void eval_convert_to(uint128_type* result, const gmp_int& val) { if (mpz_sgn(val.data()) < 0) { BOOST_MP_THROW_EXCEPTION(std::range_error("Conversion from negative integer to an unsigned type results in undefined behaviour")); } *result = 0; gmp_int t(val); unsigned parts = sizeof(uint128_type) / sizeof(unsigned long); for (unsigned i = 0; i < parts; ++i) { uint128_type part = mpz_get_ui(t.data()); if (i) *result |= part << (i * sizeof(unsigned long) * CHAR_BIT); else *result = part; mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT); } } inline void eval_convert_to(int128_type* result, const gmp_int& val) { int s = mpz_sgn(val.data()); *result = 0; gmp_int t(val); unsigned parts = sizeof(uint128_type) / sizeof(unsigned long); uint128_type unsigned_result = 0; for (unsigned i = 0; i < parts; ++i) { uint128_type part = mpz_get_ui(t.data()); if (i) unsigned_result |= part << (i * sizeof(unsigned long) * CHAR_BIT); else unsigned_result = part; mpz_tdiv_q_2exp(t.data(), t.data(), sizeof(unsigned long) * CHAR_BIT); } // // Overflow check: // constexpr int128_type int128_max = static_cast<int128_type>((static_cast<uint128_type>(1u) << 127) - 1); constexpr int128_type int128_min = static_cast<int128_type>(static_cast<int128_type>(-int128_max) -1); bool overflow = false; if (mpz_sgn(t.data())) { overflow = true; } if ((s > 0) && (unsigned_result > static_cast<uint128_type>(int128_max))) overflow = true; if ((s < 0) && (unsigned_result > 1u - static_cast<uint128_type>(int128_min + 1))) overflow = true; if (overflow) *result = s < 0 ? int128_min : int128_max; else *result = s < 0 ? -static_cast<int128_type>(unsigned_result - 1u) - 1 : static_cast<int128_type>(unsigned_result); } template <unsigned digits10> inline void eval_convert_to(int128_type* result, const gmp_float<digits10>& val) { gmp_int i; mpz_set_f(i.data(), val.data()); eval_convert_to(result, i); } template <unsigned digits10> inline void eval_convert_to(uint128_type* result, const gmp_float<digits10>& val) { gmp_int i; mpz_set_f(i.data(), val.data()); eval_convert_to(result, i); } #endif #ifdef BOOST_HAS_FLOAT128 inline void eval_convert_to(float128_type* result, const gmp_int& val) { *result = float128_procs::strtoflt128(val.str(0, std::ios_base::fixed).c_str(), nullptr); } #endif inline void eval_abs(gmp_int& result, const gmp_int& val) { mpz_abs(result.data(), val.data()); } inline void eval_gcd(gmp_int& result, const gmp_int& a, const gmp_int& b) { mpz_gcd(result.data(), a.data(), b.data()); } inline void eval_lcm(gmp_int& result, const gmp_int& a, const gmp_int& b) { mpz_lcm(result.data(), a.data(), b.data()); } template <class I> inline typename std::enable_if<(boost::multiprecision::detail::is_unsigned<I>::value && (sizeof(I) <= sizeof(unsigned long)))>::type eval_gcd(gmp_int& result, const gmp_int& a, const I b) { mpz_gcd_ui(result.data(), a.data(), b); } template <class I> inline typename std::enable_if<(boost::multiprecision::detail::is_unsigned<I>::value && (sizeof(I) <= sizeof(unsigned long)))>::type eval_lcm(gmp_int& result, const gmp_int& a, const I b) { mpz_lcm_ui(result.data(), a.data(), b); } template <class I> inline typename std::enable_if<(boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value && (sizeof(I) <= sizeof(long)))>::type eval_gcd(gmp_int& result, const gmp_int& a, const I b) { mpz_gcd_ui(result.data(), a.data(), boost::multiprecision::detail::unsigned_abs(b)); } template <class I> inline typename std::enable_if<boost::multiprecision::detail::is_signed<I>::value && boost::multiprecision::detail::is_integral<I>::value && ((sizeof(I) <= sizeof(long)))>::type eval_lcm(gmp_int& result, const gmp_int& a, const I b) { mpz_lcm_ui(result.data(), a.data(), boost::multiprecision::detail::unsigned_abs(b)); } inline void eval_integer_sqrt(gmp_int& s, gmp_int& r, const gmp_int& x) { mpz_sqrtrem(s.data(), r.data(), x.data()); } inline std::size_t eval_lsb(const gmp_int& val) { int c = eval_get_sign(val); if (c == 0) { BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand.")); } if (c < 0) { BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined.")); } return static_cast<unsigned>(mpz_scan1(val.data(), 0)); } inline std::size_t eval_msb(const gmp_int& val) { int c = eval_get_sign(val); if (c == 0) { BOOST_MP_THROW_EXCEPTION(std::domain_error("No bits were set in the operand.")); } if (c < 0) { BOOST_MP_THROW_EXCEPTION(std::domain_error("Testing individual bits in negative values is not supported - results are undefined.")); } return static_cast<unsigned>(mpz_sizeinbase(val.data(), 2) - 1); } inline bool eval_bit_test(const gmp_int& val, std::size_t index) { return mpz_tstbit(val.data(), index) ? true : false; } inline void eval_bit_set(gmp_int& val, std::size_t index) { mpz_setbit(val.data(), index); } inline void eval_bit_unset(gmp_int& val, std::size_t index) { mpz_clrbit(val.data(), index); } inline void eval_bit_flip(gmp_int& val, std::size_t index) { mpz_combit(val.data(), index); } inline void eval_qr(const gmp_int& x, const gmp_int& y, gmp_int& q, gmp_int& r) { mpz_tdiv_qr(q.data(), r.data(), x.data(), y.data()); } template <class Integer> inline typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value, 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)())) #else if ((sizeof(Integer) <= sizeof(long)) || (val <= (std::numeric_limits<unsigned long>::max)())) #endif { return static_cast<Integer>(mpz_tdiv_ui(x.data(), val)); } else { return default_ops::eval_integer_modulus(x, val); } } template <class Integer> inline typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value, Integer>::type eval_integer_modulus(const gmp_int& x, Integer val) { return eval_integer_modulus(x, boost::multiprecision::detail::unsigned_abs(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) { BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent.")); } mpz_powm(result.data(), base.data(), p.data(), m.data()); } template <class Integer> inline typename std::enable_if< boost::multiprecision::detail::is_unsigned<Integer>::value && (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 std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value && (sizeof(Integer) <= sizeof(unsigned long))>::type eval_powm(gmp_int& result, const gmp_int& base, Integer p, const gmp_int& m) { if (p < 0) { BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent.")); } mpz_powm_ui(result.data(), base.data(), p, m.data()); } inline std::size_t hash_value(const gmp_int& val) { // 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) boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_d[i]); boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_size); return result; } struct gmp_rational; void eval_add(gmp_rational& t, const gmp_rational& o); struct gmp_rational { #ifdef BOOST_HAS_LONG_LONG using signed_types = std::tuple<long, long long> ; using unsigned_types = std::tuple<unsigned long, unsigned long long>; #else using signed_types = std::tuple<long> ; using unsigned_types = std::tuple<unsigned long>; #endif using float_types = std::tuple<double, long double>; gmp_rational() { mpq_init(this->m_data); } gmp_rational(const gmp_rational& o) { mpq_init(m_data); if (o.m_data[0]._mp_num._mp_d) mpq_set(m_data, o.m_data); } gmp_rational(const gmp_int& o) { mpz_init_set(&m_data[0]._mp_num, o.data()); mpz_init_set_ui(&m_data[0]._mp_den, 1u); } gmp_rational(long i) { mpz_init_set_si(&m_data[0]._mp_num, i); mpz_init_set_ui(&m_data[0]._mp_den, 1u); } gmp_rational(unsigned long ui) { mpz_init_set_ui(&m_data[0]._mp_num, ui); mpz_init_set_ui(&m_data[0]._mp_den, 1u); } // 2-arg constructors: template <class T, class U> gmp_rational(const T& a, const U& b, typename std::enable_if<std::is_constructible<gmp_int, T>::value && std::is_constructible<gmp_int, U>::value>::type* = nullptr) { gmp_int i(a), j(b); if (eval_is_zero(j)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); m_data[0]._mp_num = i.data()[0]; m_data[0]._mp_den = j.data()[0]; mpq_canonicalize(m_data); i.data()[0]._mp_d = nullptr; j.data()[0]._mp_d = nullptr; } template <class U> gmp_rational(const gmp_int& a, const U& b, typename std::enable_if<std::is_constructible<gmp_int, U>::value>::type* = nullptr) { gmp_int j(b); if (eval_is_zero(j)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_init_set(&m_data[0]._mp_num, a.data()); m_data[0]._mp_den = j.data()[0]; if (boost::multiprecision::detail::unsigned_abs(b) > 1) mpq_canonicalize(m_data); j.data()[0]._mp_d = nullptr; } template <class U> gmp_rational(gmp_int&& a, const U& b, typename std::enable_if<std::is_constructible<gmp_int, U>::value>::type* = nullptr) { gmp_int j(b); if (eval_is_zero(j)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); m_data[0]._mp_num = a.data()[0]; m_data[0]._mp_den = j.data()[0]; if (boost::multiprecision::detail::unsigned_abs(b) > 1) mpq_canonicalize(m_data); a.data()[0]._mp_d = nullptr; j.data()[0]._mp_d = nullptr; } template <class T> gmp_rational(const T& a, const gmp_int& b, typename std::enable_if<std::is_constructible<gmp_int, T>::value>::type* = nullptr) { if (eval_is_zero(b)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); gmp_int i(a); m_data[0]._mp_num = i.data()[0]; mpz_init_set(&m_data[0]._mp_den, b.data()); if(boost::multiprecision::detail::unsigned_abs(a) > 1) mpq_canonicalize(m_data); i.data()[0]._mp_d = nullptr; } template <class T> gmp_rational(const T& a, gmp_int&& b, typename std::enable_if<std::is_constructible<gmp_int, T>::value>::type* = nullptr) { if (eval_is_zero(static_cast<gmp_int&&>(b))) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); gmp_int i(a); m_data[0]._mp_num = i.data()[0]; m_data[0]._mp_den = b.data()[0]; if(boost::multiprecision::detail::unsigned_abs(a) > 1) mpq_canonicalize(m_data); i.data()[0]._mp_d = nullptr; b.data()[0]._mp_d = nullptr; } gmp_rational(const gmp_int& a, const gmp_int& b) { if (eval_is_zero(b)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_init_set(&m_data[0]._mp_num, a.data()); mpz_init_set(&m_data[0]._mp_den, b.data()); mpq_canonicalize(m_data); } gmp_rational(const gmp_int& a, gmp_int&& b) { if (eval_is_zero(static_cast<gmp_int&&>(b))) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_init_set(&m_data[0]._mp_num, a.data()); m_data[0]._mp_den = b.data()[0]; mpq_canonicalize(m_data); b.data()[0]._mp_d = nullptr; } gmp_rational(gmp_int&& a, const gmp_int& b) { if (eval_is_zero(b)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); m_data[0]._mp_num = a.data()[0]; mpz_init_set(&m_data[0]._mp_den, b.data()); mpq_canonicalize(m_data); a.data()[0]._mp_d = nullptr; } gmp_rational(gmp_int&& a, gmp_int&& b) { if (eval_is_zero(static_cast<gmp_int&&>(b))) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); m_data[0]._mp_num = a.data()[0]; m_data[0]._mp_den = b.data()[0]; mpq_canonicalize(m_data); a.data()[0]._mp_d = nullptr; b.data()[0]._mp_d = nullptr; } // rvalue copy gmp_rational(gmp_rational&& o) noexcept { m_data[0] = o.m_data[0]; o.m_data[0]._mp_num._mp_d = nullptr; o.m_data[0]._mp_den._mp_d = nullptr; } gmp_rational(const mpq_t o) { mpq_init(m_data); mpq_set(m_data, o); } gmp_rational(const mpz_t o) { mpq_init(m_data); mpq_set_z(m_data, o); } gmp_rational& operator=(const gmp_rational& o) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); mpq_set(m_data, o.m_data); return *this; } // rvalue assign gmp_rational& operator=(gmp_rational&& o) noexcept { mpq_swap(m_data, o.m_data); return *this; } #ifdef BOOST_HAS_LONG_LONG #if defined(ULLONG_MAX) && (ULLONG_MAX == ULONG_MAX) gmp_rational& operator=(unsigned long long i) { *this = static_cast<unsigned long>(i); return *this; } #else gmp_rational& operator=(unsigned long long i) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); gmp_int zi; zi = i; mpq_set_z(m_data, zi.data()); return *this; } gmp_rational& operator=(long long i) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); bool neg = i < 0; *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) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); mpq_set_ui(m_data, i, 1); return *this; } gmp_rational& operator=(long i) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); mpq_set_si(m_data, i, 1); return *this; } gmp_rational& operator=(double d) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); mpq_set_d(m_data, d); return *this; } template <class F> gmp_rational& assign_float(F a) { using default_ops::eval_add; using default_ops::eval_subtract; BOOST_MP_FLOAT128_USING using std::floor; using std::frexp; using std::ldexp; if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); if (a == 0) { mpq_set_si(m_data, 0, 1); return *this; } if (a == 1) { mpq_set_si(m_data, 1, 1); return *this; } BOOST_MP_ASSERT(!BOOST_MP_ISINF(a)); BOOST_MP_ASSERT(!BOOST_MP_ISNAN(a)); int e; F f, term; mpq_set_ui(m_data, 0, 1); mpq_set_ui(m_data, 0u, 1); gmp_rational t; f = frexp(a, &e); constexpr int shift = std::numeric_limits<int>::digits - 1; while (f != static_cast<F>(0.0f)) { // extract int sized bits from f: f = ldexp(f, shift); term = floor(f); e -= shift; mpq_mul_2exp(m_data, m_data, shift); t = static_cast<long>(term); eval_add(*this, t); f -= term; } if (e > 0) mpq_mul_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(e)); else if (e < 0) mpq_div_2exp(m_data, m_data, static_cast<mp_bitcnt_t>(-e)); return *this; } gmp_rational& operator=(long double a) { return assign_float(a); } #ifdef BOOST_HAS_FLOAT128 gmp_rational& operator=(float128_type a) { return assign_float(a); } #endif #ifdef BOOST_HAS_INT128 gmp_rational& operator=(uint128_type i) { gmp_int gi; gi = i; return *this = gi; } gmp_rational& operator=(int128_type i) { gmp_int gi; gi = i; return *this = gi; } #endif gmp_rational& operator=(const char* s) { if (m_data[0]._mp_den._mp_d == nullptr) mpq_init(m_data); if (0 != mpq_set_str(m_data, s, 10)) BOOST_MP_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 == nullptr) 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 == nullptr) 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 == nullptr) mpq_init(m_data); mpq_set_z(m_data, o); return *this; } void swap(gmp_rational& o) { mpq_swap(m_data, o.m_data); } std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags /*f*/) const { BOOST_MP_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(nullptr, 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) mpq_clear(m_data); } void negate() { BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d); mpq_neg(m_data, m_data); } int compare(const gmp_rational& o) const { BOOST_MP_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 { gmp_rational d; d = v; return compare(d); } int compare(unsigned long v) const { BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d); return mpq_cmp_ui(m_data, v, 1); } int compare(long v) const { BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d); return mpq_cmp_si(m_data, v, 1); } mpq_t& data() { BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d); return m_data; } const mpq_t& data() const { BOOST_MP_ASSERT(m_data[0]._mp_num._mp_d); return m_data; } protected: mpq_t m_data; }; inline bool eval_is_zero(const gmp_rational& val) { return mpq_sgn(val.data()) == 0; } template <class T> inline bool eval_eq(gmp_rational& a, const T& b) { return a.compare(b) == 0; } template <class T> inline bool eval_lt(gmp_rational& a, const T& b) { return a.compare(b) < 0; } template <class T> inline bool eval_gt(gmp_rational& a, const T& b) { return a.compare(b) > 0; } inline void eval_add(gmp_rational& t, const gmp_rational& o) { mpq_add(t.data(), t.data(), o.data()); } inline void eval_subtract(gmp_rational& t, const gmp_rational& o) { mpq_sub(t.data(), t.data(), o.data()); } inline void eval_multiply(gmp_rational& t, const gmp_rational& o) { mpq_mul(t.data(), t.data(), o.data()); } inline void eval_divide(gmp_rational& t, const gmp_rational& o) { if (eval_is_zero(o)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpq_div(t.data(), t.data(), o.data()); } inline void eval_add(gmp_rational& t, const gmp_rational& p, const gmp_rational& o) { mpq_add(t.data(), p.data(), o.data()); } inline void eval_subtract(gmp_rational& t, const gmp_rational& p, const gmp_rational& o) { mpq_sub(t.data(), p.data(), o.data()); } inline void eval_multiply(gmp_rational& t, const gmp_rational& p, const gmp_rational& o) { mpq_mul(t.data(), p.data(), o.data()); } inline void eval_divide(gmp_rational& t, const gmp_rational& p, const gmp_rational& o) { if (eval_is_zero(o)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpq_div(t.data(), p.data(), o.data()); } // // operator with scalars: // inline void eval_add(gmp_rational& result, gmp_rational const& a, gmp_int const& b) { // we allow result and a to be the same object here: if (&a != &result) { mpz_set(mpq_numref(result.data()), mpq_numref(a.data())); mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } mpz_addmul(mpq_numref(result.data()), mpq_denref(a.data()), b.data()); // no need to normalize, there can be no common divisor as long as a is already normalized. } inline void eval_add(gmp_rational& result, gmp_rational const& a, unsigned long b) { // we allow result and a to be the same object here: if (&a != &result) { mpz_set(mpq_numref(result.data()), mpq_numref(a.data())); mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } mpz_addmul_ui(mpq_numref(result.data()), mpq_denref(a.data()), b); // no need to normalize, there can be no common divisor as long as a is already normalized. } inline void eval_add(gmp_rational& result, gmp_rational const& a, long b) { // we allow result and a to be the same object here: if (&a != &result) { mpz_set(mpq_numref(result.data()), mpq_numref(a.data())); mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if(b > 0) mpz_addmul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(b)); else mpz_submul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(-b)); // no need to normalize, there can be no common divisor as long as a is already normalized. } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_add(gmp_rational& result, gmp_rational const& a, const T& b) { gmp_int t; t = b; eval_add(result, a, t); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_add(gmp_rational& result, const T& b, gmp_rational const& a) { eval_add(result, a, b); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_add(gmp_rational& result, const T& b) { eval_add(result, result, b); } inline void eval_subtract(gmp_rational& result, gmp_rational const& a, gmp_int const& b) { // we allow result and a to be the same object here: if (&a != &result) { mpz_set(mpq_numref(result.data()), mpq_numref(a.data())); mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } mpz_submul(mpq_numref(result.data()), mpq_denref(a.data()), b.data()); // no need to normalize, there can be no common divisor as long as a is already normalized. } inline void eval_subtract(gmp_rational& result, gmp_rational const& a, unsigned long b) { // we allow result and a to be the same object here: if (&a != &result) { mpz_set(mpq_numref(result.data()), mpq_numref(a.data())); mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } mpz_submul_ui(mpq_numref(result.data()), mpq_denref(a.data()), b); // no need to normalize, there can be no common divisor as long as a is already normalized. } inline void eval_subtract(gmp_rational& result, gmp_rational const& a, long b) { // we allow result and a to be the same object here: if (&a != &result) { mpz_set(mpq_numref(result.data()), mpq_numref(a.data())); mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if(b > 0) mpz_submul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(b)); else mpz_addmul_ui(mpq_numref(result.data()), mpq_denref(a.data()), static_cast<local_uint_type>(-b)); // no need to normalize, there can be no common divisor as long as a is already normalized. } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_subtract(gmp_rational& result, gmp_rational const& a, const T& b) { gmp_int t; t = b; eval_subtract(result, a, t); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_subtract(gmp_rational& result, const T& b, gmp_rational const& a) { eval_subtract(result, a, b); result.negate(); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_subtract(gmp_rational& result, const T& b) { eval_subtract(result, result, b); } inline void eval_multiply(gmp_rational& result, gmp_rational const& a, gmp_int const& b) { gmp_int g, t; mpz_gcd(g.data(), mpq_denref(a.data()), b.data()); if (!mpz_fits_uint_p(g.data()) || (mpz_get_ui(g.data()) != 1)) { // We get here if the gcd is not unity, this is true if the number is // too large for an unsigned long, or if we get an unsigned long and check against 1. eval_divide(t, b, g); mpz_mul(mpq_numref(result.data()), t.data(), mpq_numref(a.data())); mpz_divexact(mpq_denref(result.data()), mpq_denref(a.data()), g.data()); } else { // gcd is 1. mpz_mul(mpq_numref(result.data()), mpq_numref(a.data()), b.data()); if (&result != &a) mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } } inline void eval_multiply(gmp_rational& result, gmp_rational const& a, unsigned long b) { if (b == 0) { mpq_set_ui(result.data(), b, 1); return; } if (mpz_sgn(mpq_numref(a.data())) == 0) { result = a; return; } unsigned long g = static_cast<unsigned long>(mpz_gcd_ui(nullptr, mpq_denref(a.data()), b)); if (g != 1) { BOOST_MP_ASSERT(g); b /= g; mpz_mul_ui(mpq_numref(result.data()), mpq_numref(a.data()), b); mpz_divexact_ui(mpq_denref(result.data()), mpq_denref(a.data()), g); } else { mpz_mul_ui(mpq_numref(result.data()), mpq_numref(a.data()), b); if (&result != &a) mpz_set(mpq_denref(result.data()), mpq_denref(a.data())); } } inline void eval_multiply(gmp_rational& result, gmp_rational const& a, long b) { eval_multiply(result, a, boost::multiprecision::detail::unsigned_abs(b)); if (b < 0) result.negate(); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_multiply(gmp_rational& result, gmp_rational const& a, const T& b) { gmp_int t; t = b; eval_multiply(result, a, t); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_multiply(gmp_rational& result, const T& b, gmp_rational const& a) { eval_multiply(result, a, b); } template <class T> inline typename std::enable_if<boost::multiprecision::detail::is_integral<T>::value>::type eval_multiply(gmp_rational& result, const T& b) { eval_multiply(result, result, b); } inline int eval_get_sign(const gmp_rational& val) { return mpq_sgn(val.data()); } template <class R> inline typename std::enable_if<number_category<R>::value == number_kind_floating_point>::type eval_convert_to(R* result, const gmp_rational& backend) { // // The generic conversion is as good as anything we can write here: // // This does not round correctly: // //*result = mpq_get_d(val.data()); // // This does: // ::boost::multiprecision::detail::generic_convert_rational_to_float(*result, backend); } #ifdef BOOST_HAS_FLOAT128 inline void eval_convert_to(float128_type* result, const gmp_rational& val) { using default_ops::eval_convert_to; gmp_int n, d; float128_type fn, fd; mpz_set(n.data(), mpq_numref(val.data())); mpz_set(d.data(), mpq_denref(val.data())); eval_convert_to(&fn, n); eval_convert_to(&fd, d); *result = fn / fd; } #endif template <class R> inline typename std::enable_if<number_category<R>::value == number_kind_integer>::type eval_convert_to(R* result, const gmp_rational& backend) { gmp_int n(mpq_numref(backend.data())); gmp_int d(mpq_denref(backend.data())); using default_ops::eval_divide; eval_divide(n, d); using default_ops::eval_convert_to; eval_convert_to(result, n); } inline void eval_abs(gmp_rational& result, const gmp_rational& val) { mpq_abs(result.data(), val.data()); } inline void assign_components(gmp_rational& result, unsigned long v1, unsigned long v2) { if (v2 == 0u) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpq_set_ui(result.data(), v1, v2); mpq_canonicalize(result.data()); } inline void assign_components(gmp_rational& result, long v1, long v2) { if (v2 == 0) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); using local_uint_type = typename boost::multiprecision::detail::make_unsigned<long>::type; if (v2 < 0) mpq_set_si(result.data(), -v1, static_cast<local_uint_type>(-v2)); else mpq_set_si(result.data(), v1, static_cast<local_uint_type>(v2)); mpq_canonicalize(result.data()); } inline void assign_components(gmp_rational& result, gmp_int const& v1, gmp_int const& v2) { if (eval_is_zero(v2)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_set(mpq_numref(result.data()), v1.data()); mpz_set(mpq_denref(result.data()), v2.data()); mpq_canonicalize(result.data()); } template <class T, class U> void assign_components(gmp_rational& result, const T& a, const U& b) { gmp_int x, y; x = a; y = b; if (eval_is_zero(y)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); std::swap(result.data()[0]._mp_num, x.data()[0]); std::swap(result.data()[0]._mp_den, y.data()[0]); mpq_canonicalize(result.data()); } template <class U> void assign_components(gmp_rational& result, const gmp_int& a, const U& b) { gmp_int y; y = b; if (eval_is_zero(y)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); mpz_set(&result.data()[0]._mp_num, a.data()); std::swap(result.data()[0]._mp_den, y.data()[0]); mpq_canonicalize(result.data()); } template <class T> void assign_components(gmp_rational& result, const T& a, const gmp_int& b) { if (eval_is_zero(b)) BOOST_MP_THROW_EXCEPTION(std::overflow_error("Division by zero.")); gmp_int x; x = a; std::swap(result.data()[0]._mp_num, x.data()[0]); mpz_set(&result.data()[0]._mp_den, b.data()); mpq_canonicalize(result.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) boost::multiprecision::detail::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) boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_den._mp_d[i]); boost::multiprecision::detail::hash_combine(result, val.data()[0]._mp_num._mp_size); return result; } // // Some useful helpers: // inline std::size_t used_gmp_int_bits(const gmp_int& val) { return eval_msb(val) - eval_lsb(val) + 1; } inline std::size_t used_gmp_rational_bits(const gmp_rational& val) { unsigned d2_d = static_cast<unsigned>(mpz_sizeinbase(mpq_denref(val.data()), 2) - mpz_scan1(mpq_denref(val.data()), 0)); unsigned d2_n = static_cast<unsigned>(mpz_sizeinbase(mpq_numref(val.data()), 2) - mpz_scan1(mpq_numref(val.data()), 0)); return (std::max)(d2_d, d2_n); } // // Some member functions that are dependent upon previous code go here: // template <unsigned Digits10> template <unsigned D> inline gmp_float<Digits10>::gmp_float(const gmp_float<D>& o, typename std::enable_if<D <= Digits10>::type*) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision())); mpf_set(this->m_data, o.data()); } template <unsigned Digits10> template <unsigned D> inline gmp_float<Digits10>::gmp_float(const gmp_float<D>& o, typename std::enable_if< !(D <= Digits10)>::type*) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision())); mpf_set(this->m_data, o.data()); } template <unsigned Digits10> inline gmp_float<Digits10>::gmp_float(const gmp_int& o) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision())); mpf_set_z(this->data(), o.data()); } template <unsigned Digits10> inline gmp_float<Digits10>::gmp_float(const gmp_rational& o) { mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision())); mpf_set_q(this->data(), o.data()); } template <unsigned Digits10> template <unsigned D> inline gmp_float<Digits10>& gmp_float<Digits10>::operator=(const gmp_float<D>& o) { if (this->m_data[0]._mp_d == nullptr) mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)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 == nullptr) mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)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 == nullptr) mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(Digits10 ? Digits10 : (unsigned)this->get_default_precision())); mpf_set_q(this->data(), o.data()); return *this; } inline gmp_float<0>::gmp_float(const gmp_int& o) : requested_precision(get_default_precision()) { if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) { std::size_t d2 = used_gmp_int_bits(o); std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(d2); if (d10 > requested_precision) requested_precision = static_cast<unsigned>(d10); } mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); mpf_set_z(this->data(), o.data()); } inline gmp_float<0>::gmp_float(const gmp_rational& o) : requested_precision(get_default_precision()) { if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) { std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(o)); if (d10 > requested_precision) requested_precision = static_cast<unsigned>(d10); } mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); mpf_set_q(this->data(), o.data()); } inline gmp_float<0>& gmp_float<0>::operator=(const gmp_int& o) { if (this->m_data[0]._mp_d == nullptr) { requested_precision = this->get_default_precision(); if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) { std::size_t d2 = used_gmp_int_bits(o); std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(d2); if (d10 > requested_precision) requested_precision = static_cast<unsigned>(d10); } mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) { std::size_t d2 = used_gmp_int_bits(o); std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(d2); if (d10 > requested_precision) this->precision(static_cast<unsigned>(d10)); } 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 == nullptr) { requested_precision = this->get_default_precision(); if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) { std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(o)); if (d10 > requested_precision) requested_precision = static_cast<unsigned>(d10); } mpf_init2(this->m_data, multiprecision::detail::digits10_2_2(requested_precision)); } else if (thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) { std::size_t d10 = 1 + multiprecision::detail::digits2_2_10(used_gmp_rational_bits(o)); if (d10 > requested_precision) this->precision(static_cast<unsigned>(d10)); } mpf_set_q(this->data(), o.data()); return *this; } inline gmp_int::gmp_int(const gmp_rational& o) { mpz_init(this->m_data); mpz_set_q(this->m_data, o.data()); } inline gmp_int& gmp_int::operator=(const gmp_rational& o) { if (this->m_data[0]._mp_d == nullptr) mpz_init(this->m_data); mpz_set_q(this->m_data, o.data()); return *this; } } //namespace backends template <expression_template_option ExpressionTemplates> struct component_type<number<gmp_rational, ExpressionTemplates> > { using type = number<gmp_int, ExpressionTemplates>; }; template <expression_template_option ET> inline number<gmp_int, ET> numerator(const number<gmp_rational, ET>& val) { number<gmp_int, ET> result; mpz_set(result.backend().data(), (mpq_numref(val.backend().data()))); return result; } template <expression_template_option ET> inline number<gmp_int, ET> denominator(const number<gmp_rational, ET>& val) { number<gmp_int, ET> result; mpz_set(result.backend().data(), (mpq_denref(val.backend().data()))); return result; } namespace detail { template <> struct digits2<number<gmp_float<0>, et_on> > { static long value() { return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision())); } }; template <> struct digits2<number<gmp_float<0>, et_off> > { static long value() { return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision())); } }; template <> struct digits2<number<debug_adaptor<gmp_float<0> >, et_on> > { static long value() { return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision())); } }; template <> struct digits2<number<debug_adaptor<gmp_float<0> >, et_off> > { static long value() { return static_cast<long>(multiprecision::detail::digits10_2_2(gmp_float<0>::thread_default_precision())); } }; template <unsigned Digits10> struct transcendental_reduction_type<boost::multiprecision::backends::gmp_float<Digits10> > { // // The type used for trigonometric reduction needs 3 times the precision of the base type. // This is double the precision of the original type, plus the largest exponent supported. // As a practical measure the largest argument supported is 1/eps, as supporting larger // arguments requires the division of argument by PI/2 to also be done at higher precision, // otherwise the result (an integer) can not be represented exactly. // // See ARGUMENT REDUCTION FOR HUGE ARGUMENTS. K C Ng. // using type = boost::multiprecision::backends::gmp_float<Digits10 * 3>; }; } // namespace detail template <> struct number_category<detail::canonical<mpz_t, gmp_int>::type> : public std::integral_constant<int, number_kind_integer> {}; template <> struct number_category<detail::canonical<mpq_t, gmp_rational>::type> : public std::integral_constant<int, number_kind_rational> {}; template <> struct number_category<detail::canonical<mpf_t, gmp_float<0> >::type> : public std::integral_constant<int, number_kind_floating_point> {}; namespace detail { template <> struct is_variable_precision<backends::gmp_float<0> > : public std::integral_constant<bool, true> {}; } // namespace detail } // namespace multiprecision namespace math { namespace tools { #ifndef BOOST_MP_MATH_AVAILABLE template <typename T> inline int digits(); template <typename T> inline T max_value(); template <typename T> inline T min_value(); #endif // BOOST_MP_MATH_AVAILABLE inline void set_output_precision(const boost::multiprecision::mpf_float& val, std::ostream& os) { const int sz_prec = static_cast<int>(val.precision()); os << std::setprecision(sz_prec); } template <> inline int digits<boost::multiprecision::mpf_float>() #ifdef BOOST_MATH_NOEXCEPT noexcept #endif { return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::thread_default_precision())); } template <> inline int digits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, boost::multiprecision::et_off> >() #ifdef BOOST_MATH_NOEXCEPT noexcept #endif { return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::mpf_float::thread_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 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>::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 int digits<boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> > >() #ifdef BOOST_MATH_NOEXCEPT noexcept #endif { return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::thread_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 noexcept #endif { return static_cast<int>(multiprecision::detail::digits10_2_2(boost::multiprecision::number<boost::multiprecision::debug_adaptor<boost::multiprecision::mpf_float::backend_type> >::thread_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(); } 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::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 std { // // numeric_limits [partial] specializations for the types declared in this header: // template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> > { using number_type = boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates>; // // 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 calc_min() { number_type result(1); mpf_div_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1); return result; } static number_type calc_max() { number_type result(1); mpf_mul_2exp(result.backend().data(), result.backend().data(), (std::numeric_limits<mp_exp_t>::max)() / 64 + 1); return result; } static number_type calc_epsilon() { number_type result(1); mpf_div_2exp(result.backend().data(), result.backend().data(), std::numeric_limits<number_type>::digits - 1); return result; } public: static constexpr bool is_specialized = true; static number_type(min)() { // rely on C++11 thread safe initialization of statics: static const number_type value{calc_min()}; return value; } static number_type(max)() { static number_type value{calc_max()}; return value; } static constexpr number_type lowest() { return -(max)(); } static constexpr int digits = static_cast<int>((Digits10 * 1000L) / 301L + ((Digits10 * 1000L) % 301L ? 2 : 1)); static constexpr int digits10 = Digits10; // Have to allow for a possible extra limb inside the gmp data structure: static constexpr int max_digits10 = Digits10 + 3 + ((GMP_LIMB_BITS * 301L) / 1000L); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static number_type epsilon() { static const number_type value{calc_epsilon()}; return value; } // What value should this be???? static number_type round_error() { return 1; } static constexpr long min_exponent = LONG_MIN; static constexpr long min_exponent10 = (LONG_MIN / 1000) * 301L; static constexpr long max_exponent = LONG_MAX; static constexpr long max_exponent10 = (LONG_MAX / 1000) * 301L; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif static constexpr float_denorm_style has_denorm = denorm_absent; #ifdef _MSC_VER #pragma warning(pop) #endif static constexpr bool has_denorm_loss = false; static constexpr number_type infinity() { return number_type(); } static constexpr number_type quiet_NaN() { return number_type(); } static constexpr number_type signaling_NaN() { return number_type(); } static constexpr number_type denorm_min() { return (min)(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_indeterminate; }; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::digits; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::digits10; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::max_digits10; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_signed; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_integer; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_exact; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::radix; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::min_exponent; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::min_exponent10; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::max_exponent; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr long numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::max_exponent10; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_infinity; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_quiet_NaN; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_signaling_NaN; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_denorm; #ifdef _MSC_VER #pragma warning(pop) #endif template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::has_denorm_loss; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_iec559; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_bounded; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::is_modulo; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::traps; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::tinyness_before; template <unsigned Digits10, boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<Digits10>, ExpressionTemplates> >::round_style; template <boost::multiprecision::expression_template_option ExpressionTemplates> class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> > { using number_type = boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates>; public: 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(); } static constexpr int digits = 0; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 0; static number_type epsilon() { return number_type(); } static number_type round_error() { return number_type(); } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif static constexpr float_denorm_style has_denorm = denorm_absent; #ifdef _MSC_VER #pragma warning(pop) #endif 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(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_indeterminate; }; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::digits; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_signed; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_integer; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_exact; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::radix; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::min_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::min_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::max_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_infinity; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_quiet_NaN; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_signaling_NaN; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_denorm; #ifdef _MSC_VER #pragma warning(pop) #endif template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::has_denorm_loss; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_iec559; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_bounded; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::is_modulo; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::traps; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::tinyness_before; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> >::round_style; template <boost::multiprecision::expression_template_option ExpressionTemplates> class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> > { using number_type = boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates>; public: static constexpr bool is_specialized = true; // // Largest and smallest numbers are bounded only by available memory, set // to zero: // static number_type(min)() { return number_type(); } static number_type(max)() { return number_type(); } static number_type lowest() { return (min)(); } static constexpr int digits = INT_MAX; static constexpr int digits10 = (INT_MAX / 1000) * 301L; static constexpr int max_digits10 = digits10 + 3; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static number_type epsilon() { return number_type(); } static number_type round_error() { return number_type(); } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif static constexpr float_denorm_style has_denorm = denorm_absent; #ifdef _MSC_VER #pragma warning(pop) #endif 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(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::digits; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_signed; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_integer; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_exact; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::radix; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::min_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::min_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::max_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_infinity; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_quiet_NaN; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_signaling_NaN; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_denorm; #ifdef _MSC_VER #pragma warning(pop) #endif template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::has_denorm_loss; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_iec559; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_bounded; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::is_modulo; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::traps; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::tinyness_before; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_int, ExpressionTemplates> >::round_style; template <boost::multiprecision::expression_template_option ExpressionTemplates> class numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> > { using number_type = boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates>; public: static constexpr bool is_specialized = true; // // Largest and smallest numbers are bounded only by available memory, set // to zero: // static number_type(min)() { return number_type(); } static number_type(max)() { return number_type(); } static number_type lowest() { return (min)(); } // Digits are unbounded, use zero for now: static constexpr int digits = INT_MAX; static constexpr int digits10 = (INT_MAX / 1000) * 301L; static constexpr int max_digits10 = digits10 + 3; static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = true; static constexpr int radix = 2; static number_type epsilon() { return number_type(); } static number_type round_error() { return number_type(); } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif static constexpr float_denorm_style has_denorm = denorm_absent; #ifdef _MSC_VER #pragma warning(pop) #endif 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 (min)(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_signed; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_integer; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_exact; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::radix; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::min_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::max_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_infinity; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_quiet_NaN; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_signaling_NaN; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) #endif template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm; #ifdef _MSC_VER #pragma warning(pop) #endif template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::has_denorm_loss; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_iec559; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_bounded; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::is_modulo; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::traps; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::tinyness_before; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::gmp_rational, ExpressionTemplates> >::round_style; #ifdef BOOST_MSVC #pragma warning(pop) #endif } // namespace std namespace Eigen { template <class B1, class B2> struct NumTraitsImp; template <boost::multiprecision::expression_template_option ExpressionTemplates> struct NumTraitsImp<boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates>, boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates> > { using self_type = boost::multiprecision::number<boost::multiprecision::gmp_float<0>, ExpressionTemplates>; using Real = typename boost::multiprecision::scalar_result_from_possible_complex<self_type>::type; using NonInteger = self_type; // Not correct but we can't do much better?? using Literal = double; using Nested = self_type; enum { IsComplex = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_complex, IsInteger = boost::multiprecision::number_category<self_type>::value == boost::multiprecision::number_kind_integer, ReadCost = 1, AddCost = 4, MulCost = 8, IsSigned = std::numeric_limits<self_type>::is_specialized ? std::numeric_limits<self_type>::is_signed : true, RequireInitialization = 1, }; static Real highest() noexcept { return boost::math::tools::max_value<Real>(); } static Real lowest() noexcept { return boost::math::tools::min_value<Real>(); } static int digits() noexcept { return boost::math::tools::digits<Real>(); } static int digits10() { return Real::thread_default_precision(); } static Real epsilon() { return ldexp(Real(1), 1 - digits()); } static Real dummy_precision() { return 1000 * epsilon(); } static constexpr long min_exponent() noexcept { return LONG_MIN; } static constexpr long max_exponent() noexcept { return LONG_MAX; } static Real infinity() { return Real(); } static Real quiet_NaN() { return Real(); } }; } #endif