/////////////////////////////////////////////////////////////////////////////// // Copyright 2011 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_0.txt) #ifndef BOOST_MATH_EXTENDED_REAL_HPP #define BOOST_MATH_EXTENDED_REAL_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // stream operators #include // EOF #include // isspace #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW #include #endif namespace boost { namespace multiprecision { #ifdef BOOST_MSVC // warning C4127: conditional expression is constant // warning C4714: function marked as __forceinline not inlined #pragma warning(push) #pragma warning(disable : 4127 4714 6326) #endif template class number { typedef number self_type; public: typedef Backend backend_type; typedef typename component_type::type value_type; BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number() BOOST_MP_NOEXCEPT_IF(noexcept(Backend())) {} BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const number& e) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval()))) : m_backend(e.m_backend) {} template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v, typename boost::enable_if_c< (boost::is_arithmetic::value || is_same::value || is_convertible::value) && !is_convertible::type, Backend>::value && !detail::is_restricted_conversion::type, Backend>::value #ifdef BOOST_HAS_FLOAT128 && !boost::is_same::value #endif >::type* = 0) { m_backend = canonical_value(v); } template BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const V& v, typename boost::enable_if_c< is_convertible::type, Backend>::value && !detail::is_restricted_conversion::type, Backend>::value>::type* = 0) #ifndef BOOST_INTEL BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval::type const&>()))) #endif : m_backend(canonical_value(v)) {} template BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const V& v, unsigned digits10, typename boost::enable_if_c<(boost::is_arithmetic::value || is_same::value || is_convertible::value) && !detail::is_restricted_conversion::type, Backend>::value && (boost::multiprecision::number_category::value != boost::multiprecision::number_kind_complex) && (boost::multiprecision::number_category::value != boost::multiprecision::number_kind_rational) #ifdef BOOST_HAS_FLOAT128 && !boost::is_same::value #endif >::type* = 0) : m_backend(canonical_value(v), digits10) {} BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const number& e, unsigned digits10) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval(), std::declval()))) : m_backend(e.m_backend, digits10) {} template explicit BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v, typename boost::enable_if_c< (boost::is_arithmetic::value || is_same::value || is_convertible::value) && !detail::is_explicitly_convertible::type, Backend>::value && detail::is_restricted_conversion::type, Backend>::value>::type* = 0) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval() = std::declval::type const&>())) { m_backend = canonical_value(v); } template explicit BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const V& v, typename boost::enable_if_c< detail::is_explicitly_convertible::type, Backend>::value && (detail::is_restricted_conversion::type, Backend>::value || !is_convertible::type, Backend>::value)>::type* = 0) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval::type const&>()))) : m_backend(canonical_value(v)) {} template explicit BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const V& v, unsigned digits10, typename boost::enable_if_c<(boost::is_arithmetic::value || is_same::value || is_convertible::value) && detail::is_restricted_conversion::type, Backend>::value && (boost::multiprecision::number_category::value != boost::multiprecision::number_kind_complex) && (boost::multiprecision::number_category::value != boost::multiprecision::number_kind_rational)>::type* = 0) : m_backend(canonical_value(v), digits10) {} template BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(const number& val) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval()))) : m_backend(val.backend()) {} template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const number& val, typename boost::enable_if_c<(boost::is_convertible::value && !detail::is_restricted_conversion::value)>::type* = 0) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval()))) : m_backend(val.backend()) {} template explicit BOOST_MP_CXX14_CONSTEXPR number(const number& val, typename boost::enable_if_c< (!detail::is_explicitly_convertible::value)>::type* = 0) { // // Attempt a generic interconvertion: // detail::scoped_default_precision > precision_guard_1(val); detail::scoped_default_precision > precision_guard_2(val); using detail::generic_interconvert; generic_interconvert(backend(), val.backend(), number_category(), number_category()); } template explicit BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const number& val, typename boost::enable_if_c< (detail::is_explicitly_convertible::value && (detail::is_restricted_conversion::value || !boost::is_convertible::value))>::type* = 0) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval()))) : m_backend(val.backend()) {} template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2, typename boost::enable_if_c<(is_convertible::value && is_convertible::value && !is_same::type, self_type>::value)>::type* = 0) { using default_ops::assign_components; detail::scoped_default_precision > precision_guard(v1, v2); assign_components(m_backend, canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2))); } template BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2, typename boost::enable_if_c< (is_constructible::value || is_convertible::value) && (is_constructible::value || is_convertible::value) && !is_same::type, self_type>::value && !is_same::value && !(is_convertible::value && is_convertible::value)>::type* = 0) { using default_ops::assign_components; detail::scoped_default_precision > precision_guard(v1, v2); assign_components(m_backend, canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2))); } #ifndef BOOST_NO_CXX17_HDR_STRING_VIEW // // Support for new types in C++17 // template explicit inline BOOST_MP_CXX14_CONSTEXPR number(const std::basic_string_view& view) { using default_ops::assign_from_string_view; assign_from_string_view(this->backend(), view); } template explicit inline BOOST_MP_CXX14_CONSTEXPR number(const std::basic_string_view& view_x, const std::basic_string_view& view_y) { using default_ops::assign_from_string_view; assign_from_string_view(this->backend(), view_x, view_y); } template explicit BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const std::basic_string_view& v, unsigned digits10) : m_backend(canonical_value(v), digits10) {} template BOOST_MP_CXX14_CONSTEXPR number& assign(const std::basic_string_view& view) { using default_ops::assign_from_string_view; assign_from_string_view(this->backend(), view); return *this; } #endif template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2, unsigned digits10, typename boost::enable_if_c<(is_convertible::value && is_convertible::value && !is_same::type, self_type>::value)>::type* = 0) : m_backend(canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2)), digits10) {} template BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR number(const V& v1, const U& v2, unsigned digits10, typename boost::enable_if_c<((is_constructible::value || is_convertible::value) && (is_constructible::value || is_convertible::value) && !is_same::type, self_type>::value) && !(is_convertible::value && is_convertible::value)>::type* = 0) : m_backend(canonical_value(detail::evaluate_if_expression(v1)), canonical_value(detail::evaluate_if_expression(v2)), digits10) {} template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number(const number& v1, const number& v2, typename boost::enable_if_c::value>::type* = 0) { using default_ops::assign_components; detail::scoped_default_precision > precision_guard(v1, v2); assign_components(m_backend, v1.backend(), v2.backend()); } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator=(const detail::expression& e) { typedef mpl::bool_::result_type>::value> tag_type; detail::scoped_default_precision > precision_guard(e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(e); return *this = BOOST_MP_MOVE(t); } do_assign(e, tag_type()); return *this; } template BOOST_MP_CXX14_CONSTEXPR number& assign(const detail::expression& e) { typedef mpl::bool_::result_type>::value> tag_type; detail::scoped_default_precision > precision_guard(e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t; t.assign(e); return *this = BOOST_MP_MOVE(t); } do_assign(e, tag_type()); return *this; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator=(const number& e) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval() = std::declval())) { m_backend = e.m_backend; return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator=(const V& v) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval() = std::declval::type&>())) { m_backend = canonical_value(v); return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& assign(const V& v) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval() = std::declval::type&>())) { m_backend = canonical_value(v); return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& assign(const V& v, unsigned digits10) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval() = std::declval::type&>())) { number t(v, digits10); return *this = t; } template BOOST_MP_CXX14_CONSTEXPR typename boost::disable_if, number&>::type assign(const number& v) { // // Attempt a generic interconvertion: // using detail::generic_interconvert; detail::scoped_default_precision > precision_guard(v); detail::scoped_default_precision > precision_guard2(v); // // If the current precision of *this differs from that of value v, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(v); return *this = BOOST_MP_MOVE(t); } generic_interconvert(backend(), v.backend(), number_category(), number_category()); return *this; } template BOOST_MP_CXX14_CONSTEXPR number(const detail::expression& e, typename boost::enable_if_c::result_type, self_type>::value>::type* = 0) { // // No preicsion guard here, we already have one in operator= // *this = e; } template explicit BOOST_MP_CXX14_CONSTEXPR number(const detail::expression& e, typename boost::enable_if_c::result_type, self_type>::value && boost::multiprecision::detail::is_explicitly_convertible::result_type, self_type>::value>::type* = 0) { // // No precision guard as assign has one already: // assign(e); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES BOOST_MP_FORCEINLINE BOOST_CONSTEXPR number(number&& r) BOOST_MP_NOEXCEPT_IF(noexcept(Backend(std::declval()))) : m_backend(static_cast(r.m_backend)) {} BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator=(number&& r) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval() = std::declval())) { m_backend = static_cast(r.m_backend); return *this; } #endif BOOST_MP_CXX14_CONSTEXPR number& operator+=(const self_type& val) { detail::scoped_default_precision > precision_guard(*this, val); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this + val); return *this = BOOST_MP_MOVE(t); } do_add(detail::expression(val), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator+=(const detail::expression& e) { detail::scoped_default_precision > precision_guard(*this, e); // Create a copy if e contains this, but not if we're just doing a // x += x if ((contains_self(e) && !is_self(e))) { self_type temp(e); do_add(detail::expression(temp), detail::terminal()); } else { do_add(e, tag()); } return *this; } template BOOST_MP_CXX14_CONSTEXPR number& operator+=(const detail::expression& e) { detail::scoped_default_precision > precision_guard(*this, e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this + e); return *this = BOOST_MP_MOVE(t); } // // Fused multiply-add: // using default_ops::eval_multiply_add; eval_multiply_add(m_backend, canonical_value(e.left_ref()), canonical_value(e.right_ref())); return *this; } template typename boost::enable_if_c::value, number&>::type BOOST_MP_CXX14_CONSTEXPR operator+=(const V& v) { using default_ops::eval_add; eval_add(m_backend, canonical_value(v)); return *this; } BOOST_MP_CXX14_CONSTEXPR number& operator-=(const self_type& val) { detail::scoped_default_precision > precision_guard(*this, val); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this - val); return *this = BOOST_MP_MOVE(t); } do_subtract(detail::expression(val), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator-=(const detail::expression& e) { detail::scoped_default_precision > precision_guard(*this, e); // Create a copy if e contains this: if (contains_self(e)) { self_type temp(e); do_subtract(detail::expression(temp), detail::terminal()); } else { do_subtract(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator-=(const V& v) { using default_ops::eval_subtract; eval_subtract(m_backend, canonical_value(v)); return *this; } template BOOST_MP_CXX14_CONSTEXPR number& operator-=(const detail::expression& e) { detail::scoped_default_precision > precision_guard(*this, e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this - e); return *this = BOOST_MP_MOVE(t); } // // Fused multiply-subtract: // using default_ops::eval_multiply_subtract; eval_multiply_subtract(m_backend, canonical_value(e.left_ref()), canonical_value(e.right_ref())); return *this; } BOOST_MP_CXX14_CONSTEXPR number& operator*=(const self_type& e) { detail::scoped_default_precision > precision_guard(*this, e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this * e); return *this = BOOST_MP_MOVE(t); } do_multiplies(detail::expression(e), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator*=(const detail::expression& e) { detail::scoped_default_precision > precision_guard(*this, e); // Create a temporary if the RHS references *this, but not // if we're just doing an x *= x; if ((contains_self(e) && !is_self(e))) { self_type temp(e); do_multiplies(detail::expression(temp), detail::terminal()); } else { do_multiplies(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator*=(const V& v) { using default_ops::eval_multiply; eval_multiply(m_backend, canonical_value(v)); return *this; } BOOST_MP_CXX14_CONSTEXPR number& operator%=(const self_type& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The modulus operation is only valid for integer types"); detail::scoped_default_precision > precision_guard(*this, e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this % e); return *this = BOOST_MP_MOVE(t); } do_modulus(detail::expression(e), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator%=(const detail::expression& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The modulus operation is only valid for integer types"); detail::scoped_default_precision > precision_guard(*this, e); // Create a temporary if the RHS references *this: if (contains_self(e)) { self_type temp(e); do_modulus(detail::expression(temp), detail::terminal()); } else { do_modulus(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator%=(const V& v) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The modulus operation is only valid for integer types"); using default_ops::eval_modulus; eval_modulus(m_backend, canonical_value(v)); return *this; } // // These operators are *not* proto-ized. // The issue is that the increment/decrement must happen // even if the result of the operator *is never used*. // Possibly we could modify our expression wrapper to // execute the increment/decrement on destruction, but // correct implementation will be tricky, so defered for now... // BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator++() { using default_ops::eval_increment; eval_increment(m_backend); return *this; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator--() { using default_ops::eval_decrement; eval_decrement(m_backend); return *this; } inline BOOST_MP_CXX14_CONSTEXPR number operator++(int) { using default_ops::eval_increment; self_type temp(*this); eval_increment(m_backend); return temp; } inline BOOST_MP_CXX14_CONSTEXPR number operator--(int) { using default_ops::eval_decrement; self_type temp(*this); eval_decrement(m_backend); return temp; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator<<=(V val) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The left-shift operation is only valid for integer types"); detail::check_shift_range(val, mpl::bool_<(sizeof(V) > sizeof(std::size_t))>(), mpl::bool_::value>()); eval_left_shift(m_backend, static_cast(canonical_value(val))); return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator>>=(V val) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The right-shift operation is only valid for integer types"); detail::check_shift_range(val, mpl::bool_<(sizeof(V) > sizeof(std::size_t))>(), mpl::bool_::value>()); eval_right_shift(m_backend, static_cast(canonical_value(val))); return *this; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator/=(const self_type& e) { detail::scoped_default_precision > precision_guard(*this, e); // // If the current precision of *this differs from that of expression e, then we // create a temporary (which will have the correct precision thanks to precision_guard) // and then move the result into *this. In C++17 we add a leading "if constexpr" // which causes this code to be eliminated in the common case that this type is // not actually variable precision. Pre C++17 this code should still be mostly // optimised away, but we can't prevent instantiation of the dead code leading // to longer build and possibly link times. // BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(number) if (precision_guard.precision() != boost::multiprecision::detail::current_precision_of(*this)) { number t(*this / e); return *this = BOOST_MP_MOVE(t); } do_divide(detail::expression(e), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator/=(const detail::expression& e) { detail::scoped_default_precision > precision_guard(*this, e); // Create a temporary if the RHS references *this: if (contains_self(e)) { self_type temp(e); do_divide(detail::expression(temp), detail::terminal()); } else { do_divide(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator/=(const V& v) { using default_ops::eval_divide; eval_divide(m_backend, canonical_value(v)); return *this; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator&=(const self_type& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise & operation is only valid for integer types"); do_bitwise_and(detail::expression(e), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator&=(const detail::expression& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise & operation is only valid for integer types"); // Create a temporary if the RHS references *this, but not // if we're just doing an x &= x; if (contains_self(e) && !is_self(e)) { self_type temp(e); do_bitwise_and(detail::expression(temp), detail::terminal()); } else { do_bitwise_and(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator&=(const V& v) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise & operation is only valid for integer types"); using default_ops::eval_bitwise_and; eval_bitwise_and(m_backend, canonical_value(v)); return *this; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator|=(const self_type& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise | operation is only valid for integer types"); do_bitwise_or(detail::expression(e), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator|=(const detail::expression& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise | operation is only valid for integer types"); // Create a temporary if the RHS references *this, but not // if we're just doing an x |= x; if (contains_self(e) && !is_self(e)) { self_type temp(e); do_bitwise_or(detail::expression(temp), detail::terminal()); } else { do_bitwise_or(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator|=(const V& v) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise | operation is only valid for integer types"); using default_ops::eval_bitwise_or; eval_bitwise_or(m_backend, canonical_value(v)); return *this; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number& operator^=(const self_type& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types"); do_bitwise_xor(detail::expression(e), detail::terminal()); return *this; } template BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::result_type, self_type>::value, number&>::type operator^=(const detail::expression& e) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types"); if (contains_self(e)) { self_type temp(e); do_bitwise_xor(detail::expression(temp), detail::terminal()); } else { do_bitwise_xor(e, typename detail::expression::tag_type()); } return *this; } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value, number&>::type operator^=(const V& v) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise ^ operation is only valid for integer types"); using default_ops::eval_bitwise_xor; eval_bitwise_xor(m_backend, canonical_value(v)); return *this; } // // swap: // BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR void swap(self_type& other) BOOST_MP_NOEXCEPT_IF(noexcept(std::declval().swap(std::declval()))) { m_backend.swap(other.backend()); } // // Zero and sign: // BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR bool is_zero() const { using default_ops::eval_is_zero; return eval_is_zero(m_backend); } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR int sign() const { using default_ops::eval_get_sign; return eval_get_sign(m_backend); } // // String conversion functions: // std::string str(std::streamsize digits = 0, std::ios_base::fmtflags f = std::ios_base::fmtflags(0)) const { return m_backend.str(digits, f); } template void serialize(Archive& ar, const unsigned int /*version*/) { ar& boost::make_nvp("backend", m_backend); } private: template BOOST_MP_CXX14_CONSTEXPR void convert_to_imp(T* result) const { using default_ops::eval_convert_to; eval_convert_to(result, m_backend); } template BOOST_MP_CXX14_CONSTEXPR void convert_to_imp(number* result) const { result->assign(*this); } BOOST_MP_CXX14_CONSTEXPR void convert_to_imp(std::string* result) const { *result = this->str(); } public: template BOOST_MP_CXX14_CONSTEXPR T convert_to() const { T result = T(); convert_to_imp(&result); return result; } // // Use in boolean context, and explicit conversion operators: // #ifndef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS #if (defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 7) && !defined(__clang__)) || (defined(BOOST_INTEL) && (BOOST_INTEL <= 1500)) // // Horrible workaround for gcc-4.6.x which always prefers the template // operator bool() rather than the non-template operator when converting to // an arithmetic type: // template ::value, int>::type = 0> explicit operator T() const { using default_ops::eval_is_zero; return !eval_is_zero(backend()); } template ::value || is_void::value, int>::type = 0> explicit operator T() const { return this->template convert_to(); } #else #if BOOST_WORKAROUND(BOOST_MSVC, < 1900) || (defined(__apple_build_version__) && BOOST_WORKAROUND(__clang_major__, < 9)) template #else template ::value || !boost::is_default_constructible::value || (!boost::is_arithmetic::value && !boost::is_complex::value), T>::type> #endif explicit BOOST_MP_CXX14_CONSTEXPR operator T() const { return this->template convert_to(); } BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const { return !is_zero(); } #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800) BOOST_MP_FORCEINLINE explicit operator void() const {} #endif #endif #else typedef bool (self_type::*unmentionable_type)() const; BOOST_MP_FORCEINLINE operator unmentionable_type() const { return is_zero() ? 0 : &self_type::is_zero; } #endif // // Default precision: // static BOOST_MP_CXX14_CONSTEXPR unsigned default_precision() BOOST_NOEXCEPT { return Backend::default_precision(); } static BOOST_MP_CXX14_CONSTEXPR void default_precision(unsigned digits10) { Backend::default_precision(digits10); } BOOST_MP_CXX14_CONSTEXPR unsigned precision() const BOOST_NOEXCEPT { return m_backend.precision(); } BOOST_MP_CXX14_CONSTEXPR void precision(unsigned digits10) { m_backend.precision(digits10); } // // Comparison: // BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR int compare(const number& o) const BOOST_MP_NOEXCEPT_IF(noexcept(std::declval().compare(std::declval()))) { return m_backend.compare(o.m_backend); } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value && (number_category::value != number_kind_complex), int>::type compare(const V& o) const { using default_ops::eval_get_sign; if (o == 0) return eval_get_sign(m_backend); return m_backend.compare(canonical_value(o)); } template BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename boost::enable_if_c::value && (number_category::value == number_kind_complex), int>::type compare(const V& o) const { using default_ops::eval_get_sign; return m_backend.compare(canonical_value(o)); } // // Direct access to the underlying backend: // #if !(defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_REF_QUALIFIERS) || BOOST_WORKAROUND(BOOST_GCC, < 50000)) BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend& backend() & BOOST_NOEXCEPT { return m_backend; } BOOST_MP_FORCEINLINE BOOST_CONSTEXPR const Backend& backend() const& BOOST_NOEXCEPT { return m_backend; } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend&& backend() && BOOST_NOEXCEPT { return static_cast(m_backend); } BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend const&& backend() const&& BOOST_NOEXCEPT { return static_cast(m_backend); } #else BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR Backend& backend() BOOST_NOEXCEPT { return m_backend; } BOOST_MP_FORCEINLINE BOOST_CONSTEXPR const Backend& backend() const BOOST_NOEXCEPT { return m_backend; } #endif // // Complex number real and imag: // BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex >::type real() const { using default_ops::eval_real; detail::scoped_default_precision >::type> precision_guard(*this); typename scalar_result_from_possible_complex >::type result; eval_real(result.backend(), backend()); return result; } BOOST_MP_CXX14_CONSTEXPR typename scalar_result_from_possible_complex >::type imag() const { using default_ops::eval_imag; detail::scoped_default_precision >::type> precision_guard(*this); typename scalar_result_from_possible_complex >::type result; eval_imag(result.backend(), backend()); return result; } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value, self_type&>::type real(const T& val) { using default_ops::eval_set_real; eval_set_real(backend(), canonical_value(val)); return *this; } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && number_category::value == number_kind_complex, self_type&>::type imag(const T& val) { using default_ops::eval_set_imag; eval_set_imag(backend(), canonical_value(val)); return *this; } private: template BOOST_MP_CXX14_CONSTEXPR void do_assign(const detail::expression& e, const mpl::true_&) { do_assign(e, tag()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const detail::expression& e, const mpl::false_&) { // The result of the expression isn't the same type as this - // create a temporary result and assign it to *this: typedef typename detail::expression::result_type temp_type; temp_type t(e); this->assign(t); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::add_immediates&) { using default_ops::eval_add; boost::multiprecision::detail::maybe_promote_precision(this); eval_add(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::subtract_immediates&) { using default_ops::eval_subtract; boost::multiprecision::detail::maybe_promote_precision(this); eval_subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiply_immediates&) { using default_ops::eval_multiply; boost::multiprecision::detail::maybe_promote_precision(this); eval_multiply(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiply_add&) { using default_ops::eval_multiply_add; boost::multiprecision::detail::maybe_promote_precision(this); eval_multiply_add(m_backend, canonical_value(e.left().value()), canonical_value(e.middle().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiply_subtract&) { using default_ops::eval_multiply_subtract; boost::multiprecision::detail::maybe_promote_precision(this); eval_multiply_subtract(m_backend, canonical_value(e.left().value()), canonical_value(e.middle().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::divide_immediates&) { using default_ops::eval_divide; boost::multiprecision::detail::maybe_promote_precision(this); eval_divide(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::negate&) { typedef typename Exp::left_type left_type; do_assign(e.left(), typename left_type::tag_type()); m_backend.negate(); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::plus&) { typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; BOOST_CONSTEXPR int const left_depth = left_type::depth; BOOST_CONSTEXPR int const right_depth = right_type::depth; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && br) { self_type temp(e); temp.m_backend.swap(this->m_backend); } else if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_add(e.right(), typename right_type::tag_type()); } else if (br && is_self(e.right())) { // Ignore the right node, it's *this, just add the left: do_add(e.left(), typename left_type::tag_type()); } else if (!br && (bl || (left_depth >= right_depth))) { // br is always false, but if bl is true we must take the this branch: do_assign(e.left(), typename left_type::tag_type()); do_add(e.right(), typename right_type::tag_type()); } else { do_assign(e.right(), typename right_type::tag_type()); do_add(e.left(), typename left_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::minus&) { typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; BOOST_CONSTEXPR int const left_depth = left_type::depth; BOOST_CONSTEXPR int const right_depth = right_type::depth; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && br) { self_type temp(e); temp.m_backend.swap(this->m_backend); } else if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just subtract the right: do_subtract(e.right(), typename right_type::tag_type()); } else if (br && is_self(e.right())) { // Ignore the right node, it's *this, just subtract the left and negate the result: do_subtract(e.left(), typename left_type::tag_type()); m_backend.negate(); } else if (!br && (bl || (left_depth >= right_depth))) { // br is always false, but if bl is true we must take the this branch: do_assign(e.left(), typename left_type::tag_type()); do_subtract(e.right(), typename right_type::tag_type()); } else { do_assign(e.right(), typename right_type::tag_type()); do_subtract(e.left(), typename left_type::tag_type()); m_backend.negate(); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::multiplies&) { typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; BOOST_CONSTEXPR int const left_depth = left_type::depth; BOOST_CONSTEXPR int const right_depth = right_type::depth; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && br) { self_type temp(e); temp.m_backend.swap(this->m_backend); } else if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_multiplies(e.right(), typename right_type::tag_type()); } else if (br && is_self(e.right())) { // Ignore the right node, it's *this, just add the left: do_multiplies(e.left(), typename left_type::tag_type()); } else if (!br && (bl || (left_depth >= right_depth))) { // br is always false, but if bl is true we must take the this branch: do_assign(e.left(), typename left_type::tag_type()); do_multiplies(e.right(), typename right_type::tag_type()); } else { do_assign(e.right(), typename right_type::tag_type()); do_multiplies(e.left(), typename left_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::divides&) { typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_divide(e.right(), typename right_type::tag_type()); } else if (br) { self_type temp(e); temp.m_backend.swap(this->m_backend); } else { do_assign(e.left(), typename left_type::tag_type()); do_divide(e.right(), typename right_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::modulus&) { // // This operation is only valid for integer backends: // BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The modulus operation is only valid for integer types"); typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_modulus(e.right(), typename right_type::tag_type()); } else if (br) { self_type temp(e); temp.m_backend.swap(this->m_backend); } else { do_assign(e.left(), typename left_type::tag_type()); do_modulus(e.right(), typename right_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::modulus_immediates&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The modulus operation is only valid for integer types"); using default_ops::eval_modulus; boost::multiprecision::detail::maybe_promote_precision(this); eval_modulus(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_and&) { // // This operation is only valid for integer backends: // BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "Bitwise operations are only valid for integer types"); typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; BOOST_CONSTEXPR int const left_depth = left_type::depth; BOOST_CONSTEXPR int const right_depth = right_type::depth; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_bitwise_and(e.right(), typename right_type::tag_type()); } else if (br && is_self(e.right())) { do_bitwise_and(e.left(), typename left_type::tag_type()); } else if (!br && (bl || (left_depth >= right_depth))) { do_assign(e.left(), typename left_type::tag_type()); do_bitwise_and(e.right(), typename right_type::tag_type()); } else { do_assign(e.right(), typename right_type::tag_type()); do_bitwise_and(e.left(), typename left_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_and_immediates&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "Bitwise operations are only valid for integer types"); using default_ops::eval_bitwise_and; eval_bitwise_and(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_or&) { // // This operation is only valid for integer backends: // BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "Bitwise operations are only valid for integer types"); typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; BOOST_CONSTEXPR int const left_depth = left_type::depth; BOOST_CONSTEXPR int const right_depth = right_type::depth; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_bitwise_or(e.right(), typename right_type::tag_type()); } else if (br && is_self(e.right())) { do_bitwise_or(e.left(), typename left_type::tag_type()); } else if (!br && (bl || (left_depth >= right_depth))) { do_assign(e.left(), typename left_type::tag_type()); do_bitwise_or(e.right(), typename right_type::tag_type()); } else { do_assign(e.right(), typename right_type::tag_type()); do_bitwise_or(e.left(), typename left_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_or_immediates&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "Bitwise operations are only valid for integer types"); using default_ops::eval_bitwise_or; eval_bitwise_or(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_xor&) { // // This operation is only valid for integer backends: // BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "Bitwise operations are only valid for integer types"); typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; BOOST_CONSTEXPR int const left_depth = left_type::depth; BOOST_CONSTEXPR int const right_depth = right_type::depth; bool bl = contains_self(e.left()); bool br = contains_self(e.right()); if (bl && is_self(e.left())) { // Ignore the left node, it's *this, just add the right: do_bitwise_xor(e.right(), typename right_type::tag_type()); } else if (br && is_self(e.right())) { do_bitwise_xor(e.left(), typename left_type::tag_type()); } else if (!br && (bl || (left_depth >= right_depth))) { do_assign(e.left(), typename left_type::tag_type()); do_bitwise_xor(e.right(), typename right_type::tag_type()); } else { do_assign(e.right(), typename right_type::tag_type()); do_bitwise_xor(e.left(), typename left_type::tag_type()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_xor_immediates&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "Bitwise operations are only valid for integer types"); using default_ops::eval_bitwise_xor; eval_bitwise_xor(m_backend, canonical_value(e.left().value()), canonical_value(e.right().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::terminal&) { if (!is_self(e)) { m_backend = canonical_value(e.value()); } } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::function&) { typedef typename Exp::arity tag_type; boost::multiprecision::detail::maybe_promote_precision(this); do_assign_function(e, tag_type()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::shift_left&) { // We can only shift by an integer value, not an arbitrary expression: typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; typedef typename right_type::arity right_arity; BOOST_STATIC_ASSERT_MSG(right_arity::value == 0, "The left shift operator requires an integer value for the shift operand."); typedef typename right_type::result_type right_value_type; BOOST_STATIC_ASSERT_MSG(is_integral::value, "The left shift operator requires an integer value for the shift operand."); typedef typename left_type::tag_type tag_type; do_assign_left_shift(e.left(), canonical_value(e.right().value()), tag_type()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::shift_right&) { // We can only shift by an integer value, not an arbitrary expression: typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; typedef typename right_type::arity right_arity; BOOST_STATIC_ASSERT_MSG(right_arity::value == 0, "The left shift operator requires an integer value for the shift operand."); typedef typename right_type::result_type right_value_type; BOOST_STATIC_ASSERT_MSG(is_integral::value, "The left shift operator requires an integer value for the shift operand."); typedef typename left_type::tag_type tag_type; do_assign_right_shift(e.left(), canonical_value(e.right().value()), tag_type()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::bitwise_complement&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise ~ operation is only valid for integer types"); using default_ops::eval_complement; self_type temp(e.left()); eval_complement(m_backend, temp.backend()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign(const Exp& e, const detail::complement_immediates&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The bitwise ~ operation is only valid for integer types"); using default_ops::eval_complement; eval_complement(m_backend, canonical_value(e.left().value())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_right_shift(const Exp& e, const Val& val, const detail::terminal&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The right shift operation is only valid for integer types"); using default_ops::eval_right_shift; detail::check_shift_range(val, mpl::bool_<(sizeof(Val) > sizeof(std::size_t))>(), mpl::bool_::value>()); eval_right_shift(m_backend, canonical_value(e.value()), static_cast(val)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_left_shift(const Exp& e, const Val& val, const detail::terminal&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The left shift operation is only valid for integer types"); using default_ops::eval_left_shift; detail::check_shift_range(val, mpl::bool_<(sizeof(Val) > sizeof(std::size_t))>(), mpl::bool_::value>()); eval_left_shift(m_backend, canonical_value(e.value()), static_cast(val)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_right_shift(const Exp& e, const Val& val, const Tag&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The right shift operation is only valid for integer types"); using default_ops::eval_right_shift; self_type temp(e); detail::check_shift_range(val, mpl::bool_<(sizeof(Val) > sizeof(std::size_t))>(), mpl::bool_::value>()); eval_right_shift(m_backend, temp.backend(), static_cast(val)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_left_shift(const Exp& e, const Val& val, const Tag&) { BOOST_STATIC_ASSERT_MSG(number_category::value == number_kind_integer, "The left shift operation is only valid for integer types"); using default_ops::eval_left_shift; self_type temp(e); detail::check_shift_range(val, mpl::bool_<(sizeof(Val) > sizeof(std::size_t))>(), mpl::bool_::value>()); eval_left_shift(m_backend, temp.backend(), static_cast(val)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const mpl::int_<1>&) { e.left().value()(&m_backend); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const mpl::int_<2>&) { typedef typename Exp::right_type right_type; typedef typename right_type::tag_type tag_type; do_assign_function_1(e.left().value(), e.right_ref(), tag_type()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_1(const F& f, const Exp& val, const detail::terminal&) { f(m_backend, function_arg_value(val)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_1(const F& f, const Exp& val, const Tag&) { typename Exp::result_type t(val); f(m_backend, t.backend()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const mpl::int_<3>&) { typedef typename Exp::middle_type middle_type; typedef typename middle_type::tag_type tag_type; typedef typename Exp::right_type end_type; typedef typename end_type::tag_type end_tag; do_assign_function_2(e.left().value(), e.middle_ref(), e.right_ref(), tag_type(), end_tag()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const detail::terminal&, const detail::terminal&) { f(m_backend, function_arg_value(val1), function_arg_value(val2)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const Tag1&, const detail::terminal&) { typename Exp1::result_type temp1(val1); f(m_backend, BOOST_MP_MOVE(temp1.backend()), function_arg_value(val2)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const detail::terminal&, const Tag2&) { typename Exp2::result_type temp2(val2); f(m_backend, function_arg_value(val1), BOOST_MP_MOVE(temp2.backend())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_2(const F& f, const Exp1& val1, const Exp2& val2, const Tag1&, const Tag2&) { typename Exp1::result_type temp1(val1); typename Exp2::result_type temp2(val2); f(m_backend, BOOST_MP_MOVE(temp1.backend()), BOOST_MP_MOVE(temp2.backend())); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function(const Exp& e, const mpl::int_<4>&) { typedef typename Exp::left_middle_type left_type; typedef typename left_type::tag_type left_tag_type; typedef typename Exp::right_middle_type middle_type; typedef typename middle_type::tag_type middle_tag_type; typedef typename Exp::right_type right_type; typedef typename right_type::tag_type right_tag_type; do_assign_function_3a(e.left().value(), e.left_middle_ref(), e.right_middle_ref(), e.right_ref(), left_tag_type(), middle_tag_type(), right_tag_type()); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&, const Tag2& t2, const Tag3& t3) { do_assign_function_3b(f, val1, val2, val3, t2, t3); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3a(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag1&, const Tag2& t2, const Tag3& t3) { typename Exp1::result_type t(val1); do_assign_function_3b(f, BOOST_MP_MOVE(t), val2, val3, t2, t3); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&, const Tag3& t3) { do_assign_function_3c(f, val1, val2, val3, t3); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3b(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag2& /*t2*/, const Tag3& t3) { typename Exp2::result_type t(val2); do_assign_function_3c(f, val1, BOOST_MP_MOVE(t), val3, t3); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const detail::terminal&) { f(m_backend, function_arg_value(val1), function_arg_value(val2), function_arg_value(val3)); } template BOOST_MP_CXX14_CONSTEXPR void do_assign_function_3c(const F& f, const Exp1& val1, const Exp2& val2, const Exp3& val3, const Tag3& /*t3*/) { typename Exp3::result_type t(val3); do_assign_function_3c(f, val1, val2, BOOST_MP_MOVE(t), detail::terminal()); } template BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::terminal&) { using default_ops::eval_add; boost::multiprecision::detail::maybe_promote_precision(this); eval_add(m_backend, canonical_value(e.value())); } template BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::negate&) { typedef typename Exp::left_type left_type; boost::multiprecision::detail::maybe_promote_precision(this); do_subtract(e.left(), typename left_type::tag_type()); } template BOOST_MP_CXX14_CONSTEXPR void do_add(const Exp& e, const detail::plus&) { typedef typename Exp::left_type left_type; typedef typename Exp::right_type right_type; do_add(e.left(), typename left_type::tag_type()); do_add(e.right(), typename right_type::tag_type()); } template