///////////////////////////////////////////////////////////////

// Copyright 2012 John Maddock. 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_

//

// Comparison operators for cpp_int_backend:

//

#ifndef BOOST_MP_CPP_INT_ADD_HPP

#define BOOST_MP_CPP_INT_ADD_HPP

namespace boost{ namespace multiprecision{ namespace backends{

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable:4127) // conditional expression is constant

#endif

//

// This is the key addition routine where all the argument types are non-trivial cpp_int's:

//

template <class CppInt1, class CppInt2, class CppInt3>

inline void add_unsigned(CppInt1& result, const CppInt2& a, const CppInt3& b) BOOST_MP_NOEXCEPT_IF(is_non_throwing_cpp_int<CppInt1>::value)

{

using std::swap;

// Nothing fancy, just let uintmax_t take the strain:

double_limb_type carry = 0;

unsigned m, x;

unsigned as = a.size();

unsigned bs = b.size();

minmax(as, bs, m, x);

if(x == 1)

{

bool s = a.sign();

result = static_cast<double_limb_type>(*a.limbs()) + static_cast<double_limb_type>(*b.limbs());

result.sign(s);

return;

}

result.resize(x, x);

typename CppInt2::const_limb_pointer pa = a.limbs();

typename CppInt3::const_limb_pointer pb = b.limbs();

typename CppInt1::limb_pointer pr = result.limbs();

typename CppInt1::limb_pointer pr_end = pr + m;

if(as < bs)

swap(pa, pb);

// First where a and b overlap:

while(pr != pr_end)

{

carry += static_cast<double_limb_type>(*pa) + static_cast<double_limb_type>(*pb);

#ifdef __MSVC_RUNTIME_CHECKS

*pr = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));

#else

*pr = static_cast<limb_type>(carry);

#endif

carry >>= CppInt1::limb_bits;

++pr, ++pa, ++pb;

}

pr_end += x - m;

// Now where only a has digits:

while(pr != pr_end)

{

if(!carry)

{

if(pa != pr)

#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)

std::copy(pa, pa + (pr_end - pr), stdext::checked_array_iterator<limb_type*>(pr, result.size()));

#else

std::copy(pa, pa + (pr_end - pr), pr);

#endif

break;

}

carry += static_cast<double_limb_type>(*pa);

#ifdef __MSVC_RUNTIME_CHECKS

*pr = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));

#else

*pr = static_cast<limb_type>(carry);

#endif

carry >>= CppInt1::limb_bits;

++pr, ++pa;

}

if(carry)

{

// We overflowed, need to add one more limb:

result.resize(x + 1, x + 1);

if(result.size() > x)

result.limbs()[x] = static_cast<limb_type>(carry);

}

result.normalize();

result.sign(a.sign());

}

//

// As above, but for adding a single limb to a non-trivial cpp_int:

//

template <class CppInt1, class CppInt2>

inline void add_unsigned(CppInt1& result, const CppInt2& a, const limb_type& o) BOOST_MP_NOEXCEPT_IF(is_non_throwing_cpp_int<CppInt1>::value)

{

// Addition using modular arithmetic.

// Nothing fancy, just let uintmax_t take the strain:

if(&result != &a)

result.resize(a.size(), a.size());

double_limb_type carry = o;

typename CppInt1::limb_pointer pr = result.limbs();

typename CppInt2::const_limb_pointer pa = a.limbs();

unsigned i = 0;

// Addition with carry until we either run out of digits or carry is zero:

for(; carry && (i < result.size()); ++i)

{

carry += static_cast<double_limb_type>(pa[i]);

#ifdef __MSVC_RUNTIME_CHECKS

pr[i] = static_cast<limb_type>(carry & ~static_cast<limb_type>(0));

#else

pr[i] = static_cast<limb_type>(carry);

#endif

carry >>= CppInt1::limb_bits;

}

// Just copy any remaining digits:

if(&a != &result)

{

for(; i < result.size(); ++i)

pr[i] = pa[i];

}

if(carry)

{

// We overflowed, need to add one more limb:

unsigned x = result.size();

result.resize(x + 1, x + 1);

if(result.size() > x)

result.limbs()[x] = static_cast<limb_type>(carry);

}

result.normalize();

result.sign(a.sign());

}

//

// Core subtraction routine for all non-trivial cpp_int's:

//

template <class CppInt1, class CppInt2, class CppInt3>

inline void subtract_unsigned(CppInt1& result, const CppInt2& a, const CppInt3& b) BOOST_MP_NOEXCEPT_IF(is_non_throwing_cpp_int<CppInt1>::value)

{

using std::swap;

// Nothing fancy, just let uintmax_t take the strain:

double_limb_type borrow = 0;

unsigned m, x;

minmax(a.size(), b.size(), m, x);

//

// special cases for small limb counts:

//

if(x == 1)

{

bool s = a.sign();

limb_type al = *a.limbs();

limb_type bl = *b.limbs();

if(bl > al)

{

std::swap(al, bl);

s = !s;

}

result = al - bl;

result.sign(s);

return;

}

// This isn't used till later, but comparison has to occur before we resize the result,

// as that may also resize a or b if this is an inplace operation:

int c = a.compare_unsigned(b);

// Set up the result vector:

result.resize(x, x);

// Now that a, b, and result are stable, get pointers to their limbs:

typename CppInt2::const_limb_pointer pa = a.limbs();

typename CppInt3::const_limb_pointer pb = b.limbs();

typename CppInt1::limb_pointer pr = result.limbs();

bool swapped = false;

if(c < 0)

{

swap(pa, pb);

swapped = true;

}

else if(c == 0)

{

result = static_cast<limb_type>(0);

return;

}

unsigned i = 0;

// First where a and b overlap:

while(i < m)

{

borrow = static_cast<double_limb_type>(pa[i]) - static_cast<double_limb_type>(pb[i]) - borrow;

pr[i] = static_cast<limb_type>(borrow);

borrow = (borrow >> CppInt1::limb_bits) & 1u;

++i;

}

// Now where only a has digits, only as long as we've borrowed:

while(borrow && (i < x))

{

borrow = static_cast<double_limb_type>(pa[i]) - borrow;

pr[i] = static_cast<limb_type>(borrow);

borrow = (borrow >> CppInt1::limb_bits) & 1u;

++i;

}

// Any remaining digits are the same as those in pa:

if((x != i) && (pa != pr))

#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)

std::copy(pa + i, pa + x, stdext::checked_array_iterator<limb_type*>(pr + i, result.size() - i));

#else

std::copy(pa + i, pa + x, pr + i);

#endif

BOOST_ASSERT(0 == borrow);

//

// We may have lost digits, if so update limb usage count:

//

result.normalize();

result.sign(a.sign());

if(swapped)

result.negate();

}

//

// And again to subtract a single limb:

//

template <class CppInt1, class CppInt2>

inline void subtract_unsigned(CppInt1& result, const CppInt2& a, const limb_type& b) BOOST_MP_NOEXCEPT_IF(is_non_throwing_cpp_int<CppInt1>::value)

{

// Subtract one limb.

// Nothing fancy, just let uintmax_t take the strain:

BOOST_STATIC_CONSTANT(double_limb_type, borrow = static_cast<double_limb_type>(CppInt1::max_limb_value) + 1);

result.resize(a.size(), a.size());

typename CppInt1::limb_pointer pr = result.limbs();

typename CppInt2::const_limb_pointer pa = a.limbs();

if(*pa >= b)

{

*pr = *pa - b;

if(&result != &a)

{

#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)

std::copy(pa + 1, pa + a.size(), stdext::checked_array_iterator<limb_type*>(pr + 1, result.size() - 1));

#else

std::copy(pa + 1, pa + a.size(), pr + 1);

#endif

result.sign(a.sign());

}

else if((result.size() == 1) && (*pr == 0))

{

result.sign(false); // zero is unsigned.

}

}

else if(result.size() == 1)

{

*pr = b - *pa;

result.sign(!a.sign());

}

else

{

*pr = static_cast<limb_type>((borrow + *pa) - b);

unsigned i = 1;

while(!pa[i])

{

pr[i] = CppInt1::max_limb_value;

++i;

}

pr[i] = pa[i] - 1;

if(&result != &a)

{

++i;

#if BOOST_WORKAROUND(BOOST_MSVC, >= 1600)

std::copy(pa + i, pa + a.size(), stdext::checked_array_iterator<limb_type*>(pr + i, result.size() - i));

#else

std::copy(pa + i, pa + a.size(), pr + i);

#endif

}

result.normalize();

result.sign(a.sign());

}

}

//

// Now the actual functions called by the front end, all of which forward to one of the above:

//

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type

eval_add(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

eval_add(result, result, o);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, unsigned MinBits3, unsigned MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>

inline typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value >::type

eval_add(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,

const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(a.sign() != b.sign())

{

subtract_unsigned(result, a, b);

return;

}

add_unsigned(result, a, b);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type

eval_add(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result, const limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(result.sign())

{

subtract_unsigned(result, result, o);

}

else

add_unsigned(result, result, o);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type

eval_add(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,

const limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(a.sign())

{

subtract_unsigned(result, a, o);

}

else

add_unsigned(result, a, o);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type

eval_add(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const signed_limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(o < 0)

eval_subtract(result, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));

else if(o > 0)

eval_add(result, static_cast<limb_type>(o));

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type

eval_add(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,

const signed_limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(o < 0)

eval_subtract(result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));

else if(o > 0)

eval_add(result, a, static_cast<limb_type>(o));

else if(&result != &a)

result = a;

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(result.sign())

{

add_unsigned(result, result, o);

}

else

subtract_unsigned(result, result, o);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,

const limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(a.sign())

{

add_unsigned(result, a, o);

}

else

{

subtract_unsigned(result, a, o);

}

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const signed_limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(o)

{

if(o < 0)

eval_add(result, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));

else

eval_subtract(result, static_cast<limb_type>(o));

}

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,

const signed_limb_type& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(o)

{

if(o < 0)

eval_add(result, a, static_cast<limb_type>(boost::multiprecision::detail::unsigned_abs(o)));

else

eval_subtract(result, a, static_cast<limb_type>(o));

}

else if(&result != &a)

result = a;

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type

eval_increment(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

static const limb_type one = 1;

if(!result.sign() && (result.limbs()[0] < cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value))

++result.limbs()[0];

else if (result.sign() && result.limbs()[0])

{

--result.limbs()[0];

if (!result.limbs()[0])

result.sign(false);

}

else

eval_add(result, one);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value>::type

eval_decrement(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

static const limb_type one = 1;

if(!result.sign() && result.limbs()[0])

--result.limbs()[0];

else if (result.sign() && (result.limbs()[0] < cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::max_limb_value))

++result.limbs()[0];

else

eval_subtract(result, one);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value >::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

eval_subtract(result, result, o);

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, unsigned MinBits2, unsigned MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2, unsigned MinBits3, unsigned MaxBits3, cpp_integer_type SignType3, cpp_int_check_type Checked3, class Allocator3>

BOOST_MP_FORCEINLINE typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3> >::value >::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& a,

const cpp_int_backend<MinBits3, MaxBits3, SignType3, Checked3, Allocator3>& b) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(a.sign() != b.sign())

{

add_unsigned(result, a, b);

return;

}

subtract_unsigned(result, a, b);

}

//

// Simple addition and subtraction routine for trivial cpp_int's come last:

//

// One of the arguments is signed:

//

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

inline typename enable_if_c<

is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)

>::type

eval_add(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(result.sign() != o.sign())

{

if(*o.limbs() > *result.limbs())

{

*result.limbs() = detail::checked_subtract(*o.limbs(), *result.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

result.negate();

}

else

*result.limbs() = detail::checked_subtract(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

}

else

*result.limbs() = detail::checked_add(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

result.normalize();

}

// Simple version for two unsigned arguments:

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<

is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

>::type

eval_add(cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

*result.limbs() = detail::checked_add(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

result.normalize();

}

// signed subtraction:

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

inline typename enable_if_c<

is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& (is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value || is_signed_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value)

>::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

if(result.sign() != o.sign())

{

*result.limbs() = detail::checked_add(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

}

else if(*result.limbs() < *o.limbs())

{

*result.limbs() = detail::checked_subtract(*o.limbs(), *result.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

result.negate();

}

else

*result.limbs() = detail::checked_subtract(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

result.normalize();

}

template <unsigned MinBits1, unsigned MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1>

BOOST_MP_FORCEINLINE typename enable_if_c<

is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

&& is_unsigned_number<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value

>::type

eval_subtract(

cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& result,

const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& o) BOOST_MP_NOEXCEPT_IF((is_non_throwing_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value))

{

*result.limbs() = detail::checked_subtract(*result.limbs(), *o.limbs(), typename cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::checked_type());

result.normalize();

}

#ifdef _MSC_VER

#pragma warning(pop)

#endif

}}} // namespaces

#endif