mqt-core 3.3.2__cp314-cp314t-macosx_11_0_x86_64.whl

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

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2021 Matt Borland. 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_DETAIL_HASH_HPP
+#define BOOST_MP_DETAIL_HASH_HPP
+
+#include <cstddef>
+#include <functional>
+#include <boost/multiprecision/detail/standalone_config.hpp>
+
+namespace boost { namespace multiprecision { namespace detail {
+
+template <typename T>
+inline std::size_t hash_value(const T& v)
+{
+    std::hash<T> hasher;
+    return hasher(v);
+}
+
+#if defined(BOOST_HAS_INT128)
+
+std::size_t hash_value(const uint128_type& val);
+
+inline std::size_t hash_value(const int128_type& val)
+{
+   return hash_value(static_cast<uint128_type>(val));
+}
+
+#endif
+
+inline void hash_combine(std::size_t&) {}
+
+template <typename T, typename... Args>
+inline void hash_combine(std::size_t& seed, const T& v, Args... args) 
+{
+    constexpr std::size_t adder = 0x9e3779b9;
+    seed = seed ^ (hash_value(v) + adder + (seed<<6) + (seed>>2));
+    hash_combine(seed, args...);
+}
+
+#if defined(BOOST_HAS_INT128)
+
+inline std::size_t hash_value(const uint128_type& val)
+{
+   std::size_t result = static_cast<std::size_t>(val);
+   hash_combine(result, static_cast<std::size_t>(val >> 64));
+   return result;
+}
+
+#endif
+
+}}} // Namespaces
+
+#endif // BOOST_MP_DETAIL_HASH_HPP

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

@@ -0,0 +1,474 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_MP_DETAIL_INTEGER_OPS_HPP
+#define BOOST_MP_DETAIL_INTEGER_OPS_HPP
+
+#include <boost/multiprecision/number.hpp>
+#include <boost/multiprecision/detail/no_exceptions_support.hpp>
+
+namespace boost { namespace multiprecision {
+
+namespace default_ops {
+
+template <class Backend>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_qr(const Backend& x, const Backend& y, Backend& q, Backend& r)
+{
+   eval_divide(q, x, y);
+   eval_modulus(r, x, y);
+}
+
+template <class Backend, class Integer>
+inline BOOST_MP_CXX14_CONSTEXPR Integer eval_integer_modulus(const Backend& x, Integer val)
+{
+   BOOST_MP_USING_ABS
+   using default_ops::eval_convert_to;
+   using default_ops::eval_modulus;
+   using int_type = typename boost::multiprecision::detail::canonical<Integer, Backend>::type;
+   Backend                                                                           t;
+   eval_modulus(t, x, static_cast<int_type>(val));
+   Integer result(0);
+   eval_convert_to(&result, t);
+   return abs(result);
+}
+
+template <class B>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_gcd(B& result, const B& a, const B& b)
+{
+   using default_ops::eval_get_sign;
+   using default_ops::eval_is_zero;
+   using default_ops::eval_lsb;
+
+   std::ptrdiff_t shift(0);
+
+   B u(a), v(b);
+
+   int s = eval_get_sign(u);
+
+   /* GCD(0,x) := x */
+   if (s < 0)
+   {
+      u.negate();
+   }
+   else if (s == 0)
+   {
+      result = v;
+      return;
+   }
+   s = eval_get_sign(v);
+   if (s < 0)
+   {
+      v.negate();
+   }
+   else if (s == 0)
+   {
+      result = u;
+      return;
+   }
+
+   /* Let shift := lg K, where K is the greatest power of 2
+   dividing both u and v. */
+
+   std::size_t us = eval_lsb(u);
+   std::size_t vs = eval_lsb(v);
+   shift       = static_cast<std::ptrdiff_t>((std::min)(us, vs));
+   eval_right_shift(u, us);
+   eval_right_shift(v, vs);
+
+   do
+   {
+      /* Now u and v are both odd, so diff(u, v) is even.
+      Let u = min(u, v), v = diff(u, v)/2. */
+      s = u.compare(v);
+      if (s > 0)
+         u.swap(v);
+      if (s == 0)
+         break;
+      eval_subtract(v, u);
+      vs = eval_lsb(v);
+      eval_right_shift(v, vs);
+   } while (true);
+
+   result = u;
+   eval_left_shift(result, shift);
+}
+
+template <class B>
+inline BOOST_MP_CXX14_CONSTEXPR void eval_lcm(B& result, const B& a, const B& b)
+{
+   using ui_type = typename std::tuple_element<0, typename B::unsigned_types>::type;
+   B                                                             t;
+   eval_gcd(t, a, b);
+
+   if (eval_is_zero(t))
+   {
+      result = static_cast<ui_type>(0);
+   }
+   else
+   {
+      eval_divide(result, a, t);
+      eval_multiply(result, b);
+   }
+   if (eval_get_sign(result) < 0)
+      result.negate();
+}
+
+} // namespace default_ops
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
+divide_qr(const number<Backend, ExpressionTemplates>& x, const number<Backend, ExpressionTemplates>& y,
+          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
+{
+   using default_ops::eval_qr;
+   eval_qr(x.backend(), y.backend(), q.backend(), r.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates, class tag, class A1, class A2, class A3, class A4>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
+divide_qr(const number<Backend, ExpressionTemplates>& x, const multiprecision::detail::expression<tag, A1, A2, A3, A4>& y,
+          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
+{
+   divide_qr(x, number<Backend, ExpressionTemplates>(y), q, r);
+}
+
+template <class tag, class A1, class A2, class A3, class A4, class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
+divide_qr(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, const number<Backend, ExpressionTemplates>& y,
+          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
+{
+   divide_qr(number<Backend, ExpressionTemplates>(x), y, q, r);
+}
+
+template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b, class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer>::type
+divide_qr(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, const multiprecision::detail::expression<tagb, A1b, A2b, A3b, A4b>& y,
+          number<Backend, ExpressionTemplates>& q, number<Backend, ExpressionTemplates>& r)
+{
+   divide_qr(number<Backend, ExpressionTemplates>(x), number<Backend, ExpressionTemplates>(y), q, r);
+}
+
+template <class Backend, expression_template_option ExpressionTemplates, class Integer>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && (number_category<Backend>::value == number_kind_integer), Integer>::type
+integer_modulus(const number<Backend, ExpressionTemplates>& x, Integer val)
+{
+   using default_ops::eval_integer_modulus;
+   return eval_integer_modulus(x.backend(), val);
+}
+
+template <class tag, class A1, class A2, class A3, class A4, class Integer>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<Integer>::value && (number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer), Integer>::type
+integer_modulus(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, Integer val)
+{
+   using result_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
+   return integer_modulus(result_type(x), val);
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, std::size_t>::type
+lsb(const number<Backend, ExpressionTemplates>& x)
+{
+   using default_ops::eval_lsb;
+   return eval_lsb(x.backend());
+}
+
+template <class tag, class A1, class A2, class A3, class A4>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, std::size_t>::type
+lsb(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x)
+{
+   using number_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
+   number_type                                                                           n(x);
+   using default_ops::eval_lsb;
+   return eval_lsb(n.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, std::size_t>::type
+msb(const number<Backend, ExpressionTemplates>& x)
+{
+   using default_ops::eval_msb;
+   return eval_msb(x.backend());
+}
+
+template <class tag, class A1, class A2, class A3, class A4>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, std::size_t>::type
+msb(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x)
+{
+   using number_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
+   number_type                                                                           n(x);
+   using default_ops::eval_msb;
+   return eval_msb(n.backend());
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, bool>::type
+bit_test(const number<Backend, ExpressionTemplates>& x, std::size_t index)
+{
+   using default_ops::eval_bit_test;
+   return eval_bit_test(x.backend(), index);
+}
+
+template <class tag, class A1, class A2, class A3, class A4>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type>::value == number_kind_integer, bool>::type
+bit_test(const multiprecision::detail::expression<tag, A1, A2, A3, A4>& x, std::size_t index)
+{
+   using number_type = typename multiprecision::detail::expression<tag, A1, A2, A3, A4>::result_type;
+   number_type                                                                           n(x);
+   using default_ops::eval_bit_test;
+   return eval_bit_test(n.backend(), index);
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
+bit_set(number<Backend, ExpressionTemplates>& x, std::size_t index)
+{
+   using default_ops::eval_bit_set;
+   eval_bit_set(x.backend(), index);
+   return x;
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
+bit_unset(number<Backend, ExpressionTemplates>& x, std::size_t index)
+{
+   using default_ops::eval_bit_unset;
+   eval_bit_unset(x.backend(), index);
+   return x;
+}
+
+template <class Backend, expression_template_option ExpressionTemplates>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<Backend>::value == number_kind_integer, number<Backend, ExpressionTemplates>&>::type
+bit_flip(number<Backend, ExpressionTemplates>& x, std::size_t index)
+{
+   using default_ops::eval_bit_flip;
+   eval_bit_flip(x.backend(), index);
+   return x;
+}
+
+namespace default_ops {
+
+//
+// Within powm, we need a type with twice as many digits as the argument type, define
+// a traits class to obtain that type:
+//
+template <class Backend>
+struct double_precision_type
+{
+   using type = Backend;
+};
+
+//
+// If the exponent is a signed integer type, then we need to
+// check the value is positive:
+//
+template <class Backend>
+inline BOOST_MP_CXX14_CONSTEXPR void check_sign_of_backend(const Backend& v, const std::integral_constant<bool, true>)
+{
+   if (eval_get_sign(v) < 0)
+   {
+      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
+   }
+}
+template <class Backend>
+inline BOOST_MP_CXX14_CONSTEXPR void check_sign_of_backend(const Backend&, const std::integral_constant<bool, false>) {}
+//
+// Calculate (a^p)%c:
+//
+template <class Backend>
+BOOST_MP_CXX14_CONSTEXPR void eval_powm(Backend& result, const Backend& a, const Backend& p, const Backend& c)
+{
+   using default_ops::eval_bit_test;
+   using default_ops::eval_get_sign;
+   using default_ops::eval_modulus;
+   using default_ops::eval_multiply;
+   using default_ops::eval_right_shift;
+
+   using double_type = typename double_precision_type<Backend>::type                                      ;
+   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;
+
+   check_sign_of_backend(p, std::integral_constant<bool, std::numeric_limits<number<Backend> >::is_signed>());
+
+   double_type x, y(a), b(p), t;
+   x = ui_type(1u);
+
+   while (eval_get_sign(b) > 0)
+   {
+      if (eval_bit_test(b, 0))
+      {
+         eval_multiply(t, x, y);
+         eval_modulus(x, t, c);
+      }
+      eval_multiply(t, y, y);
+      eval_modulus(y, t, c);
+      eval_right_shift(b, ui_type(1));
+   }
+   Backend x2(x);
+   eval_modulus(result, x2, c);
+}
+
+template <class Backend, class Integer>
+BOOST_MP_CXX14_CONSTEXPR void eval_powm(Backend& result, const Backend& a, const Backend& p, Integer c)
+{
+   using double_type = typename double_precision_type<Backend>::type                                      ;
+   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;
+   using i1_type = typename boost::multiprecision::detail::canonical<Integer, double_type>::type      ;
+   using i2_type = typename boost::multiprecision::detail::canonical<Integer, Backend>::type          ;
+
+   using default_ops::eval_bit_test;
+   using default_ops::eval_get_sign;
+   using default_ops::eval_modulus;
+   using default_ops::eval_multiply;
+   using default_ops::eval_right_shift;
+
+   check_sign_of_backend(p, std::integral_constant<bool, std::numeric_limits<number<Backend> >::is_signed>());
+
+   if (eval_get_sign(p) < 0)
+   {
+      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
+   }
+
+   double_type x, y(a), b(p), t;
+   x = ui_type(1u);
+
+   while (eval_get_sign(b) > 0)
+   {
+      if (eval_bit_test(b, 0))
+      {
+         eval_multiply(t, x, y);
+         eval_modulus(x, t, static_cast<i1_type>(c));
+      }
+      eval_multiply(t, y, y);
+      eval_modulus(y, t, static_cast<i1_type>(c));
+      eval_right_shift(b, ui_type(1));
+   }
+   Backend x2(x);
+   eval_modulus(result, x2, static_cast<i2_type>(c));
+}
+
+template <class Backend, class Integer>
+BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer>::value >::type eval_powm(Backend& result, const Backend& a, Integer b, const Backend& c)
+{
+   using double_type = typename double_precision_type<Backend>::type                                      ;
+   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;
+
+   using default_ops::eval_bit_test;
+   using default_ops::eval_get_sign;
+   using default_ops::eval_modulus;
+   using default_ops::eval_multiply;
+   using default_ops::eval_right_shift;
+
+   double_type x, y(a), t;
+   x = ui_type(1u);
+
+   while (b > 0)
+   {
+      if (b & 1)
+      {
+         eval_multiply(t, x, y);
+         eval_modulus(x, t, c);
+      }
+      eval_multiply(t, y, y);
+      eval_modulus(y, t, c);
+      b >>= 1;
+   }
+   Backend x2(x);
+   eval_modulus(result, x2, c);
+}
+
+template <class Backend, class Integer>
+BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<Integer>::value && boost::multiprecision::detail::is_integral<Integer>::value>::type eval_powm(Backend& result, const Backend& a, Integer b, const Backend& c)
+{
+   if (b < 0)
+   {
+      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
+   }
+   eval_powm(result, a, static_cast<typename boost::multiprecision::detail::make_unsigned<Integer>::type>(b), c);
+}
+
+template <class Backend, class Integer1, class Integer2>
+BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_unsigned<Integer1>::value >::type eval_powm(Backend& result, const Backend& a, Integer1 b, Integer2 c)
+{
+   using double_type = typename double_precision_type<Backend>::type                                      ;
+   using ui_type = typename boost::multiprecision::detail::canonical<unsigned char, double_type>::type;
+   using i1_type = typename boost::multiprecision::detail::canonical<Integer1, double_type>::type     ;
+   using i2_type = typename boost::multiprecision::detail::canonical<Integer2, Backend>::type         ;
+
+   using default_ops::eval_bit_test;
+   using default_ops::eval_get_sign;
+   using default_ops::eval_modulus;
+   using default_ops::eval_multiply;
+   using default_ops::eval_right_shift;
+
+   double_type x, y(a), t;
+   x = ui_type(1u);
+
+   while (b > 0)
+   {
+      if (b & 1)
+      {
+         eval_multiply(t, x, y);
+         eval_modulus(x, t, static_cast<i1_type>(c));
+      }
+      eval_multiply(t, y, y);
+      eval_modulus(y, t, static_cast<i1_type>(c));
+      b >>= 1;
+   }
+   Backend x2(x);
+   eval_modulus(result, x2, static_cast<i2_type>(c));
+}
+
+template <class Backend, class Integer1, class Integer2>
+BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_signed<Integer1>::value && boost::multiprecision::detail::is_integral<Integer1>::value>::type eval_powm(Backend& result, const Backend& a, Integer1 b, Integer2 c)
+{
+   if (b < 0)
+   {
+      BOOST_MP_THROW_EXCEPTION(std::runtime_error("powm requires a positive exponent."));
+   }
+   eval_powm(result, a, static_cast<typename boost::multiprecision::detail::make_unsigned<Integer1>::type>(b), c);
+}
+
+struct powm_func
+{
+   template <class T, class U, class V>
+   BOOST_MP_CXX14_CONSTEXPR void operator()(T& result, const T& b, const U& p, const V& m) const
+   {
+      eval_powm(result, b, p, m);
+   }
+   template <class R, class T, class U, class V>
+   BOOST_MP_CXX14_CONSTEXPR void operator()(R& result, const T& b, const U& p, const V& m) const
+   {
+      T temp;
+      eval_powm(temp, b, p, m);
+      result = std::move(temp);
+   }
+};
+
+} // namespace default_ops
+
+template <class T, class U, class V>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+        (number_category<T>::value == number_kind_integer) &&
+        (is_number<T>::value || is_number_expression<T>::value) &&
+        (is_number<U>::value || is_number_expression<U>::value || boost::multiprecision::detail::is_integral<U>::value) &&
+        (is_number<V>::value || is_number_expression<V>::value || boost::multiprecision::detail::is_integral<V>::value),
+    typename std::conditional<
+        is_no_et_number<T>::value,
+        T,
+        typename std::conditional<
+            is_no_et_number<U>::value,
+            U,
+            typename std::conditional<
+                is_no_et_number<V>::value,
+                V,
+                detail::expression<detail::function, default_ops::powm_func, T, U, V> >::type>::type>::type>::type
+powm(const T& b, const U& p, const V& mod)
+{
+   return detail::expression<detail::function, default_ops::powm_func, T, U, V>(
+       default_ops::powm_func(), b, p, mod);
+}
+
+}} // namespace boost::multiprecision
+
+#endif

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

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2019 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+//
+// We used to use lexical_cast internally for quick conversions from integers 
+// to strings, but that breaks if the global locale is something other than "C".
+// See https://github.com/boostorg/multiprecision/issues/167.
+//
+#ifndef BOOST_MP_DETAIL_ITOS_HPP
+#define BOOST_MP_DETAIL_ITOS_HPP
+
+namespace boost { namespace multiprecision { namespace detail {
+
+   template <class Integer>
+   std::string itos(Integer val)
+   {
+      if (!val)  return "0";
+      std::string result;
+      bool isneg = false;
+      if (val < 0)
+      {
+         val = -val;
+         isneg = true;
+      }
+      while (val)
+      {
+         result.insert(result.begin(), char('0' + (val % 10)));
+         val /= 10;
+      }
+      if (isneg)
+         result.insert(result.begin(), '-');
+      return result;
+   }
+
+
+}}} // namespace boost::multiprecision::detail
+
+#endif

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

@@ -0,0 +1,106 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2016 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_MIN_MAX_HPP
+#define BOOST_MP_MIN_MAX_HPP
+
+#include <boost/multiprecision/traits/is_backend.hpp>
+
+namespace boost { namespace multiprecision {
+
+//
+// Expression template overloads for (min) and (max):
+//
+// Introduced in response to https://svn.boost.org/trac/boost/ticket/11149
+// note that these can not legally be injected into namespace std, and that doing so
+// may break future enhancements to the standard.  None the less adding
+// namespace std{ using boost::multiprecision::(min); using boost::multiprecision::(max); }
+// to your code may get some generic code working that wouldn't work otherwise.
+//
+// The use of enable_if on the return type is to avoid poisoning std::min/max,
+// otherwise attempting to make an explicit call to min<long>(a, b) when these and std
+// versions are in scope, will cause the compiler to try to instantiate the signatures
+// for our versions as well as the std ones, which in turn instantiates number<long>
+// which fails to compile as "long" is not a valid backend type.
+//
+template <class Backend>
+inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on>&>::type(min)(const number<Backend, et_on>& a, const number<Backend, et_on>& b)
+{
+   return a < b ? a : b;
+}
+template <class Backend, class tag, class A1, class A2, class A3, class A4>
+inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(min)(const number<Backend, et_on>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
+{
+   number<Backend, et_on> t(b);
+   if (a < t)
+      return a;
+   return t;
+}
+template <class tag, class A1, class A2, class A3, class A4, class Backend>
+inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(min)(const detail::expression<tag, A1, A2, A3, A4>& a, const number<Backend, et_on>& b)
+{
+   number<Backend, et_on> t(a);
+   if (t < b)
+      return t;
+   return b;
+}
+template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
+inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(min)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
+{
+   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
+   if (t1 < t2)
+      return t1;
+   return t2;
+}
+template <class tag, class A1, class A2, class A3, class A4>
+inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(min)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
+{
+   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
+   if (t1 < t2)
+      return t1;
+   return t2;
+}
+
+template <class Backend>
+inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on>&>::type(max)(const number<Backend, et_on>& a, const number<Backend, et_on>& b)
+{
+   return a > b ? a : b;
+}
+template <class Backend, class tag, class A1, class A2, class A3, class A4>
+inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(max)(const number<Backend, et_on>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
+{
+   number<Backend, et_on> t(b);
+   if (a > t)
+      return a;
+   return t;
+}
+template <class tag, class A1, class A2, class A3, class A4, class Backend>
+inline typename std::enable_if<boost::multiprecision::detail::is_backend<Backend>::value, const number<Backend, et_on> >::type(max)(const detail::expression<tag, A1, A2, A3, A4>& a, const number<Backend, et_on>& b)
+{
+   number<Backend, et_on> t(a);
+   if (t > b)
+      return t;
+   return b;
+}
+template <class tag, class A1, class A2, class A3, class A4, class tagb, class A1b, class A2b, class A3b, class A4b>
+inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(max)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tagb, A1b, A2b, A3b, A4b>& b)
+{
+   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
+   if (t1 > t2)
+      return t1;
+   return t2;
+}
+template <class tag, class A1, class A2, class A3, class A4>
+inline typename detail::expression<tag, A1, A2, A3, A4>::result_type(max)(const detail::expression<tag, A1, A2, A3, A4>& a, const detail::expression<tag, A1, A2, A3, A4>& b)
+{
+   typename detail::expression<tag, A1, A2, A3, A4>::result_type t1(a), t2(b);
+   if (t1 > t2)
+      return t1;
+   return t2;
+}
+
+}} // namespace boost::multiprecision
+
+#endif