inline void eval_bit_flip(const logged_adaptor<Backend>& arg, unsigned a) { using default_ops::eval_bit_flip; log_prefix_event(arg.value(), a, "bit-flip"); eval_bit_flip(arg.value(), a); log_postfix_event(arg.value(), arg, "bit-flip"); }
inline void eval_right_shift(logged_adaptor<Backend>& arg, const logged_adaptor<Backend>& a, unsigned b) { using default_ops::eval_right_shift; log_prefix_event(arg.value(), a, b, ">>"); eval_right_shift(arg.value(), a.value(), b); log_postfix_event(arg.value(), ">>"); }
BOOST_MP_FORCEINLINE typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type operator & (const V& a, number<B, et_off>&& b) { using default_ops::eval_bitwise_and; eval_bitwise_and(b.backend(), number<B, et_off>::canonical_value(a)); return static_cast<number<B, et_off>&&>(b); }
inline void eval_convert_to(R* result, const logged_adaptor<Backend>& val) { using default_ops::eval_convert_to; log_prefix_event(val.value(), "convert_to"); eval_convert_to(result, val.value()); log_postfix_event(val.value(), *result, "convert_to"); }
inline typename enable_if_c<!is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value, unsigned>::type eval_lsb(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a) { using default_ops::eval_get_sign; if(eval_get_sign(a) == 0) { BOOST_THROW_EXCEPTION(std::range_error("No bits were set in the operand.")); } if(a.sign()) { BOOST_THROW_EXCEPTION(std::range_error("Testing individual bits in negative values is not supported - results are undefined.")); } // // Find the index of the least significant limb that is non-zero: // unsigned index = 0; while(!a.limbs()[index] && (index < a.size())) ++index; // // Find the index of the least significant bit within that limb: // unsigned result = boost::multiprecision::detail::find_lsb(a.limbs()[index]); return result + index * cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>::limb_bits; }
BOOST_MP_FORCEINLINE typename enable_if_c<is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type operator >> (number<B, et_off>&& a, const I& b) { using default_ops::eval_right_shift; eval_right_shift(a.backend(), b); return static_cast<number<B, et_off>&&>(a); }
inline void eval_right_shift(logged_adaptor<Backend>& arg, unsigned a) { using default_ops::eval_right_shift; log_prefix_event(arg.value(), a, ">>="); eval_right_shift(arg.value(), a); log_postfix_event(arg.value(), ">>="); }
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_divide; eval_divide(a.backend(), number<B, et_off>::canonical_value(b)); return static_cast<number<B, et_off>&&>(a); }
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 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_multiply; eval_multiply(b.backend(), number<B, et_off>::canonical_value(a)); return static_cast<number<B, et_off>&&>(b); }
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 * (const number<B, et_off>& a, number<B, et_off>&& b) { using default_ops::eval_multiply; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_multiply(b.backend(), a.backend()); return static_cast<number<B, et_off>&&>(b); }
BOOST_MP_FORCEINLINE typename enable_if_c<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator % (number<B, et_off>&& a, const number<B, et_off>& b) { using default_ops::eval_modulus; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_modulus(a.backend(), b.backend()); return static_cast<number<B, et_off>&&>(a); }
BOOST_MP_FORCEINLINE typename enable_if<is_integral<I>, number<B, et_off> >::type operator >> (number<B, et_off>&& a, const I& b) { using default_ops::eval_right_shift; eval_right_shift(a.backend(), b); return static_cast<number<B, et_off>&&>(a); }
BOOST_MP_FORCEINLINE number<B, et_off> operator / (number<B, et_off>&& a, const number<B, et_off>& b) { using default_ops::eval_divide; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_divide(a.backend(), b.backend()); return static_cast<number<B, et_off>&&>(a); }
BOOST_MP_FORCEINLINE typename enable_if_c<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator & (const number<B, et_off>& a, const number<B, et_off>& b) { number<B, et_off> result; using default_ops::eval_bitwise_and; eval_bitwise_and(result.backend(), a.backend(), 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 typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type operator & (const number<B, et_off>& a, const V& b) { number<B, et_off> result; using default_ops::eval_bitwise_and; eval_bitwise_and(result.backend(), a.backend(), number<B, et_off>::canonical_value(b)); return BOOST_MP_MOVE(result); }
inline unsigned eval_integer_modulus(const logged_adaptor<Backend>& arg, const T& a) { using default_ops::eval_integer_modulus; log_prefix_event(arg.value(), a, "integer-modulus"); unsigned r = eval_integer_modulus(arg.value(), a); log_postfix_event(arg.value(), r, "integer-modulus"); return r; }
inline bool eval_bit_test(const logged_adaptor<Backend>& arg, unsigned a) { using default_ops::eval_bit_test; log_prefix_event(arg.value(), a, "bit-test"); bool r = eval_bit_test(arg.value(), a); log_postfix_event(arg.value(), r, "bit-test"); return r; }
BOOST_MP_FORCEINLINE typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type operator % (number<B, et_off>&& a, const V& b) { using default_ops::eval_modulus; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_modulus(a.backend(), number<B, et_off>::canonical_value(b)); 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 / (number<B, et_off>&& a, const V& b) { using default_ops::eval_divide; detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b); eval_divide(a.backend(), number<B, et_off>::canonical_value(b)); 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); }
inline int eval_fpclassify(const logged_adaptor<Backend>& arg) { using default_ops::eval_fpclassify; log_prefix_event(arg.value(), "fpclassify"); int r = eval_fpclassify(arg.value()); log_postfix_event(arg.value(), r, "fpclassify"); return r; }
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); }
inline unsigned eval_lsb(const logged_adaptor<Backend>& arg) { using default_ops::eval_lsb; log_prefix_event(arg.value(), "least-significant-bit"); unsigned r = eval_lsb(arg.value()); log_postfix_event(arg.value(), r, "least-significant-bit"); return r; }
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) { number<B, et_off> result; using default_ops::eval_bitwise_xor; eval_bitwise_xor(result.backend(), a.backend(), number<B, et_off>::canonical_value(b)); return BOOST_MP_MOVE(result); }
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_integer>& /*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_left_shift; using default_ops::eval_bitwise_or; 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 limb_type; // get the corresponding type that we can assign to "To": typedef typename canonical<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: limb_type limb; limb_type mask = static_cast<limb_type>(~static_cast<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<limb_type>::digits); // // Then keep picking off more limbs until "t" is zero: // To l; unsigned shift = std::numeric_limits<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<limb_type>::digits); eval_left_shift(l, shift); eval_bitwise_or(to, l); shift += std::numeric_limits<limb_type>::digits; } // // Finish off by setting the sign: // if(is_neg) to.negate(); }
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; }
void generic_interconvert(To& to, const From& from, const mpl::int_<number_kind_rational>& /*to_type*/, const mpl::int_<number_kind_integer>& /*from_type*/) { typedef typename component_type<number<To> >::type to_component_type; number<From> t(from); to_component_type n(t), d(1); using default_ops::assign_components; assign_components(to, n.backend(), d.backend()); }