Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //  Copyright 2011 John Maddock. Distributed under the Boost
Chris@16: //  Software License, Version 1.0. (See accompanying file
Chris@16: //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: #ifndef BOOST_MATH_MP_TOMMATH_BACKEND_HPP
Chris@16: #define BOOST_MATH_MP_TOMMATH_BACKEND_HPP
Chris@16: 
Chris@16: #include <boost/multiprecision/number.hpp>
Chris@16: #include <boost/multiprecision/rational_adaptor.hpp>
Chris@16: #include <boost/multiprecision/detail/integer_ops.hpp>
Chris@16: #include <boost/math/special_functions/fpclassify.hpp>
Chris@16: #include <boost/cstdint.hpp>
Chris@16: #include <boost/scoped_array.hpp>
Chris@16: #include <tommath.h>
Chris@16: #include <cmath>
Chris@16: #include <limits>
Chris@16: #include <climits>
Chris@16: 
Chris@16: namespace boost{ namespace multiprecision{ namespace backends{
Chris@16: 
Chris@16: namespace detail{
Chris@16: 
Chris@16: inline void check_tommath_result(unsigned v)
Chris@16: {
Chris@16:    if(v != MP_OKAY)
Chris@16:    {
Chris@16:       BOOST_THROW_EXCEPTION(std::runtime_error(mp_error_to_string(v)));
Chris@16:    }
Chris@16: }
Chris@16: 
Chris@16: }
Chris@16: 
Chris@16: struct tommath_int;
Chris@16: 
Chris@16: void eval_multiply(tommath_int& t, const tommath_int& o);
Chris@16: void eval_add(tommath_int& t, const tommath_int& o);
Chris@16: 
Chris@16: struct tommath_int
Chris@16: {
Chris@16:    typedef mpl::list<boost::int32_t, long long>             signed_types;
Chris@16:    typedef mpl::list<boost::uint32_t, unsigned long long>   unsigned_types;
Chris@16:    typedef mpl::list<long double>                           float_types;
Chris@16: 
Chris@16:    tommath_int()
Chris@16:    {
Chris@16:       detail::check_tommath_result(mp_init(&m_data));
Chris@16:    }
Chris@16:    tommath_int(const tommath_int& o)
Chris@16:    {
Chris@16:       detail::check_tommath_result(mp_init_copy(&m_data, const_cast< ::mp_int*>(&o.m_data)));
Chris@16:    }
Chris@16: #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
Chris@16:    tommath_int(tommath_int&& o) BOOST_NOEXCEPT
Chris@16:    {
Chris@16:       m_data = o.m_data;
Chris@16:       o.m_data.dp = 0;
Chris@16:    }
Chris@16:    tommath_int& operator = (tommath_int&& o)
Chris@16:    {
Chris@101:       mp_exch(&m_data, &o.m_data);
Chris@16:       return *this;
Chris@16:    }
Chris@16: #endif
Chris@16:    tommath_int& operator = (const tommath_int& o)
Chris@16:    {
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16:       if(o.m_data.dp)
Chris@16:          detail::check_tommath_result(mp_copy(const_cast< ::mp_int*>(&o.m_data), &m_data));
Chris@16:       return *this;
Chris@16:    }
Chris@16:    tommath_int& operator = (unsigned long long i)
Chris@16:    {
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16:       unsigned long long mask = ((1uLL << std::numeric_limits<unsigned>::digits) - 1);
Chris@16:       unsigned shift = 0;
Chris@16:       ::mp_int t;
Chris@16:       detail::check_tommath_result(mp_init(&t));
Chris@16:       mp_zero(&m_data);
Chris@16:       while(i)
Chris@16:       {
Chris@16:          detail::check_tommath_result(mp_set_int(&t, static_cast<unsigned>(i & mask)));
Chris@16:          if(shift)
Chris@16:             detail::check_tommath_result(mp_mul_2d(&t, shift, &t));
Chris@16:          detail::check_tommath_result((mp_add(&m_data, &t, &m_data)));
Chris@16:          shift += std::numeric_limits<unsigned>::digits;
Chris@16:          i >>= std::numeric_limits<unsigned>::digits;
Chris@16:       }
Chris@16:       mp_clear(&t);
Chris@16:       return *this;
Chris@16:    }
Chris@16:    tommath_int& operator = (long long i)
Chris@16:    {
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16:       bool neg = i < 0;
Chris@101:       *this = boost::multiprecision::detail::unsigned_abs(i);
Chris@16:       if(neg)
Chris@16:          detail::check_tommath_result(mp_neg(&m_data, &m_data));
Chris@16:       return *this;
Chris@16:    }
Chris@16:    //
Chris@16:    // Note that although mp_set_int takes an unsigned long as an argument
Chris@16:    // it only sets the first 32-bits to the result, and ignores the rest.
Chris@16:    // So use uint32_t as the largest type to pass to this function.
Chris@16:    //
Chris@16:    tommath_int& operator = (boost::uint32_t i)
Chris@16:    {
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16:       detail::check_tommath_result((mp_set_int(&m_data, i)));
Chris@16:       return *this;
Chris@16:    }
Chris@16:    tommath_int& operator = (boost::int32_t i)
Chris@16:    {
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16:       bool neg = i < 0;
Chris@16:       *this = static_cast<boost::uint32_t>(std::abs(i));
Chris@16:       if(neg)
Chris@16:          detail::check_tommath_result(mp_neg(&m_data, &m_data));
Chris@16:       return *this;
Chris@16:    }
Chris@16:    tommath_int& operator = (long double a)
Chris@16:    {
Chris@16:       using std::frexp;
Chris@16:       using std::ldexp;
Chris@16:       using std::floor;
Chris@16: 
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16: 
Chris@16:       if (a == 0) {
Chris@16:          detail::check_tommath_result(mp_set_int(&m_data, 0));
Chris@16:          return *this;
Chris@16:       }
Chris@16: 
Chris@16:       if (a == 1) {
Chris@16:          detail::check_tommath_result(mp_set_int(&m_data, 1));
Chris@16:          return *this;
Chris@16:       }
Chris@16: 
Chris@16:       BOOST_ASSERT(!(boost::math::isinf)(a));
Chris@16:       BOOST_ASSERT(!(boost::math::isnan)(a));
Chris@16: 
Chris@16:       int e;
Chris@16:       long double f, term;
Chris@16:       detail::check_tommath_result(mp_set_int(&m_data, 0u));
Chris@16:       ::mp_int t;
Chris@16:       detail::check_tommath_result(mp_init(&t));
Chris@16: 
Chris@16:       f = frexp(a, &e);
Chris@16: 
Chris@16:       static const int shift = std::numeric_limits<int>::digits - 1;
Chris@16: 
Chris@16:       while(f)
Chris@16:       {
Chris@16:          // extract int sized bits from f:
Chris@16:          f = ldexp(f, shift);
Chris@16:          term = floor(f);
Chris@16:          e -= shift;
Chris@16:          detail::check_tommath_result(mp_mul_2d(&m_data, shift, &m_data));
Chris@16:          if(term > 0)
Chris@16:          {
Chris@16:             detail::check_tommath_result(mp_set_int(&t, static_cast<int>(term)));
Chris@16:             detail::check_tommath_result(mp_add(&m_data, &t, &m_data));
Chris@16:          }
Chris@16:          else
Chris@16:          {
Chris@16:             detail::check_tommath_result(mp_set_int(&t, static_cast<int>(-term)));
Chris@16:             detail::check_tommath_result(mp_sub(&m_data, &t, &m_data));
Chris@16:          }
Chris@16:          f -= term;
Chris@16:       }
Chris@16:       if(e > 0)
Chris@16:          detail::check_tommath_result(mp_mul_2d(&m_data, e, &m_data));
Chris@16:       else if(e < 0)
Chris@16:       {
Chris@16:          tommath_int t2;
Chris@16:          detail::check_tommath_result(mp_div_2d(&m_data, -e, &m_data, &t2.data()));
Chris@16:       }
Chris@16:       mp_clear(&t);
Chris@16:       return *this;
Chris@16:    }
Chris@16:    tommath_int& operator = (const char* s)
Chris@16:    {
Chris@16:       //
Chris@16:       // We don't use libtommath's own routine because it doesn't error check the input :-(
Chris@16:       //
Chris@16:       if(m_data.dp == 0)
Chris@16:          detail::check_tommath_result(mp_init(&m_data));
Chris@16:       std::size_t n = s ? std::strlen(s) : 0;
Chris@16:       *this = static_cast<boost::uint32_t>(0u);
Chris@16:       unsigned radix = 10;
Chris@16:       bool isneg = false;
Chris@16:       if(n && (*s == '-'))
Chris@16:       {
Chris@16:          --n;
Chris@16:          ++s;
Chris@16:          isneg = true;
Chris@16:       }
Chris@16:       if(n && (*s == '0'))
Chris@16:       {
Chris@16:          if((n > 1) && ((s[1] == 'x') || (s[1] == 'X')))
Chris@16:          {
Chris@16:             radix = 16;
Chris@16:             s +=2;
Chris@16:             n -= 2;
Chris@16:          }
Chris@16:          else
Chris@16:          {
Chris@16:             radix = 8;
Chris@16:             n -= 1;
Chris@16:          }
Chris@16:       }
Chris@16:       if(n)
Chris@16:       {
Chris@16:          if(radix == 8 || radix == 16)
Chris@16:          {
Chris@16:             unsigned shift = radix == 8 ? 3 : 4;
Chris@16:             unsigned block_count = DIGIT_BIT / shift;
Chris@16:             unsigned block_shift = shift * block_count;
Chris@16:             unsigned long long val, block;
Chris@16:             while(*s)
Chris@16:             {
Chris@16:                block = 0;
Chris@16:                for(unsigned i = 0; (i < block_count); ++i)
Chris@16:                {
Chris@16:                   if(*s >= '0' && *s <= '9')
Chris@16:                      val = *s - '0';
Chris@16:                   else if(*s >= 'a' && *s <= 'f')
Chris@16:                      val = 10 + *s - 'a';
Chris@16:                   else if(*s >= 'A' && *s <= 'F')
Chris@16:                      val = 10 + *s - 'A';
Chris@16:                   else
Chris@16:                      val = 400;
Chris@16:                   if(val > radix)
Chris@16:                   {
Chris@16:                      BOOST_THROW_EXCEPTION(std::runtime_error("Unexpected content found while parsing character string."));
Chris@16:                   }
Chris@16:                   block <<= shift;
Chris@16:                   block |= val;
Chris@16:                   if(!*++s)
Chris@16:                   {
Chris@16:                      // final shift is different:
Chris@16:                      block_shift = (i + 1) * shift;
Chris@16:                      break;
Chris@16:                   }
Chris@16:                }
Chris@16:                detail::check_tommath_result(mp_mul_2d(&data(), block_shift, &data()));
Chris@16:                if(data().used)
Chris@16:                   data().dp[0] |= block;
Chris@16:                else
Chris@16:                   *this = block;
Chris@16:             }
Chris@16:          }
Chris@16:          else
Chris@16:          {
Chris@16:             // Base 10, we extract blocks of size 10^9 at a time, that way
Chris@16:             // the number of multiplications is kept to a minimum:
Chris@16:             boost::uint32_t block_mult = 1000000000;
Chris@16:             while(*s)
Chris@16:             {
Chris@16:                boost::uint32_t block = 0;
Chris@16:                for(unsigned i = 0; i < 9; ++i)
Chris@16:                {
Chris@16:                   boost::uint32_t val;
Chris@16:                   if(*s >= '0' && *s <= '9')
Chris@16:                      val = *s - '0';
Chris@16:                   else
Chris@16:                      BOOST_THROW_EXCEPTION(std::runtime_error("Unexpected character encountered in input."));
Chris@16:                   block *= 10;
Chris@16:                   block += val;
Chris@16:                   if(!*++s)
Chris@16:                   {
Chris@16:                      static const boost::uint32_t block_multiplier[9]  = { 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
Chris@16:                      block_mult = block_multiplier[i];
Chris@16:                      break;
Chris@16:                   }
Chris@16:                }
Chris@16:                tommath_int t;
Chris@16:                t = block_mult;
Chris@16:                eval_multiply(*this, t);
Chris@16:                t = block;
Chris@16:                eval_add(*this, t);
Chris@16:             }
Chris@16:          }
Chris@16:       }
Chris@16:       if(isneg)
Chris@16:          this->negate();
Chris@16:       return *this;
Chris@16:    }
Chris@16:    std::string str(std::streamsize /*digits*/, std::ios_base::fmtflags f)const
Chris@16:    {
Chris@16:       BOOST_ASSERT(m_data.dp);
Chris@16:       int base = 10;
Chris@16:       if((f & std::ios_base::oct) == std::ios_base::oct)
Chris@16:          base = 8;
Chris@16:       else if((f & std::ios_base::hex) == std::ios_base::hex)
Chris@16:          base = 16;
Chris@16:       //
Chris@16:       // sanity check, bases 8 and 16 are only available for positive numbers:
Chris@16:       //
Chris@16:       if((base != 10) && m_data.sign)
Chris@16:          BOOST_THROW_EXCEPTION(std::runtime_error("Formatted output in bases 8 or 16 is only available for positive numbers"));
Chris@16:       int s;
Chris@16:       detail::check_tommath_result(mp_radix_size(const_cast< ::mp_int*>(&m_data), base, &s));
Chris@16:       boost::scoped_array<char> a(new char[s+1]);
Chris@16:       detail::check_tommath_result(mp_toradix_n(const_cast< ::mp_int*>(&m_data), a.get(), base, s+1));
Chris@16:       std::string result = a.get();
Chris@16:       if((base != 10) && (f & std::ios_base::showbase))
Chris@16:       {
Chris@16:          int pos = result[0] == '-' ? 1 : 0;
Chris@16:          const char* pp = base == 8 ? "0" : "0x";
Chris@101:          result.insert(static_cast<std::string::size_type>(pos), pp);
Chris@16:       }
Chris@16:       if((f & std::ios_base::showpos) && (result[0] != '-'))
Chris@101:          result.insert(static_cast<std::string::size_type>(0), 1, '+');
Chris@16:       return result;
Chris@16:    }
Chris@16:    ~tommath_int()
Chris@16:    {
Chris@16:       if(m_data.dp)
Chris@16:          mp_clear(&m_data);
Chris@16:    }
Chris@16:    void negate()
Chris@16:    {
Chris@16:       BOOST_ASSERT(m_data.dp);
Chris@16:       mp_neg(&m_data, &m_data);
Chris@16:    }
Chris@16:    int compare(const tommath_int& o)const
Chris@16:    {
Chris@16:       BOOST_ASSERT(m_data.dp && o.m_data.dp);
Chris@16:       return mp_cmp(const_cast< ::mp_int*>(&m_data), const_cast< ::mp_int*>(&o.m_data));
Chris@16:    }
Chris@16:    template <class V>
Chris@16:    int compare(V v)const
Chris@16:    {
Chris@16:       tommath_int d;
Chris@16:       tommath_int t(*this);
Chris@16:       detail::check_tommath_result(mp_shrink(&t.data()));
Chris@16:       d = v;
Chris@16:       return t.compare(d);
Chris@16:    }
Chris@16:    ::mp_int& data() 
Chris@16:    { 
Chris@16:       BOOST_ASSERT(m_data.dp);
Chris@16:       return m_data; 
Chris@16:    }
Chris@16:    const ::mp_int& data()const 
Chris@16:    { 
Chris@16:       BOOST_ASSERT(m_data.dp);
Chris@16:       return m_data; 
Chris@16:    }
Chris@16:    void swap(tommath_int& o)BOOST_NOEXCEPT
Chris@16:    {
Chris@16:       mp_exch(&m_data, &o.data());
Chris@16:    }
Chris@16: protected:
Chris@16:    ::mp_int m_data;
Chris@16: };
Chris@16: 
Chris@16: #define BOOST_MP_TOMMATH_BIT_OP_CHECK(x)\
Chris@16:    if(SIGN(&x.data()))\
Chris@16:       BOOST_THROW_EXCEPTION(std::runtime_error("Bitwise operations on libtommath negative valued integers are disabled as they produce unpredictable results"))
Chris@16: 
Chris@16: int eval_get_sign(const tommath_int& val);
Chris@16: 
Chris@16: inline void eval_add(tommath_int& t, const tommath_int& o)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_add(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16: }
Chris@16: inline void eval_subtract(tommath_int& t, const tommath_int& o)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_sub(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16: }
Chris@16: inline void eval_multiply(tommath_int& t, const tommath_int& o)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_mul(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16: }
Chris@16: inline void eval_divide(tommath_int& t, const tommath_int& o)
Chris@16: {
Chris@16:    using default_ops::eval_is_zero;
Chris@16:    tommath_int temp;
Chris@16:    if(eval_is_zero(o))
Chris@16:       BOOST_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
Chris@16:    detail::check_tommath_result(mp_div(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data(), &temp.data()));
Chris@16: }
Chris@16: inline void eval_modulus(tommath_int& t, const tommath_int& o)
Chris@16: {
Chris@16:    using default_ops::eval_is_zero;
Chris@16:    if(eval_is_zero(o))
Chris@16:       BOOST_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
Chris@16:    bool neg = eval_get_sign(t) < 0;
Chris@16:    bool neg2 = eval_get_sign(o) < 0;
Chris@16:    detail::check_tommath_result(mp_mod(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16:    if((neg != neg2) && (eval_get_sign(t) != 0))
Chris@16:    {
Chris@16:       t.negate();
Chris@16:       detail::check_tommath_result(mp_add(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16:       t.negate();
Chris@16:    }
Chris@16:    else if(neg && (t.compare(o) == 0))
Chris@16:    {
Chris@16:       mp_zero(&t.data());
Chris@16:    }
Chris@16: }
Chris@16: template <class UI>
Chris@16: inline void eval_left_shift(tommath_int& t, UI i)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_mul_2d(&t.data(), static_cast<unsigned>(i), &t.data()));
Chris@16: }
Chris@16: template <class UI>
Chris@16: inline void eval_right_shift(tommath_int& t, UI i)
Chris@16: {
Chris@16:    tommath_int d;
Chris@16:    detail::check_tommath_result(mp_div_2d(&t.data(), static_cast<unsigned>(i), &t.data(), &d.data()));
Chris@16: }
Chris@16: template <class UI>
Chris@16: inline void eval_left_shift(tommath_int& t, const tommath_int& v, UI i)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_mul_2d(const_cast< ::mp_int*>(&v.data()), static_cast<unsigned>(i), &t.data()));
Chris@16: }
Chris@16: template <class UI>
Chris@16: inline void eval_right_shift(tommath_int& t, const tommath_int& v, UI i)
Chris@16: {
Chris@16:    tommath_int d;
Chris@16:    detail::check_tommath_result(mp_div_2d(const_cast< ::mp_int*>(&v.data()), static_cast<unsigned long>(i), &t.data(), &d.data()));
Chris@16: }
Chris@16: 
Chris@16: inline void eval_bitwise_and(tommath_int& result, const tommath_int& v)
Chris@16: {
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(result);
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
Chris@16:    detail::check_tommath_result(mp_and(&result.data(), const_cast< ::mp_int*>(&v.data()), &result.data()));
Chris@16: }
Chris@16: 
Chris@16: inline void eval_bitwise_or(tommath_int& result, const tommath_int& v)
Chris@16: {
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(result);
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
Chris@16:    detail::check_tommath_result(mp_or(&result.data(), const_cast< ::mp_int*>(&v.data()), &result.data()));
Chris@16: }
Chris@16: 
Chris@16: inline void eval_bitwise_xor(tommath_int& result, const tommath_int& v)
Chris@16: {
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(result);
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
Chris@16:    detail::check_tommath_result(mp_xor(&result.data(), const_cast< ::mp_int*>(&v.data()), &result.data()));
Chris@16: }
Chris@16: 
Chris@16: inline void eval_add(tommath_int& t, const tommath_int& p, const tommath_int& o)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_add(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16: }
Chris@16: inline void eval_subtract(tommath_int& t, const tommath_int& p, const tommath_int& o)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_sub(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16: }
Chris@16: inline void eval_multiply(tommath_int& t, const tommath_int& p, const tommath_int& o)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_mul(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16: }
Chris@16: inline void eval_divide(tommath_int& t, const tommath_int& p, const tommath_int& o)
Chris@16: {
Chris@16:    using default_ops::eval_is_zero;
Chris@16:    tommath_int d;
Chris@16:    if(eval_is_zero(o))
Chris@16:       BOOST_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
Chris@16:    detail::check_tommath_result(mp_div(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data(), &d.data()));
Chris@16: }
Chris@16: inline void eval_modulus(tommath_int& t, const tommath_int& p, const tommath_int& o)
Chris@16: {
Chris@16:    using default_ops::eval_is_zero;
Chris@16:    if(eval_is_zero(o))
Chris@16:       BOOST_THROW_EXCEPTION(std::overflow_error("Integer division by zero"));
Chris@16:    bool neg = eval_get_sign(p) < 0;
Chris@16:    bool neg2 = eval_get_sign(o) < 0;
Chris@16:    detail::check_tommath_result(mp_mod(const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16:    if((neg != neg2) && (eval_get_sign(t) != 0))
Chris@16:    {
Chris@16:       t.negate();
Chris@16:       detail::check_tommath_result(mp_add(&t.data(), const_cast< ::mp_int*>(&o.data()), &t.data()));
Chris@16:       t.negate();
Chris@16:    }
Chris@16:    else if(neg  && (t.compare(o) == 0))
Chris@16:    {
Chris@16:       mp_zero(&t.data());
Chris@16:    }
Chris@16: }
Chris@16: 
Chris@16: inline void eval_bitwise_and(tommath_int& result, const tommath_int& u, const tommath_int& v)
Chris@16: {
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(u);
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
Chris@16:    detail::check_tommath_result(mp_and(const_cast< ::mp_int*>(&u.data()), const_cast< ::mp_int*>(&v.data()), &result.data()));
Chris@16: }
Chris@16: 
Chris@16: inline void eval_bitwise_or(tommath_int& result, const tommath_int& u, const tommath_int& v)
Chris@16: {
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(u);
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
Chris@16:    detail::check_tommath_result(mp_or(const_cast< ::mp_int*>(&u.data()), const_cast< ::mp_int*>(&v.data()), &result.data()));
Chris@16: }
Chris@16: 
Chris@16: inline void eval_bitwise_xor(tommath_int& result, const tommath_int& u, const tommath_int& v)
Chris@16: {
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(u);
Chris@16:    BOOST_MP_TOMMATH_BIT_OP_CHECK(v);
Chris@16:    detail::check_tommath_result(mp_xor(const_cast< ::mp_int*>(&u.data()), const_cast< ::mp_int*>(&v.data()), &result.data()));
Chris@16: }
Chris@16: /*
Chris@16: inline void eval_complement(tommath_int& result, const tommath_int& u)
Chris@16: {
Chris@16:    //
Chris@16:    // Although this code works, it doesn't really do what the user might expect....
Chris@16:    // and it's hard to see how it ever could.  Disabled for now:
Chris@16:    //
Chris@16:    result = u;
Chris@16:    for(int i = 0; i < result.data().used; ++i)
Chris@16:    {
Chris@16:       result.data().dp[i] = MP_MASK & ~(result.data().dp[i]);
Chris@16:    }
Chris@16:    //
Chris@16:    // We now need to pad out the left of the value with 1's to round up to a whole number of
Chris@16:    // CHAR_BIT * sizeof(mp_digit) units.  Otherwise we'll end up with a very strange number of
Chris@16:    // bits set!
Chris@16:    //
Chris@16:    unsigned shift = result.data().used * DIGIT_BIT;    // How many bits we're actually using
Chris@16:    // How many bits we actually need, reduced by one to account for a mythical sign bit:
Chris@16:    int padding = result.data().used * std::numeric_limits<mp_digit>::digits - shift - 1; 
Chris@16:    while(padding >= std::numeric_limits<mp_digit>::digits) 
Chris@16:       padding -= std::numeric_limits<mp_digit>::digits;
Chris@16: 
Chris@16:    // Create a mask providing the extra bits we need and add to result:
Chris@16:    tommath_int mask;
Chris@16:    mask = static_cast<long long>((1u << padding) - 1);
Chris@16:    eval_left_shift(mask, shift);
Chris@16:    add(result, mask);
Chris@16: }
Chris@16: */
Chris@16: inline bool eval_is_zero(const tommath_int& val)
Chris@16: {
Chris@16:    return mp_iszero(&val.data());
Chris@16: }
Chris@16: inline int eval_get_sign(const tommath_int& val)
Chris@16: {
Chris@16:    return mp_iszero(&val.data()) ? 0 : SIGN(&val.data()) ? -1 : 1;
Chris@16: }
Chris@16: template <class A>
Chris@16: inline void eval_convert_to(A* result, const tommath_int& val)
Chris@16: {
Chris@16:    *result = boost::lexical_cast<A>(val.str(0, std::ios_base::fmtflags(0)));
Chris@16: }
Chris@16: inline void eval_convert_to(char* result, const tommath_int& val)
Chris@16: {
Chris@16:    *result = static_cast<char>(boost::lexical_cast<int>(val.str(0, std::ios_base::fmtflags(0))));
Chris@16: }
Chris@16: inline void eval_convert_to(unsigned char* result, const tommath_int& val)
Chris@16: {
Chris@16:    *result = static_cast<unsigned char>(boost::lexical_cast<unsigned>(val.str(0, std::ios_base::fmtflags(0))));
Chris@16: }
Chris@16: inline void eval_convert_to(signed char* result, const tommath_int& val)
Chris@16: {
Chris@16:    *result = static_cast<signed char>(boost::lexical_cast<int>(val.str(0, std::ios_base::fmtflags(0))));
Chris@16: }
Chris@16: inline void eval_abs(tommath_int& result, const tommath_int& val)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_abs(const_cast< ::mp_int*>(&val.data()), &result.data()));
Chris@16: }
Chris@16: inline void eval_gcd(tommath_int& result, const tommath_int& a, const tommath_int& b)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_gcd(const_cast< ::mp_int*>(&a.data()), const_cast< ::mp_int*>(&b.data()), const_cast< ::mp_int*>(&result.data())));
Chris@16: }
Chris@16: inline void eval_lcm(tommath_int& result, const tommath_int& a, const tommath_int& b)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_lcm(const_cast< ::mp_int*>(&a.data()), const_cast< ::mp_int*>(&b.data()), const_cast< ::mp_int*>(&result.data())));
Chris@16: }
Chris@16: inline void eval_powm(tommath_int& result, const tommath_int& base, const tommath_int& p, const tommath_int& m)
Chris@16: {
Chris@16:    if(eval_get_sign(p) < 0)
Chris@16:    {
Chris@16:       BOOST_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
Chris@16:    }
Chris@16:    detail::check_tommath_result(mp_exptmod(const_cast< ::mp_int*>(&base.data()), const_cast< ::mp_int*>(&p.data()), const_cast< ::mp_int*>(&m.data()), &result.data()));
Chris@16: }
Chris@16: 
Chris@16: 
Chris@16: inline void eval_qr(const tommath_int& x, const tommath_int& y, 
Chris@16:    tommath_int& q, tommath_int& r)
Chris@16: {
Chris@16:    detail::check_tommath_result(mp_div(const_cast< ::mp_int*>(&x.data()), const_cast< ::mp_int*>(&y.data()), &q.data(), &r.data()));
Chris@16: }
Chris@16: 
Chris@16: inline unsigned eval_lsb(const tommath_int& val)
Chris@16: {
Chris@16:    int c = eval_get_sign(val);
Chris@16:    if(c == 0)
Chris@16:    {
Chris@16:       BOOST_THROW_EXCEPTION(std::range_error("No bits were set in the operand."));
Chris@16:    }
Chris@16:    if(c < 0)
Chris@16:    {
Chris@16:       BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined."));
Chris@16:    }
Chris@16:    return mp_cnt_lsb(const_cast< ::mp_int*>(&val.data()));
Chris@16: }
Chris@16: 
Chris@16: inline unsigned eval_msb(const tommath_int& val)
Chris@16: {
Chris@16:    int c = eval_get_sign(val);
Chris@16:    if(c == 0)
Chris@16:    {
Chris@16:       BOOST_THROW_EXCEPTION(std::range_error("No bits were set in the operand."));
Chris@16:    }
Chris@16:    if(c < 0)
Chris@16:    {
Chris@16:       BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined."));
Chris@16:    }
Chris@16:    return mp_count_bits(const_cast< ::mp_int*>(&val.data())) - 1;
Chris@16: }
Chris@16: 
Chris@16: template <class Integer>
Chris@16: inline typename enable_if<is_unsigned<Integer>, Integer>::type eval_integer_modulus(const tommath_int& x, Integer val)
Chris@16: {
Chris@16:    static const mp_digit m = (static_cast<mp_digit>(1) << DIGIT_BIT) - 1;
Chris@16:    if(val <= m)
Chris@16:    {
Chris@16:       mp_digit d;
Chris@16:       detail::check_tommath_result(mp_mod_d(const_cast< ::mp_int*>(&x.data()), static_cast<mp_digit>(val), &d));
Chris@16:       return d;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       return default_ops::eval_integer_modulus(x, val);
Chris@16:    }
Chris@16: }
Chris@16: template <class Integer>
Chris@16: inline typename enable_if<is_signed<Integer>, Integer>::type eval_integer_modulus(const tommath_int& x, Integer val)
Chris@16: {
Chris@16:    typedef typename make_unsigned<Integer>::type unsigned_type;
Chris@16:    return eval_integer_modulus(x, static_cast<unsigned_type>(std::abs(val)));
Chris@16: }
Chris@16: 
Chris@16: } // namespace backends
Chris@16: 
Chris@16: using boost::multiprecision::backends::tommath_int;
Chris@16: 
Chris@16: template<>
Chris@16: struct number_category<tommath_int> : public mpl::int_<number_kind_integer>{};
Chris@16: 
Chris@16: typedef number<tommath_int >                     tom_int;
Chris@16: typedef rational_adaptor<tommath_int>               tommath_rational;
Chris@16: typedef number<tommath_rational>                 tom_rational;
Chris@16: 
Chris@16: }}  // namespaces
Chris@16: 
Chris@16: namespace std{
Chris@16: 
Chris@16: template<boost::multiprecision::expression_template_option ExpressionTemplates> 
Chris@16: class numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >
Chris@16: {
Chris@16:    typedef boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> number_type;
Chris@16: public:
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_specialized = true;
Chris@16:    //
Chris@16:    // Largest and smallest numbers are bounded only by available memory, set
Chris@16:    // to zero:
Chris@16:    //
Chris@16:    static number_type (min)()
Chris@16:    { 
Chris@16:       return number_type();
Chris@16:    }
Chris@16:    static number_type (max)() 
Chris@16:    { 
Chris@16:       return number_type();
Chris@16:    }
Chris@16:    static number_type lowest() { return (min)(); }
Chris@16:    BOOST_STATIC_CONSTEXPR int digits = INT_MAX;
Chris@16:    BOOST_STATIC_CONSTEXPR int digits10 = (INT_MAX / 1000) * 301L;
Chris@16:    BOOST_STATIC_CONSTEXPR int max_digits10 = digits10 + 2;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_signed = true;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_integer = true;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_exact = true;
Chris@16:    BOOST_STATIC_CONSTEXPR int radix = 2;
Chris@16:    static number_type epsilon() { return number_type(); }
Chris@16:    static number_type round_error() { return number_type(); }
Chris@16:    BOOST_STATIC_CONSTEXPR int min_exponent = 0;
Chris@16:    BOOST_STATIC_CONSTEXPR int min_exponent10 = 0;
Chris@16:    BOOST_STATIC_CONSTEXPR int max_exponent = 0;
Chris@16:    BOOST_STATIC_CONSTEXPR int max_exponent10 = 0;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_infinity = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = false;
Chris@16:    BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = denorm_absent;
Chris@16:    BOOST_STATIC_CONSTEXPR bool has_denorm_loss = false;
Chris@16:    static number_type infinity() { return number_type(); }
Chris@16:    static number_type quiet_NaN() { return number_type(); }
Chris@16:    static number_type signaling_NaN() { return number_type(); }
Chris@16:    static number_type denorm_min() { return number_type(); }
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_iec559 = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_bounded = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool is_modulo = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool traps = false;
Chris@16:    BOOST_STATIC_CONSTEXPR bool tinyness_before = false;
Chris@16:    BOOST_STATIC_CONSTEXPR float_round_style round_style = round_toward_zero;
Chris@16: };
Chris@16: 
Chris@16: #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
Chris@16: 
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::digits10;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_digits10;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_signed;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_integer;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_exact;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::radix;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::min_exponent10;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST int numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::max_exponent10;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_infinity;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_quiet_NaN;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_signaling_NaN;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::has_denorm_loss;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_iec559;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_bounded;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::is_modulo;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::traps;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST bool numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::tinyness_before;
Chris@16: template <boost::multiprecision::expression_template_option ExpressionTemplates>
Chris@16: BOOST_CONSTEXPR_OR_CONST float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::tommath_int, ExpressionTemplates> >::round_style;
Chris@16: 
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: #endif