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_add; eval_add(result.backend(), a.backend(), b.backend()); return BOOST_MP_MOVE(result); }
BOOST_MP_FORCEINLINE number<B, et_off> operator + (number<B, et_off>&& a, number<B, et_off>&& b) { using default_ops::eval_add; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_add(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, number<B, et_off>&& b) { using default_ops::eval_add; eval_add(b.backend(), number<B, et_off>::canonical_value(a)); 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) { number<B, et_off> result; using default_ops::eval_add; eval_add(result.backend(), b.backend(), number<B, et_off>::canonical_value(a)); return BOOST_MP_MOVE(result); }
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_add; eval_add(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 + (const V& a, number<B, et_off>&& b) { using default_ops::eval_add; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_add(b.backend(), number<B, et_off>::canonical_value(a)); 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 number<B, et_off>& a, const V& b) { detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a); number<B, et_off> result; using default_ops::eval_add; eval_add(result.backend(), a.backend(), number<B, et_off>::canonical_value(b)); return result; }
void eval_exp_taylor(cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &res, const cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> &arg) { static const int bits = cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE>::bit_count; // // Taylor series for small argument, note returns exp(x) - 1: // res = limb_type(0); cpp_bin_float<Digits, DigitBase, Allocator, Exponent, MinE, MaxE> num(arg), denom, t; denom = limb_type(1); eval_add(res, num); for(unsigned k = 2; ; ++k) { eval_multiply(denom, k); eval_multiply(num, arg); eval_divide(t, num, denom); eval_add(res, t); if(eval_is_zero(t) || (res.exponent() - bits > t.exponent())) break; } }
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_floating_point>& /*to_type*/, const mpl::int_<number_kind_integer>& /*from_type*/) { using default_ops::eval_get_sign; using default_ops::eval_bitwise_and; using default_ops::eval_convert_to; using default_ops::eval_right_shift; using default_ops::eval_ldexp; using default_ops::eval_add; using default_ops::eval_is_zero; // smallest unsigned type handled natively by "From" is likely to be it's limb_type: typedef typename canonical<unsigned char, From>::type l_limb_type; // get the corresponding type that we can assign to "To": typedef typename canonical<l_limb_type, To>::type to_type; From t(from); bool is_neg = eval_get_sign(t) < 0; if(is_neg) t.negate(); // Pick off the first limb: l_limb_type limb; l_limb_type mask = static_cast<l_limb_type>(~static_cast<l_limb_type>(0)); From fl; eval_bitwise_and(fl, t, mask); eval_convert_to(&limb, fl); to = static_cast<to_type>(limb); eval_right_shift(t, std::numeric_limits<l_limb_type>::digits); // // Then keep picking off more limbs until "t" is zero: // To l; unsigned shift = std::numeric_limits<l_limb_type>::digits; while(!eval_is_zero(t)) { eval_bitwise_and(fl, t, mask); eval_convert_to(&limb, fl); l = static_cast<to_type>(limb); eval_right_shift(t, std::numeric_limits<l_limb_type>::digits); eval_ldexp(l, l, shift); eval_add(to, l); shift += std::numeric_limits<l_limb_type>::digits; } // // Finish off by setting the sign: // if(is_neg) to.negate(); }
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 }
BOOST_MP_FORCEINLINE number<B, et_off> operator + (number<B, et_off>&& a, number<B, et_off>&& b) { using default_ops::eval_add; eval_add(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); }
void convert_from_string(Backend& b, const char* p) { using default_ops::eval_multiply; using default_ops::eval_add; using default_ops::eval_pow; using default_ops::eval_divide; typedef typename mpl::front<typename Backend::unsigned_types>::type ui_type; b = ui_type(0); if(!p || (*p == 0)) return; bool is_neg = false; bool is_neg_expon = false; static const ui_type ten = ui_type(10); typename Backend::exponent_type expon = 0; int digits_seen = 0; typedef std::numeric_limits<number<Backend, et_off> > limits; static const int max_digits = limits::is_specialized ? limits::max_digits10 + 1 : INT_MAX; if(*p == '+') ++p; else if(*p == '-') { is_neg = true; ++p; } if((std::strcmp(p, "nan") == 0) || (std::strcmp(p, "NaN") == 0) || (std::strcmp(p, "NAN") == 0)) { eval_divide(b, ui_type(0)); if(is_neg) b.negate(); return; } if((std::strcmp(p, "inf") == 0) || (std::strcmp(p, "Inf") == 0) || (std::strcmp(p, "INF") == 0)) { b = ui_type(1); eval_divide(b, ui_type(0)); if(is_neg) b.negate(); return; } // // Grab all the leading digits before the decimal point: // while(std::isdigit(*p)) { eval_multiply(b, ten); eval_add(b, ui_type(*p - '0')); ++p; ++digits_seen; } if(*p == '.') { // // Grab everything after the point, stop when we've seen // enough digits, even if there are actually more available: // ++p; while(std::isdigit(*p)) { eval_multiply(b, ten); eval_add(b, ui_type(*p - '0')); ++p; --expon; if(++digits_seen > max_digits) break; } while(std::isdigit(*p)) ++p; } // // Parse the exponent: // if((*p == 'e') || (*p == 'E')) { ++p; if(*p == '+') ++p; else if(*p == '-') { is_neg_expon = true; ++p; } typename Backend::exponent_type e2 = 0; while(std::isdigit(*p)) { e2 *= 10; e2 += (*p - '0'); ++p; } if(is_neg_expon) e2 = -e2; expon += e2; } if(expon) { // Scale by 10^expon, note that 10^expon can be // outside the range of our number type, even though the // result is within range, if that looks likely, then split // the calculation in two: Backend t; t = ten; if(expon > limits::min_exponent10 + 2) { eval_pow(t, t, expon); eval_multiply(b, t); } else { eval_pow(t, t, expon + digits_seen + 1); eval_multiply(b, t); t = ten; eval_pow(t, t, -digits_seen - 1); eval_multiply(b, t); } } if(is_neg) b.negate(); if(*p) { // Unexpected input in string: BOOST_THROW_EXCEPTION(std::runtime_error("Unexpected characters in string being interpreted as a float128.")); } }