mqt-core 3.3.2__cp314-cp314t-macosx_11_0_x86_64.whl

mqt/core/include/mqt-core/boost/multiprecision/detail/number_base.hpp

@@ -0,0 +1,1656 @@
+///////////////////////////////////////////////////////////////////////////////
+//  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