BOOST_MP_FORCEINLINE number<B, et_off> operator - (const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), a.backend(), b.backend());
return BOOST_MP_MOVE(result);
}
BOOST_MP_FORCEINLINE typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
operator - (number<B, et_off>&& a, const V& b)
{
using default_ops::eval_subtract;
eval_subtract(a.backend(), number<B, et_off>::canonical_value(b));
return static_cast<number<B, et_off>&&>(a);
}
BOOST_MP_FORCEINLINE typename enable_if<is_signed_number<B>, number<B, et_off> >::type operator - (const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
eval_subtract(b.backend(), a.backend());
b.backend().negate();
return static_cast<number<B, et_off>&&>(b);
}
BOOST_MP_FORCEINLINE number<B, et_off> operator - (number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), b.backend());
return static_cast<number<B, et_off>&&>(a);
}
BOOST_MP_FORCEINLINE typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
operator - (const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return BOOST_MP_MOVE(result);
}
BOOST_MP_FORCEINLINE typename enable_if_c<(is_compatible_arithmetic_type<V, number<B, et_off> >::value && is_signed_number<B>::value), number<B, et_off> >::type
operator - (const V& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
eval_subtract(b.backend(), number<B, et_off>::canonical_value(a));
b.backend().negate();
return static_cast<number<B, et_off>&&>(b);
}
BOOST_MP_FORCEINLINE number<B, et_off> operator - (const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), a.backend(), b.backend());
return result;
}
BOOST_MP_FORCEINLINE typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
operator - (number<B, et_off>&& a, const V& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), number<B, et_off>::canonical_value(b));
return static_cast<number<B, et_off>&&>(a);
}
BOOST_MP_FORCEINLINE typename enable_if<is_signed_number<B>, number<B, et_off> >::type operator - (const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(b.backend(), a.backend());
b.backend().negate();
return static_cast<number<B, et_off>&&>(b);
}
BOOST_MP_FORCEINLINE typename enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >, number<B, et_off> >::type
operator - (const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_floating_point>& /*to_type*/, const mpl::int_<number_kind_floating_point>& /*from_type*/)
{
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4127)
#endif
//
// The code here only works when the radix of "From" is 2, we could try shifting by other
// radixes but it would complicate things.... use a string conversion when the radix is other
// than 2:
//
if(std::numeric_limits<number<From> >::radix != 2)
{
to = from.str(0, std::ios_base::fmtflags()).c_str();
return;
}
typedef typename canonical<unsigned char, To>::type ui_type;
using default_ops::eval_fpclassify;
using default_ops::eval_add;
using default_ops::eval_subtract;
using default_ops::eval_convert_to;
//
// First classify the input, then handle the special cases:
//
int c = eval_fpclassify(from);
if(c == FP_ZERO)
{
to = ui_type(0);
return;
}
else if(c == FP_NAN)
{
to = "nan";
return;
}
else if(c == FP_INFINITE)
{
to = "inf";
if(eval_get_sign(from) < 0)
to.negate();
return;
}
typename From::exponent_type e;
From f, term;
to = ui_type(0);
eval_frexp(f, from, &e);
static const int shift = std::numeric_limits<boost::intmax_t>::digits - 1;
while(!eval_is_zero(f))
{
// extract int sized bits from f:
eval_ldexp(f, f, shift);
eval_floor(term, f);
e -= shift;
eval_ldexp(to, to, shift);
typename boost::multiprecision::detail::canonical<boost::intmax_t, To>::type ll;
eval_convert_to(&ll, term);
eval_add(to, ll);
eval_subtract(f, term);
}
typedef typename To::exponent_type to_exponent;
if((e > (std::numeric_limits<to_exponent>::max)()) || (e < (std::numeric_limits<to_exponent>::min)()))
{
to = "inf";
if(eval_get_sign(from) < 0)
to.negate();
return;
}
eval_ldexp(to, to, static_cast<to_exponent>(e));
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
}
void divide_unsigned_helper(
CppInt1* result,
const CppInt2& x,
const CppInt3& y,
CppInt1& r)
{
if(((void*)result == (void*)&x) || ((void*)&r == (void*)&x))
{
CppInt2 t(x);
divide_unsigned_helper(result, t, y, r);
return;
}
if(((void*)result == (void*)&y) || ((void*)&r == (void*)&y))
{
CppInt3 t(y);
divide_unsigned_helper(result, x, t, r);
return;
}
/*
Very simple, fairly braindead long division.
Start by setting the remainder equal to x, and the
result equal to 0. Then in each loop we calculate our
"best guess" for how many times y divides into r,
add our guess to the result, and subtract guess*y
from the remainder r. One wrinkle is that the remainder
may go negative, in which case we subtract the current guess
from the result rather than adding. The value of the guess
is determined by dividing the most-significant-limb of the
current remainder by the most-significant-limb of y.
Note that there are more efficient algorithms than this
available, in particular see Knuth Vol 2. However for small
numbers of limbs this generally outperforms the alternatives
and avoids the normalisation step which would require extra storage.
*/
using default_ops::eval_subtract;
if(result == &r)
{
CppInt1 rem;
divide_unsigned_helper(result, x, y, rem);
r = rem;
return;
}
//
// Find the most significant words of numerator and denominator.
//
limb_type y_order = y.size() - 1;
if(y_order == 0)
{
//
// Only a single non-zero limb in the denominator, in this case
// we can use a specialized divide-by-single-limb routine which is
// much faster. This also handles division by zero:
//
divide_unsigned_helper(result, x, y.limbs()[y_order], r);
return;
}
typename CppInt2::const_limb_pointer px = x.limbs();
typename CppInt3::const_limb_pointer py = y.limbs();
limb_type r_order = x.size() - 1;
if((r_order == 0) && (*px == 0))
{
// x is zero, so is the result:
r = x;
if(result)
*result = x;
return;
}
r = x;
r.sign(false);
if(result)
*result = static_cast<limb_type>(0u);
//
// Check if the remainder is already less than the divisor, if so
// we already have the result. Note we try and avoid a full compare
// if we can:
//
if(r_order <= y_order)
{
if((r_order < y_order) || (r.compare_unsigned(y) < 0))
{
return;
}
}
CppInt1 t;
bool r_neg = false;
//
// See if we can short-circuit long division, and use basic arithmetic instead:
//
if(r_order == 0)
{
if(result)
{
*result = px[0] / py[0];
}
r = px[0] % py[0];
return;
}
else if(r_order == 1)
{
double_limb_type a, b;
a = (static_cast<double_limb_type>(px[1]) << CppInt1::limb_bits) | px[0];
b = y_order ?
(static_cast<double_limb_type>(py[1]) << CppInt1::limb_bits) | py[0]
: py[0];
if(result)
{
*result = a / b;
}
r = a % b;
return;
}
//
// prepare result:
//
if(result)
result->resize(1 + r_order - y_order, 1 + r_order - y_order);
typename CppInt1::const_limb_pointer prem = r.limbs();
// This is initialised just to keep the compiler from emitting useless warnings later on:
typename CppInt1::limb_pointer pr
= typename CppInt1::limb_pointer();
if(result)
{
pr = result->limbs();
for(unsigned i = 1; i < 1 + r_order - y_order; ++i)
pr[i] = 0;
}
bool first_pass = true;
do
{
//
// Calculate our best guess for how many times y divides into r:
//
limb_type guess;
if((prem[r_order] <= py[y_order]) && (r_order > 0))
{
double_limb_type a, b, v;
a = (static_cast<double_limb_type>(prem[r_order]) << CppInt1::limb_bits) | prem[r_order - 1];
b = py[y_order];
v = a / b;
if(v > CppInt1::max_limb_value)
guess = 1;
else
{
guess = static_cast<limb_type>(v);
--r_order;
}
}
else if(r_order == 0)
{
guess = prem[0] / py[y_order];
}
else
{
double_limb_type a, b, v;
a = (static_cast<double_limb_type>(prem[r_order]) << CppInt1::limb_bits) | prem[r_order - 1];
b = (y_order > 0) ? (static_cast<double_limb_type>(py[y_order]) << CppInt1::limb_bits) | py[y_order - 1] : (static_cast<double_limb_type>(py[y_order]) << CppInt1::limb_bits);
v = a / b;
guess = static_cast<limb_type>(v);
}
BOOST_ASSERT(guess); // If the guess ever gets to zero we go on forever....
//
// Update result:
//
limb_type shift = r_order - y_order;
if(result)
{
if(r_neg)
{
if(pr[shift] > guess)
pr[shift] -= guess;
else
{
t.resize(shift + 1, shift + 1);
t.limbs()[shift] = guess;
for(unsigned i = 0; i < shift; ++i)
t.limbs()[i] = 0;
eval_subtract(*result, t);
}
}
else if(CppInt1::max_limb_value - pr[shift] > guess)
pr[shift] += guess;
else
{
t.resize(shift + 1, shift + 1);
t.limbs()[shift] = guess;
for(unsigned i = 0; i < shift; ++i)
t.limbs()[i] = 0;
eval_add(*result, t);
}
}
//
// Calculate guess * y, we use a fused mutiply-shift O(N) for this
// rather than a full O(N^2) multiply:
//
double_limb_type carry = 0;
t.resize(y.size() + shift + 1, y.size() + shift);
bool truncated_t = !CppInt1::variable && (t.size() != y.size() + shift + 1);
typename CppInt1::limb_pointer pt = t.limbs();
for(unsigned i = 0; i < shift; ++i)
pt[i] = 0;
for(unsigned i = 0; i < y.size(); ++i)
{
carry += static_cast<double_limb_type>(py[i]) * static_cast<double_limb_type>(guess);
pt[i + shift] = static_cast<limb_type>(carry);
carry >>= CppInt1::limb_bits;
}
if(carry && !truncated_t)
{
pt[t.size() - 1] = static_cast<limb_type>(carry);
}
else if(!truncated_t)
{
t.resize(t.size() - 1, t.size() - 1);
}
//
// Update r in a way that won't actually produce a negative result
// in case the argument types are unsigned:
//
if(r.compare(t) > 0)
{
eval_subtract(r, t);
}
else
{
r.swap(t);
eval_subtract(r, t);
prem = r.limbs();
r_neg = !r_neg;
}
//
// First time through we need to strip any leading zero, otherwise
// the termination condition goes belly-up:
//
if(result && first_pass)
{
first_pass = false;
while(pr[result->size() - 1] == 0)
result->resize(result->size() - 1, result->size() - 1);
}
//
// Update r_order:
//
r_order = r.size() - 1;
if(r_order < y_order)
break;
}
// Termination condition is really just a check that r > y, but with a common
// short-circuit case handled first:
while((r_order > y_order) || (r.compare_unsigned(y) >= 0));
//
// We now just have to normalise the result:
//
if(r_neg && eval_get_sign(r))
{
// We have one too many in the result:
if(result)
eval_decrement(*result);
if(y.sign())
{
r.negate();
eval_subtract(r, y);
}
else
eval_subtract(r, y, r);
}
BOOST_ASSERT(r.compare_unsigned(y) < 0); // remainder must be less than the divisor or our code has failed
}
BOOST_MP_FORCEINLINE number<B, et_off> operator - (number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
eval_subtract(a.backend(), b.backend());
return static_cast<number<B, et_off>&&>(a);
}
void eval_exp(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg)
{
//
// This is based on MPFR's method, let:
//
// n = floor(x / ln(2))
//
// Then:
//
// r = x - n ln(2) : 0 <= r < ln(2)
//
// We can reduce r further by dividing by 2^k, with k ~ sqrt(n),
// so if:
//
// e0 = exp(r / 2^k) - 1
//
// With e0 evaluated by taylor series for small arguments, then:
//
// exp(x) = 2^n (1 + e0)^2^k
//
// Note that to preserve precision we actually square (1 + e0) k times, calculating
// the result less one each time, i.e.
//
// (1 + e0)^2 - 1 = e0^2 + 2e0
//
// Then add the final 1 at the end, given that e0 is small, this effectively wipes
// out the error in the last step.
//
using default_ops::eval_multiply;
using default_ops::eval_subtract;
using default_ops::eval_add;
using default_ops::eval_convert_to;
int type = eval_fpclassify(arg);
bool isneg = eval_get_sign(arg) < 0;
if(type == (int)FP_NAN)
{
res = arg;
errno = EDOM;
return;
}
else if(type == (int)FP_INFINITE)
{
res = arg;
if(isneg)
res = limb_type(0u);
else
res = arg;
return;
}
else if(type == (int)FP_ZERO)
{
res = limb_type(1);
return;
}
cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> t, n;
if(isneg)
{
t = arg;
t.negate();
eval_exp(res, t);
t.swap(res);
res = limb_type(1);
eval_divide(res, t);
return;
}
eval_divide(n, arg, default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >());
eval_floor(n, n);
eval_multiply(t, n, default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >());
eval_subtract(t, arg);
t.negate();
if(eval_get_sign(t) < 0)
{
// There are some very rare cases where arg/ln2 is an integer, and the subsequent multiply
// rounds up, in that situation t ends up negative at this point which breaks our invariants below:
t = limb_type(0);
}
Exponent k, nn;
eval_convert_to(&nn, n);
if (nn == (std::numeric_limits<Exponent>::max)())
{
// The result will necessarily oveflow:
res = std::numeric_limits<number<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> > >::infinity().backend();
return;
}
BOOST_ASSERT(t.compare(default_ops::get_constant_ln2<cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> >()) < 0);
k = nn ? Exponent(1) << (msb(nn) / 2) : 0;
eval_ldexp(t, t, -k);
eval_exp_taylor(res, t);
//
// Square 1 + res k times:
//
for(int s = 0; s < k; ++s)
{
t.swap(res);
eval_multiply(res, t, t);
eval_ldexp(t, t, 1);
eval_add(res, t);
}
eval_add(res, limb_type(1));
eval_ldexp(res, res, nn);
}
std::string convert_to_string(Backend b, std::streamsize digits, std::ios_base::fmtflags f)
{
using default_ops::eval_log10;
using default_ops::eval_floor;
using default_ops::eval_pow;
using default_ops::eval_convert_to;
using default_ops::eval_multiply;
using default_ops::eval_divide;
using default_ops::eval_subtract;
using default_ops::eval_fpclassify;
typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type;
typedef typename Backend::exponent_type exponent_type;
std::string result;
bool iszero = false;
bool isneg = false;
exponent_type expon = 0;
std::streamsize org_digits = digits;
BOOST_ASSERT(digits > 0);
int fpt = eval_fpclassify(b);
if(fpt == (int)FP_ZERO)
{
result = "0";
iszero = true;
}
else if(fpt == (int)FP_INFINITE)
{
if(b.compare(ui_type(0)) < 0)
return "-inf";
else
return ((f & std::ios_base::showpos) == std::ios_base::showpos) ? "+inf" : "inf";
}
else if(fpt == (int)FP_NAN)
{
return "nan";
}
else
{
//
// Start by figuring out the exponent:
//
isneg = b.compare(ui_type(0)) < 0;
if(isneg)
b.negate();
Backend t;
Backend ten;
ten = ui_type(10);
eval_log10(t, b);
eval_floor(t, t);
eval_convert_to(&expon, t);
if(-expon > std::numeric_limits<number<Backend> >::max_exponent10 - 3)
{
int e = -expon / 2;
Backend t2;
eval_pow(t2, ten, e);
eval_multiply(t, t2, b);
eval_multiply(t, t2);
if(expon & 1)
eval_multiply(t, ten);
}
else
{
eval_pow(t, ten, -expon);
eval_multiply(t, b);
}
//
// Make sure we're between [1,10) and adjust if not:
//
if(t.compare(ui_type(1)) < 0)
{
eval_multiply(t, ui_type(10));
--expon;
}
else if(t.compare(ui_type(10)) >= 0)
{
eval_divide(t, ui_type(10));
++expon;
}
Backend digit;
ui_type cdigit;
//
// Adjust the number of digits required based on formatting options:
//
if(((f & std::ios_base::fixed) == std::ios_base::fixed) && (expon != -1))
digits += expon + 1;
if((f & std::ios_base::scientific) == std::ios_base::scientific)
++digits;
//
// Extract the digits one at a time:
//
for(unsigned i = 0; i < digits; ++i)
{
eval_floor(digit, t);
eval_convert_to(&cdigit, digit);
result += static_cast<char>('0' + cdigit);
eval_subtract(t, digit);
eval_multiply(t, ten);
}
//
// Possibly round result:
//
if(digits >= 0)
{
eval_floor(digit, t);
eval_convert_to(&cdigit, digit);
eval_subtract(t, digit);
if((cdigit == 5) && (t.compare(ui_type(0)) == 0))
{
// Bankers rounding:
if((*result.rbegin() - '0') & 1)
{
round_string_up_at(result, result.size() - 1, expon);
}
}
else if(cdigit >= 5)
{
round_string_up_at(result, result.size() - 1, expon);
}
}
}
while((result.size() > digits) && result.size())
{
// We may get here as a result of rounding...
if(result.size() > 1)
result.erase(result.size() - 1);
else
{
if(expon > 0)
--expon; // so we put less padding in the result.
else
++expon;
++digits;
}
}
BOOST_ASSERT(org_digits >= 0);
if(isneg)
result.insert(static_cast<std::string::size_type>(0), 1, '-');
format_float_string(result, expon, org_digits, f, iszero);
return result;
}
