boost/multiprecision/detail/number_base.hpp
/////////////////////////////////////////////////////////////////////////////// // 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_MP_NUMBER_BASE_HPP #define BOOST_MP_NUMBER_BASE_HPP #include <climits> #include <ios> #include <string> #include <limits> #include <type_traits> #include <stdexcept> #include <tuple> #include <boost/multiprecision/detail/standalone_config.hpp> #include <boost/multiprecision/fwd.hpp> #include <boost/multiprecision/traits/transcendental_reduction_type.hpp> #include <boost/multiprecision/traits/std_integer_traits.hpp> #include <boost/multiprecision/detail/no_exceptions_support.hpp> #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 4307) #pragma warning(pop) #endif #ifndef BOOST_MP_STANDALONE #include <boost/lexical_cast.hpp> #include <boost/core/nvp.hpp> #endif #ifdef BOOST_MP_MATH_AVAILABLE #include <boost/math/tools/complex.hpp> #endif // We now require C++11. #include <boost/multiprecision/detail/check_cpp11_config.hpp> #if defined(NDEBUG) && !defined(_DEBUG) #define BOOST_MP_FORCEINLINE BOOST_FORCEINLINE #else #define BOOST_MP_FORCEINLINE inline #endif // // Thread local storage: // Note fails on Mingw, see https://sourceforge.net/p/mingw-w64/bugs/527/ // #if defined(BOOST_NO_CXX11_THREAD_LOCAL) #define BOOST_MP_THREAD_LOCAL #elif !(defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ < 9)) && !defined(__clang__)) #define BOOST_MP_THREAD_LOCAL thread_local #define BOOST_MP_USING_THREAD_LOCAL #else #pragma GCC warning "thread_local on mingw is broken, please use MSys mingw gcc-9 or later, see https://sourceforge.net/p/mingw-w64/bugs/527/" #define BOOST_MP_THREAD_LOCAL #endif #ifdef __has_include # if __has_include(<version>) # include <version> # ifdef __cpp_lib_is_constant_evaluated # include <type_traits> # define BOOST_MP_HAS_IS_CONSTANT_EVALUATED # endif # endif #endif #ifdef __has_builtin #if __has_builtin(__builtin_is_constant_evaluated) && !defined(BOOST_NO_CXX14_CONSTEXPR) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) #define BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED #endif #endif // // MSVC also supports __builtin_is_constant_evaluated if it's recent enough: // #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 192528326) # define BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED #endif // // As does GCC-9: // #if defined(BOOST_GCC) && !defined(BOOST_NO_CXX14_CONSTEXPR) && (__GNUC__ >= 9) && !defined(BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED) # define BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED #endif #if defined(BOOST_MP_HAS_IS_CONSTANT_EVALUATED) && !defined(BOOST_NO_CXX14_CONSTEXPR) # define BOOST_MP_IS_CONST_EVALUATED(x) std::is_constant_evaluated() #elif defined(BOOST_MP_HAS_BUILTIN_IS_CONSTANT_EVALUATED) # define BOOST_MP_IS_CONST_EVALUATED(x) __builtin_is_constant_evaluated() #elif !defined(BOOST_NO_CXX14_CONSTEXPR) && defined(BOOST_GCC) && (__GNUC__ >= 6) # define BOOST_MP_IS_CONST_EVALUATED(x) __builtin_constant_p(x) #else # define BOOST_MP_NO_CONSTEXPR_DETECTION #endif #ifdef BOOST_MP_NO_CONSTEXPR_DETECTION # define BOOST_CXX14_CONSTEXPR_IF_DETECTION #else # define BOOST_CXX14_CONSTEXPR_IF_DETECTION constexpr #endif #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable : 6326) #endif namespace boost { namespace multiprecision { enum struct variable_precision_options : signed char { assume_uniform_precision = -1, preserve_target_precision = 0, preserve_source_precision = 1, preserve_component_precision = 2, preserve_related_precision = 3, preserve_all_precision = 4, }; inline constexpr bool operator==(variable_precision_options a, variable_precision_options b) { return static_cast<unsigned>(a) == static_cast<unsigned>(b); } template <class T> struct is_et_number : public std::integral_constant<bool, false> {}; template <class Backend> struct is_et_number<number<Backend, et_on> > : public std::integral_constant<bool, true> {}; template <class T> struct is_no_et_number : public std::integral_constant<bool, false> {}; template <class Backend> struct is_no_et_number<number<Backend, et_off> > : public std::integral_constant<bool, true> {}; template <class T> struct is_number_expression : public std::integral_constant<bool, false> {}; template <class tag, class Arg1, class Arg2, class Arg3, class Arg4> struct is_number_expression<detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > : public std::integral_constant<bool, true> {}; namespace detail { template <class Val, class Backend> struct canonical; } template <class T, class Num> struct is_compatible_arithmetic_type : public std::integral_constant<bool, std::is_convertible<T, Num>::value && !std::is_same<T, Num>::value && !is_number_expression<T>::value && (std::is_constructible<typename Num::backend_type, typename detail::canonical<T, typename Num::backend_type>::type>::value || std::is_assignable<typename Num::backend_type, typename detail::canonical<T, typename Num::backend_type>::type>::value || is_number<T>::value || is_number_expression<T>::value)> {}; namespace detail { // // Workaround for missing abs(long long) and abs(__int128) on some compilers: // template <class T> constexpr typename std::enable_if<(boost::multiprecision::detail::is_signed<T>::value || std::is_floating_point<T>::value), T>::type abs(T t) noexcept { // This strange expression avoids a hardware trap in the corner case // that val is the most negative value permitted in long long. // See https://svn.boost.org/trac/boost/ticket/9740. return t < 0 ? T(1u) + T(-(t + 1)) : t; } template <class T> constexpr typename std::enable_if<boost::multiprecision::detail::is_unsigned<T>::value, T>::type abs(T t) noexcept { return t; } #define BOOST_MP_USING_ABS using boost::multiprecision::detail::abs; template <class T> constexpr typename std::enable_if<(boost::multiprecision::detail::is_signed<T>::value || std::is_floating_point<T>::value), typename boost::multiprecision::detail::make_unsigned<T>::type>::type unsigned_abs(T t) noexcept { // This strange expression avoids a hardware trap in the corner case // that val is the most negative value permitted in long long. // See https://svn.boost.org/trac/boost/ticket/9740. return t < 0 ? static_cast<typename boost::multiprecision::detail::make_unsigned<T>::type>(1u) + static_cast<typename boost::multiprecision::detail::make_unsigned<T>::type>(-(t + 1)) : static_cast<typename boost::multiprecision::detail::make_unsigned<T>::type>(t); } template <class T> constexpr typename std::enable_if<boost::multiprecision::detail::is_unsigned<T>::value, T>::type unsigned_abs(T t) noexcept { return t; } template <class T> struct bits_of { static_assert(boost::multiprecision::detail::is_integral<T>::value || std::is_enum<T>::value || std::numeric_limits<T>::is_specialized, "Failed integer size check"); static constexpr unsigned value = std::numeric_limits<T>::is_specialized ? std::numeric_limits<T>::digits : sizeof(T) * CHAR_BIT - (boost::multiprecision::detail::is_signed<T>::value ? 1 : 0); }; #if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__) #define BOOST_MP_BITS_OF_FLOAT128_DEFINED template <> struct bits_of<float128_type> { static constexpr unsigned value = 113; }; #endif template <int b> struct has_enough_bits { template <class T> struct type : public std::integral_constant<bool, bits_of<T>::value >= b> {}; }; template <class Tuple, int i, int digits, bool = (i >= std::tuple_size<Tuple>::value)> struct find_index_of_large_enough_type { static constexpr int value = bits_of<typename std::tuple_element<static_cast<std::size_t>(i), Tuple>::type>::value >= digits ? i : find_index_of_large_enough_type<Tuple, i + 1, digits>::value; }; template <class Tuple, int i, int digits> struct find_index_of_large_enough_type<Tuple, i, digits, true> { static constexpr int value = INT_MAX; }; template <int index, class Tuple, class Fallback, bool = (std::tuple_size<Tuple>::value <= index)> struct dereference_tuple { using type = typename std::tuple_element<static_cast<std::size_t>(index), Tuple>::type; }; template <int index, class Tuple, class Fallback> struct dereference_tuple<index, Tuple, Fallback, true> { using type = Fallback; }; template <class Val, class Backend, class Tag> struct canonical_imp { using type = typename std::remove_cv<typename std::decay<const Val>::type>::type; }; template <class B, class Backend, class Tag> struct canonical_imp<number<B, et_on>, Backend, Tag> { using type = B; }; template <class B, class Backend, class Tag> struct canonical_imp<number<B, et_off>, Backend, Tag> { using type = B; }; #ifdef __SUNPRO_CC template <class B, class Backend> struct canonical_imp<number<B, et_on>, Backend, std::integral_constant<int, 3> > { using type = B; }; template <class B, class Backend> struct canonical_imp<number<B, et_off>, Backend, std::integral_constant<int, 3> > { using type = B; }; #endif template <class Val, class Backend> struct canonical_imp<Val, Backend, std::integral_constant<int, 0> > { static constexpr int index = find_index_of_large_enough_type<typename Backend::signed_types, 0, bits_of<Val>::value>::value; using type = typename dereference_tuple<index, typename Backend::signed_types, Val>::type; }; template <class Val, class Backend> struct canonical_imp<Val, Backend, std::integral_constant<int, 1> > { static constexpr int index = find_index_of_large_enough_type<typename Backend::unsigned_types, 0, bits_of<Val>::value>::value; using type = typename dereference_tuple<index, typename Backend::unsigned_types, Val>::type; }; template <class Val, class Backend> struct canonical_imp<Val, Backend, std::integral_constant<int, 2> > { static constexpr int index = find_index_of_large_enough_type<typename Backend::float_types, 0, bits_of<Val>::value>::value; using type = typename dereference_tuple<index, typename Backend::float_types, Val>::type; }; template <class Val, class Backend> struct canonical_imp<Val, Backend, std::integral_constant<int, 3> > { using type = const char*; }; template <class Val, class Backend> struct canonical_imp<Val, Backend, std::integral_constant<int, 4> > { using underlying = typename std::underlying_type<Val>::type; using tag = typename std::conditional<boost::multiprecision::detail::is_signed<Val>::value, std::integral_constant<int, 0>, std::integral_constant<int, 1>>::type; using type = typename canonical_imp<underlying, Backend, tag>::type; }; template <class Val, class Backend> struct canonical { using tag_type = typename std::conditional< boost::multiprecision::detail::is_signed<Val>::value && boost::multiprecision::detail::is_integral<Val>::value, std::integral_constant<int, 0>, typename std::conditional< boost::multiprecision::detail::is_unsigned<Val>::value, std::integral_constant<int, 1>, typename std::conditional< std::is_floating_point<Val>::value, std::integral_constant<int, 2>, typename std::conditional< (std::is_convertible<Val, const char*>::value || std::is_same<Val, std::string>::value), std::integral_constant<int, 3>, typename std::conditional< std::is_enum<Val>::value, std::integral_constant<int, 4>, std::integral_constant<int, 5> >::type>::type>::type>::type>::type; using type = typename canonical_imp<Val, Backend, tag_type>::type; }; struct terminal {}; struct negate {}; struct plus {}; struct minus {}; struct multiplies {}; struct divides {}; struct modulus {}; struct shift_left {}; struct shift_right {}; struct bitwise_and {}; struct bitwise_or {}; struct bitwise_xor {}; struct bitwise_complement {}; struct add_immediates {}; struct subtract_immediates {}; struct multiply_immediates {}; struct divide_immediates {}; struct modulus_immediates {}; struct bitwise_and_immediates {}; struct bitwise_or_immediates {}; struct bitwise_xor_immediates {}; struct complement_immediates {}; struct function {}; struct multiply_add {}; struct multiply_subtract {}; template <class T> struct backend_type; template <class T, expression_template_option ExpressionTemplates> struct backend_type<number<T, ExpressionTemplates> > { using type = T; }; template <class tag, class A1, class A2, class A3, class A4> struct backend_type<expression<tag, A1, A2, A3, A4> > { using type = typename backend_type<typename expression<tag, A1, A2, A3, A4>::result_type>::type; }; template <class T1, class T2> struct combine_expression { using type = decltype(T1() + T2()); }; template <class T1, expression_template_option ExpressionTemplates, class T2> struct combine_expression<number<T1, ExpressionTemplates>, T2> { using type = number<T1, ExpressionTemplates>; }; template <class T1, class T2, expression_template_option ExpressionTemplates> struct combine_expression<T1, number<T2, ExpressionTemplates> > { using type = number<T2, ExpressionTemplates>; }; template <class T, expression_template_option ExpressionTemplates> struct combine_expression<number<T, ExpressionTemplates>, number<T, ExpressionTemplates> > { using type = number<T, ExpressionTemplates>; }; template <class T1, expression_template_option ExpressionTemplates1, class T2, expression_template_option ExpressionTemplates2> struct combine_expression<number<T1, ExpressionTemplates1>, number<T2, ExpressionTemplates2> > { using type = typename std::conditional< std::is_convertible<number<T2, ExpressionTemplates2>, number<T1, ExpressionTemplates2> >::value, number<T1, ExpressionTemplates1>, number<T2, ExpressionTemplates2> >::type; }; template <class T> struct arg_type { using type = expression<terminal, T>; }; template <class Tag, class Arg1, class Arg2, class Arg3, class Arg4> struct arg_type<expression<Tag, Arg1, Arg2, Arg3, Arg4> > { using type = expression<Tag, Arg1, Arg2, Arg3, Arg4>; }; struct unmentionable { unmentionable* proc() { return nullptr; } }; typedef unmentionable* (unmentionable::*unmentionable_type)(); template <class T, bool b> struct expression_storage_base { using type = const T&; }; template <class T> struct expression_storage_base<T, true> { using type = T; }; template <class T> struct expression_storage : public expression_storage_base<T, boost::multiprecision::detail::is_arithmetic<T>::value> {}; template <class T> struct expression_storage<T*> { using type = T*; }; template <class T> struct expression_storage<const T*> { using type = const T*; }; template <class tag, class A1, class A2, class A3, class A4> struct expression_storage<expression<tag, A1, A2, A3, A4> > { using type = expression<tag, A1, A2, A3, A4>; }; template <class tag, class Arg1> struct expression<tag, Arg1, void, void, void> { using arity = std::integral_constant<int, 1> ; using left_type = typename arg_type<Arg1>::type ; using left_result_type = typename left_type::result_type; using result_type = typename left_type::result_type; using tag_type = tag ; explicit BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a) : arg(a) {} BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg(e.arg) {} // // If we have static_assert we can give a more useful error message // than if we simply have no operator defined at all: // template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR left_type left() const { return left_type(arg); } BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg; } static constexpr unsigned depth = left_type::depth + 1; template <class T #ifndef __SUNPRO_CC , typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0 #endif > explicit BOOST_MP_CXX14_CONSTEXPR operator T() const { return static_cast<T>(static_cast<result_type>(*this)); } BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const { result_type r(*this); return static_cast<bool>(r); } template <class T> BOOST_MP_CXX14_CONSTEXPR T convert_to() { result_type r(*this); return r.template convert_to<T>(); } private: typename expression_storage<Arg1>::type arg; expression& operator=(const expression&); }; template <class Arg1> struct expression<terminal, Arg1, void, void, void> { using arity = std::integral_constant<int, 0>; using result_type = Arg1 ; using tag_type = terminal ; explicit BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a) : arg(a) {} BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg(e.arg) {} // // If we have static_assert we can give a more useful error message // than if we simply have no operator defined at all: // template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR const Arg1& value() const noexcept { return arg; } static constexpr unsigned depth = 0; template <class T #ifndef __SUNPRO_CC , typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0 #endif > explicit BOOST_MP_CXX14_CONSTEXPR operator T() const { return static_cast<T>(static_cast<result_type>(*this)); } BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const { result_type r(*this); return static_cast<bool>(r); } template <class T> BOOST_MP_CXX14_CONSTEXPR T convert_to() { result_type r(*this); return r.template convert_to<T>(); } private: typename expression_storage<Arg1>::type arg; expression& operator=(const expression&); }; template <class tag, class Arg1, class Arg2> struct expression<tag, Arg1, Arg2, void, void> { using arity = std::integral_constant<int, 2> ; using left_type = typename arg_type<Arg1>::type ; using right_type = typename arg_type<Arg2>::type ; using left_result_type = typename left_type::result_type ; using right_result_type = typename right_type::result_type ; using result_type = typename combine_expression<left_result_type, right_result_type>::type; using tag_type = tag ; BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a1, const Arg2& a2) : arg1(a1), arg2(a2) {} BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg1(e.arg1), arg2(e.arg2) {} // // If we have static_assert we can give a more useful error message // than if we simply have no operator defined at all: // template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR left_type left() const { return left_type(arg1); } BOOST_MP_CXX14_CONSTEXPR right_type right() const { return right_type(arg2); } BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg1; } BOOST_MP_CXX14_CONSTEXPR const Arg2& right_ref() const noexcept { return arg2; } template <class T #ifndef __SUNPRO_CC , typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0 #endif > explicit BOOST_MP_CXX14_CONSTEXPR operator T() const { return static_cast<T>(static_cast<result_type>(*this)); } BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const { result_type r(*this); return static_cast<bool>(r); } template <class T> BOOST_MP_CXX14_CONSTEXPR T convert_to() { result_type r(*this); return r.template convert_to<T>(); } static const constexpr unsigned left_depth = left_type::depth + 1; static const constexpr unsigned right_depth = right_type::depth + 1; static const constexpr unsigned depth = left_depth > right_depth ? left_depth : right_depth; private: typename expression_storage<Arg1>::type arg1; typename expression_storage<Arg2>::type arg2; expression& operator=(const expression&); }; template <class tag, class Arg1, class Arg2, class Arg3> struct expression<tag, Arg1, Arg2, Arg3, void> { using arity = std::integral_constant<int, 3> ; using left_type = typename arg_type<Arg1>::type ; using middle_type = typename arg_type<Arg2>::type ; using right_type = typename arg_type<Arg3>::type ; using left_result_type = typename left_type::result_type ; using middle_result_type = typename middle_type::result_type; using right_result_type = typename right_type::result_type ; using result_type = typename combine_expression< left_result_type, typename combine_expression<right_result_type, middle_result_type>::type>::type; using tag_type = tag ; BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a1, const Arg2& a2, const Arg3& a3) : arg1(a1), arg2(a2), arg3(a3) {} BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg1(e.arg1), arg2(e.arg2), arg3(e.arg3) {} // // If we have static_assert we can give a more useful error message // than if we simply have no operator defined at all: // template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR left_type left() const { return left_type(arg1); } BOOST_MP_CXX14_CONSTEXPR middle_type middle() const { return middle_type(arg2); } BOOST_MP_CXX14_CONSTEXPR right_type right() const { return right_type(arg3); } BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg1; } BOOST_MP_CXX14_CONSTEXPR const Arg2& middle_ref() const noexcept { return arg2; } BOOST_MP_CXX14_CONSTEXPR const Arg3& right_ref() const noexcept { return arg3; } template <class T #ifndef __SUNPRO_CC , typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0 #endif > explicit BOOST_MP_CXX14_CONSTEXPR operator T() const { return static_cast<T>(static_cast<result_type>(*this)); } BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const { result_type r(*this); return static_cast<bool>(r); } template <class T> BOOST_MP_CXX14_CONSTEXPR T convert_to() { result_type r(*this); return r.template convert_to<T>(); } static constexpr unsigned left_depth = left_type::depth + 1; static constexpr unsigned middle_depth = middle_type::depth + 1; static constexpr unsigned right_depth = right_type::depth + 1; static constexpr unsigned depth = left_depth > right_depth ? (left_depth > middle_depth ? left_depth : middle_depth) : (right_depth > middle_depth ? right_depth : middle_depth); private: typename expression_storage<Arg1>::type arg1; typename expression_storage<Arg2>::type arg2; typename expression_storage<Arg3>::type arg3; expression& operator=(const expression&); }; template <class tag, class Arg1, class Arg2, class Arg3, class Arg4> struct expression { using arity = std::integral_constant<int, 4> ; using left_type = typename arg_type<Arg1>::type ; using left_middle_type = typename arg_type<Arg2>::type ; using right_middle_type = typename arg_type<Arg3>::type ; using right_type = typename arg_type<Arg4>::type ; using left_result_type = typename left_type::result_type ; using left_middle_result_type = typename left_middle_type::result_type ; using right_middle_result_type = typename right_middle_type::result_type; using right_result_type = typename right_type::result_type ; using result_type = typename combine_expression< left_result_type, typename combine_expression< left_middle_result_type, typename combine_expression<right_middle_result_type, right_result_type>::type>::type>::type; using tag_type = tag ; BOOST_MP_CXX14_CONSTEXPR expression(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) : arg1(a1), arg2(a2), arg3(a3), arg4(a4) {} BOOST_MP_CXX14_CONSTEXPR expression(const expression& e) : arg1(e.arg1), arg2(e.arg2), arg3(e.arg3), arg4(e.arg4) {} // // If we have static_assert we can give a more useful error message // than if we simply have no operator defined at all: // template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not assign to a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator++(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not increment a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--() { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR expression& operator--(int) { // This should always fail: static_assert(sizeof(*this) == INT_MAX, "You can not decrement a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator+=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator+= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator-=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator-= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator*=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator*= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator/=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator/= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator%=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator%= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator|=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator|= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator&=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator&= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator^=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator^= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator<<=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator<<= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } template <class Other> BOOST_MP_CXX14_CONSTEXPR expression& operator>>=(const Other&) { // This should always fail: static_assert(sizeof(Other) == INT_MAX, "You can not use operator>>= on a Boost.Multiprecision expression template: did you inadvertantly store an expression template in a \"auto\" variable? Or pass an expression to a template function with deduced temnplate arguments?"); return *this; } BOOST_MP_CXX14_CONSTEXPR left_type left() const { return left_type(arg1); } BOOST_MP_CXX14_CONSTEXPR left_middle_type left_middle() const { return left_middle_type(arg2); } BOOST_MP_CXX14_CONSTEXPR right_middle_type right_middle() const { return right_middle_type(arg3); } BOOST_MP_CXX14_CONSTEXPR right_type right() const { return right_type(arg4); } BOOST_MP_CXX14_CONSTEXPR const Arg1& left_ref() const noexcept { return arg1; } BOOST_MP_CXX14_CONSTEXPR const Arg2& left_middle_ref() const noexcept { return arg2; } BOOST_MP_CXX14_CONSTEXPR const Arg3& right_middle_ref() const noexcept { return arg3; } BOOST_MP_CXX14_CONSTEXPR const Arg4& right_ref() const noexcept { return arg4; } template <class T #ifndef __SUNPRO_CC , typename std::enable_if<!is_number<T>::value && !std::is_convertible<result_type, T const&>::value && std::is_constructible<T, result_type>::value, int>::type = 0 #endif > explicit BOOST_MP_CXX14_CONSTEXPR operator T() const { return static_cast<T>(static_cast<result_type>(*this)); } BOOST_MP_FORCEINLINE explicit BOOST_MP_CXX14_CONSTEXPR operator bool() const { result_type r(*this); return static_cast<bool>(r); } template <class T> BOOST_MP_CXX14_CONSTEXPR T convert_to() { result_type r(*this); return r.template convert_to<T>(); } static constexpr unsigned left_depth = left_type::depth + 1; static constexpr unsigned left_middle_depth = left_middle_type::depth + 1; static constexpr unsigned right_middle_depth = right_middle_type::depth + 1; static constexpr unsigned right_depth = right_type::depth + 1; static constexpr unsigned left_max_depth = left_depth > left_middle_depth ? left_depth : left_middle_depth; static constexpr unsigned right_max_depth = right_depth > right_middle_depth ? right_depth : right_middle_depth; static constexpr unsigned depth = left_max_depth > right_max_depth ? left_max_depth : right_max_depth; private: typename expression_storage<Arg1>::type arg1; typename expression_storage<Arg2>::type arg2; typename expression_storage<Arg3>::type arg3; typename expression_storage<Arg4>::type arg4; expression& operator=(const expression&); }; template <class T> struct digits2 { static_assert(std::numeric_limits<T>::is_specialized, "numeric_limits must be specialized here"); static_assert((std::numeric_limits<T>::radix == 2) || (std::numeric_limits<T>::radix == 10), "Failed radix check"); // If we really have so many digits that this fails, then we're probably going to hit other problems anyway: static_assert(LONG_MAX / 1000 > (std::numeric_limits<T>::digits + 1), "Too many digits to cope with here"); static constexpr long m_value = std::numeric_limits<T>::radix == 10 ? (((std::numeric_limits<T>::digits + 1) * 1000L) / 301L) : std::numeric_limits<T>::digits; static inline constexpr long value() noexcept { return m_value; } }; #ifndef BOOST_MP_MIN_EXPONENT_DIGITS #ifdef _MSC_VER #define BOOST_MP_MIN_EXPONENT_DIGITS 2 #else #define BOOST_MP_MIN_EXPONENT_DIGITS 2 #endif #endif template <class S> void format_float_string(S& str, std::intmax_t my_exp, std::intmax_t digits, std::ios_base::fmtflags f, bool iszero) { using size_type = typename S::size_type; bool scientific = (f & std::ios_base::scientific) == std::ios_base::scientific; bool fixed = (f & std::ios_base::fixed) == std::ios_base::fixed; bool showpoint = (f & std::ios_base::showpoint) == std::ios_base::showpoint; bool showpos = (f & std::ios_base::showpos) == std::ios_base::showpos; bool neg = str.size() && (str[0] == '-'); if (neg) str.erase(0, 1); if (digits == 0 && !fixed) { digits = static_cast<std::intmax_t>((std::max)(str.size(), size_type(16))); } if (iszero || str.empty() || (str.find_first_not_of('0') == S::npos)) { // We will be printing zero, even though the value might not // actually be zero (it just may have been rounded to zero). str = "0"; if (scientific || fixed) { if (showpoint || digits > 0) { str.append(1, '.'); if (digits > 0) str.append(size_type(digits), '0'); } if (scientific) str.append("e+00"); } else { if (showpoint) { str.append(1, '.'); if (digits > 1) str.append(size_type(digits - 1), '0'); } } if (neg) str.insert(static_cast<std::string::size_type>(0), 1, '-'); else if (showpos) str.insert(static_cast<std::string::size_type>(0), 1, '+'); return; } if (!fixed && !scientific && !showpoint) { // // Suppress trailing zeros: // std::string::iterator pos = str.end(); while (pos != str.begin() && *--pos == '0') { } if (pos != str.end()) ++pos; str.erase(pos, str.end()); if (str.empty()) str = '0'; } else if (!fixed || (my_exp >= 0)) { // // Pad out the end with zero's if we need to: // std::intmax_t chars = static_cast<std::intmax_t>(str.size()); chars = digits - chars; if (scientific) ++chars; if (chars > 0) { str.append(static_cast<std::string::size_type>(chars), '0'); } } if (fixed || (!scientific && (my_exp >= -4) && (my_exp < digits))) { if (1 + my_exp > static_cast<std::intmax_t>(str.size())) { // Just pad out the end with zeros: str.append(static_cast<std::string::size_type>(1 + my_exp - static_cast<std::intmax_t>(str.size())), '0'); if (showpoint || (fixed && digits > 0)) str.append("."); } else if (my_exp + 1 < static_cast<std::intmax_t>(str.size())) { if (my_exp < 0) { str.insert(static_cast<std::string::size_type>(0), static_cast<std::string::size_type>(-1 - my_exp), '0'); str.insert(static_cast<std::string::size_type>(0), "0."); } else { // Insert the decimal point: str.insert(static_cast<std::string::size_type>(my_exp + 1), 1, '.'); } } else if (showpoint || (fixed && digits > 0)) // we have exactly the digits we require to left of the point str += "."; if (fixed) { // We may need to add trailing zeros: auto pos = str.find('.'); if (pos != str.npos) { // this test is probably redundant, but just to be safe and for clarity std::intmax_t l = static_cast<std::intmax_t>(pos + 1); l = static_cast<std::intmax_t>(digits - (static_cast<std::intmax_t>(str.size()) - l)); if (l > 0) str.append(size_type(l), '0'); } } } else { BOOST_MP_USING_ABS // Scientific format: if (showpoint || (str.size() > 1)) str.insert(static_cast<std::string::size_type>(1u), 1, '.'); str.append(static_cast<std::string::size_type>(1u), 'e'); S e; #ifndef BOOST_MP_STANDALONE e = boost::lexical_cast<S>(abs(my_exp)); #else BOOST_IF_CONSTEXPR(std::is_same<S, std::string>::value) { e = std::to_string(abs(my_exp)); } else { const std::string str_local_exp = std::to_string(abs(my_exp)); e = S(str_local_exp.cbegin(), str_local_exp.cend()); } #endif if (e.size() < BOOST_MP_MIN_EXPONENT_DIGITS) e.insert(static_cast<std::string::size_type>(0), BOOST_MP_MIN_EXPONENT_DIGITS - e.size(), '0'); if (my_exp < 0) e.insert(static_cast<std::string::size_type>(0), 1, '-'); else e.insert(static_cast<std::string::size_type>(0), 1, '+'); str.append(e); } if (neg) str.insert(static_cast<std::string::size_type>(0), 1, '-'); else if (showpos) str.insert(static_cast<std::string::size_type>(0), 1, '+'); } template <class V> BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V val, const std::integral_constant<bool, true>&, const std::integral_constant<bool, true>&) { if (val > (std::numeric_limits<std::size_t>::max)()) BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a value greater than std::numeric_limits<std::size_t>::max().")); if (val < 0) BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a negative value.")); } template <class V> BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V val, const std::integral_constant<bool, false>&, const std::integral_constant<bool, true>&) { if (val < 0) BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a negative value.")); } template <class V> BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V val, const std::integral_constant<bool, true>&, const std::integral_constant<bool, false>&) { if (val > (std::numeric_limits<std::size_t>::max)()) BOOST_MP_THROW_EXCEPTION(std::out_of_range("Can not shift by a value greater than std::numeric_limits<std::size_t>::max().")); } template <class V> BOOST_MP_CXX14_CONSTEXPR void check_shift_range(V, const std::integral_constant<bool, false>&, const std::integral_constant<bool, false>&) noexcept {} template <class T> BOOST_MP_CXX14_CONSTEXPR const T& evaluate_if_expression(const T& val) { return val; } template <class T> BOOST_MP_CXX14_CONSTEXPR T&& evaluate_if_expression(T&& val) { return static_cast<T&&>(val); } template <class tag, class Arg1, class Arg2, class Arg3, class Arg4> BOOST_MP_CXX14_CONSTEXPR typename expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type evaluate_if_expression(const expression<tag, Arg1, Arg2, Arg3, Arg4>& val) { return val; } template <class tag, class Arg1, class Arg2, class Arg3, class Arg4> BOOST_MP_CXX14_CONSTEXPR typename expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type evaluate_if_expression(expression<tag, Arg1, Arg2, Arg3, Arg4>&& val) { return val; } template <class T> struct convertible_to { operator T () const; }; } // namespace detail // // Traits class, lets us know what kind of number we have, defaults to a floating point type: // enum number_category_type { number_kind_unknown = -1, number_kind_integer = 0, number_kind_floating_point = 1, number_kind_rational = 2, number_kind_fixed_point = 3, number_kind_complex = 4 }; template <class Num, bool, bool> struct number_category_base : public std::integral_constant<int, number_kind_unknown> {}; template <class Num> struct number_category_base<Num, true, false> : public std::integral_constant<int, std::numeric_limits<Num>::is_integer ? number_kind_integer : (std::numeric_limits<Num>::max_exponent ? number_kind_floating_point : number_kind_unknown)> {}; template <class Num> struct number_category : public number_category_base<Num, std::is_class<Num>::value || boost::multiprecision::detail::is_arithmetic<Num>::value, std::is_abstract<Num>::value> {}; template <class Backend, expression_template_option ExpressionTemplates> struct number_category<number<Backend, ExpressionTemplates> > : public number_category<Backend> {}; template <class tag, class A1, class A2, class A3, class A4> struct number_category<detail::expression<tag, A1, A2, A3, A4> > : public number_category<typename detail::expression<tag, A1, A2, A3, A4>::result_type> {}; // // Specializations for types which do not always have numberic_limits specializations: // #ifdef BOOST_HAS_INT128 template <> struct number_category<boost::multiprecision::int128_type> : public std::integral_constant<int, number_kind_integer> {}; template <> struct number_category<boost::multiprecision::uint128_type> : public std::integral_constant<int, number_kind_integer> {}; #endif #ifdef BOOST_HAS_FLOAT128 template <> struct number_category<boost::multiprecision::float128_type> : public std::integral_constant<int, number_kind_floating_point> {}; #endif template <class T> struct component_type { using type = T; }; template <class tag, class A1, class A2, class A3, class A4> struct component_type<detail::expression<tag, A1, A2, A3, A4> > : public component_type<typename detail::expression<tag, A1, A2, A3, A4>::result_type> {}; template <class T> struct scalar_result_from_possible_complex { using type = typename std::conditional<number_category<T>::value == number_kind_complex, typename component_type<T>::type, T>::type; }; template <class T> struct complex_result_from_scalar; // individual backends must specialize this trait. template <class T> struct is_unsigned_number : public std::integral_constant<bool, false> {}; template <class Backend, expression_template_option ExpressionTemplates> struct is_unsigned_number<number<Backend, ExpressionTemplates> > : public is_unsigned_number<Backend> {}; template <class T> struct is_signed_number : public std::integral_constant<bool, !is_unsigned_number<T>::value> {}; template <class T> struct is_interval_number : public std::integral_constant<bool, false> {}; template <class Backend, expression_template_option ExpressionTemplates> struct is_interval_number<number<Backend, ExpressionTemplates> > : public is_interval_number<Backend> {}; template <class T, class U> struct is_equivalent_number_type : public std::is_same<T, U> {}; template <class Backend, expression_template_option ExpressionTemplates, class T2> struct is_equivalent_number_type<number<Backend, ExpressionTemplates>, T2> : public is_equivalent_number_type<Backend, T2> {}; template <class T1, class Backend, expression_template_option ExpressionTemplates> struct is_equivalent_number_type<T1, number<Backend, ExpressionTemplates> > : public is_equivalent_number_type<Backend, T1> {}; template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2> struct is_equivalent_number_type<number<Backend, ExpressionTemplates>, number<Backend2, ExpressionTemplates2> > : public is_equivalent_number_type<Backend, Backend2> {}; } } // namespace boost #ifdef BOOST_MP_MATH_AVAILABLE namespace boost { namespace math { namespace tools { template <class T> struct promote_arg; template <class tag, class A1, class A2, class A3, class A4> struct promote_arg<boost::multiprecision::detail::expression<tag, A1, A2, A3, A4> > { using type = typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type; }; template <class R, class B, boost::multiprecision::expression_template_option ET> inline R real_cast(const boost::multiprecision::number<B, ET>& val) { return val.template convert_to<R>(); } template <class R, class tag, class A1, class A2, class A3, class A4> inline R real_cast(const boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>& val) { using val_type = typename boost::multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type; return val_type(val).template convert_to<R>(); } template <class B, boost::multiprecision::expression_template_option ET> struct is_complex_type<boost::multiprecision::number<B, ET> > : public std::integral_constant<bool, boost::multiprecision::number_category<B>::value == boost::multiprecision::number_kind_complex> {}; } // namespace tools namespace constants { template <class T> struct is_explicitly_convertible_from_string; template <class B, boost::multiprecision::expression_template_option ET> struct is_explicitly_convertible_from_string<boost::multiprecision::number<B, ET> > { static constexpr bool value = true; }; } // namespace constants }} // namespace boost::math #endif #ifdef BOOST_MSVC #pragma warning(pop) #endif #endif // BOOST_MP_NUMBER_BASE_HPP