mqt-core 3.3.2__cp312-cp312-win_amd64.whl

mqt/core/include/mqt-core/boost/multiprecision/cpp_int/checked.hpp

@@ -0,0 +1,178 @@
+
+//  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_CPP_INT_CHECKED_HPP
+#define BOOST_MP_CPP_INT_CHECKED_HPP
+
+#include <climits>
+#include <limits>
+#include <type_traits>
+#include <stdexcept>
+#include <string>
+#include <boost/multiprecision/detail/standalone_config.hpp>
+#include <boost/multiprecision/detail/no_exceptions_support.hpp>
+
+namespace boost { namespace multiprecision { namespace backends { namespace detail {
+
+//
+// Simple routines for performing checked arithmetic with a builtin arithmetic type.
+// Note that this is not a complete header, it must be included as part of boost/multiprecision/cpp_int.hpp.
+//
+
+template <typename T>
+inline constexpr T type_max() noexcept
+{
+   return 
+   #ifdef BOOST_HAS_INT128
+   std::is_same<T, boost::multiprecision::int128_type>::value ? INT128_MAX :
+   std::is_same<T, boost::multiprecision::uint128_type>::value ? UINT128_MAX :
+   #endif
+   (std::numeric_limits<T>::max)();
+}
+
+template <typename T>
+inline constexpr T type_min() noexcept
+{
+   return 
+   #ifdef BOOST_HAS_INT128
+   std::is_same<T, boost::multiprecision::int128_type>::value ? INT128_MIN :
+   std::is_same<T, boost::multiprecision::uint128_type>::value ? T(0) :
+   #endif
+   (std::numeric_limits<T>::min)();
+}
+
+inline void raise_overflow(std::string op)
+{
+   BOOST_MP_THROW_EXCEPTION(std::overflow_error("overflow in " + op));
+}
+inline void raise_add_overflow()
+{
+   raise_overflow("addition");
+}
+inline void raise_subtract_overflow()
+{
+   BOOST_MP_THROW_EXCEPTION(std::range_error("Subtraction resulted in a negative value, but the type is unsigned"));
+}
+inline void raise_mul_overflow()
+{
+   raise_overflow("multiplication");
+}
+inline void raise_div_overflow()
+{
+   raise_overflow("division");
+}
+
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_add_imp(A a, A b, const std::integral_constant<bool, true>&)
+{
+   if (a > 0)
+   {
+      if ((b > 0) && ((type_max<A>() - b) < a))
+         raise_add_overflow();
+   }
+   else
+   {
+      if ((b < 0) && ((type_min<A>() - b) > a))
+         raise_add_overflow();
+   }
+   return a + b;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_add_imp(A a, A b, const std::integral_constant<bool, false>&)
+{
+   if ((type_max<A>() - b) < a)
+      raise_add_overflow();
+   return a + b;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_add(A a, A b, const std::integral_constant<int, checked>&)
+{
+   return checked_add_imp(a, b, std::integral_constant<bool, boost::multiprecision::detail::is_signed<A>::value && boost::multiprecision::detail::is_integral<A>::value > ());
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_add(A a, A b, const std::integral_constant<int, unchecked>&)
+{
+   return a + b;
+}
+
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract_imp(A a, A b, const std::integral_constant<bool, true>&)
+{
+   if (a > 0)
+   {
+      if ((b < 0) && ((type_max<A>() + b) < a))
+         raise_subtract_overflow();
+   }
+   else
+   {
+      if ((b > 0) && ((type_min<A>() + b) > a))
+         raise_subtract_overflow();
+   }
+   return a - b;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract_imp(A a, A b, const std::integral_constant<bool, false>&)
+{
+   if (a < b)
+      raise_subtract_overflow();
+   return a - b;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract(A a, A b, const std::integral_constant<int, checked>&)
+{
+   return checked_subtract_imp(a, b, std::integral_constant<bool, boost::multiprecision::detail::is_signed<A>::value && boost::multiprecision::detail::is_integral<A>::value>());
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_subtract(A a, A b, const std::integral_constant<int, unchecked>&)
+{
+   return a - b;
+}
+
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_multiply(A a, A b, const std::integral_constant<int, checked>&)
+{
+   BOOST_MP_USING_ABS
+   if (a && (type_max<A>() / abs(a) < abs(b)))
+      raise_mul_overflow();
+   return a * b;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_multiply(A a, A b, const std::integral_constant<int, unchecked>&)
+{
+   return a * b;
+}
+
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_divide(A a, A b, const std::integral_constant<int, checked>&)
+{
+   if (b == 0)
+      raise_div_overflow();
+   return a / b;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_divide(A a, A b, const std::integral_constant<int, unchecked>&)
+{
+   return a / b;
+}
+
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_left_shift(A a, unsigned long long shift, const std::integral_constant<int, checked>&)
+{
+   if (a && shift)
+   {
+      if ((shift > sizeof(A) * CHAR_BIT) || (a >> (sizeof(A) * CHAR_BIT - shift)))
+         BOOST_MP_THROW_EXCEPTION(std::overflow_error("Shift out of range"));
+   }
+   return a << shift;
+}
+template <class A>
+inline BOOST_MP_CXX14_CONSTEXPR A checked_left_shift(A a, unsigned long long shift, const std::integral_constant<int, unchecked>&)
+{
+   return (shift >= sizeof(A) * CHAR_BIT) ? 0 : a << shift;
+}
+
+}}}} // namespace boost::multiprecision::backends::detail
+
+#endif

mqt/core/include/mqt-core/boost/multiprecision/cpp_int/comparison.hpp

@@ -0,0 +1,374 @@
+///////////////////////////////////////////////////////////////
+//  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
+//
+// Comparison operators for cpp_int_backend:
+//
+#ifndef BOOST_MP_CPP_INT_COMPARISON_HPP
+#define BOOST_MP_CPP_INT_COMPARISON_HPP
+
+#include <boost/multiprecision/detail/constexpr.hpp>
+
+namespace boost { namespace multiprecision { namespace backends {
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4018 4389 4996)
+#endif
+
+//
+// Start with non-trivial cpp_int's:
+//
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& a, const cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& b) noexcept
+{
+   return (a.sign() == b.sign()) && (a.size() == b.size()) && std_constexpr::equal(a.limbs(), a.limbs() + a.size(), b.limbs());
+}
+template <std::size_t MinBits1, std::size_t MaxBits1, cpp_integer_type SignType1, cpp_int_check_type Checked1, class Allocator1, std::size_t MinBits2, std::size_t MaxBits2, cpp_integer_type SignType2, cpp_int_check_type Checked2, class Allocator2>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1> >::value && !is_trivial_cpp_int<cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits1, MaxBits1, SignType1, Checked1, Allocator1>& a, const cpp_int_backend<MinBits2, MaxBits2, SignType2, Checked2, Allocator2>& b) noexcept
+{
+   return (a.sign() == b.sign()) && (a.size() == b.size()) && std_constexpr::equal(a.limbs(), a.limbs() + a.size(), b.limbs());
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, limb_type b) noexcept
+{
+   return (a.sign() == false) && (a.size() == 1) && (*a.limbs() == b);
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
+{
+   return (a.sign() == (b < 0)) && (a.size() == 1) && (*a.limbs() == boost::multiprecision::detail::unsigned_abs(b));
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, limb_type b) noexcept
+{
+   return (a.size() == 1) && (*a.limbs() == b);
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
+{
+   return (b < 0) ? eval_eq(a, cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>(b)) : eval_eq(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, limb_type b) noexcept
+{
+   if (a.sign())
+      return true;
+   if (a.size() > 1)
+      return false;
+   return *a.limbs() < b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
+{
+   if ((b == 0) || (a.sign() != (b < 0)))
+      return a.sign();
+   if (a.sign())
+   {
+      if (a.size() > 1)
+         return true;
+      return *a.limbs() > boost::multiprecision::detail::unsigned_abs(b);
+   }
+   else
+   {
+      if (a.size() > 1)
+         return false;
+      return *a.limbs() < boost::multiprecision::detail::unsigned_abs(b);
+   }
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, limb_type b) noexcept
+{
+   if (a.size() > 1)
+      return false;
+   return *a.limbs() < b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
+{
+   return (b < 0) ? a.compare(b) < 0 : eval_lt(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, limb_type b) noexcept
+{
+   if (a.sign())
+      return false;
+   if (a.size() > 1)
+      return true;
+   return *a.limbs() > b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+inline BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
+{
+   if (b == 0)
+      return !a.sign() && ((a.size() > 1) || *a.limbs());
+   if (a.sign() != (b < 0))
+      return !a.sign();
+   if (a.sign())
+   {
+      if (a.size() > 1)
+         return false;
+      return *a.limbs() < boost::multiprecision::detail::unsigned_abs(b);
+   }
+   else
+   {
+      if (a.size() > 1)
+         return true;
+      return *a.limbs() > boost::multiprecision::detail::unsigned_abs(b);
+   }
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, limb_type b) noexcept
+{
+   if (a.size() > 1)
+      return true;
+   return *a.limbs() > b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class Allocator>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    !is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, Allocator>& a, signed_limb_type b) noexcept
+{
+   return (b < 0) ? a.compare(b) > 0 : eval_gt(a, static_cast<limb_type>(b)); // Use bit pattern of b for comparison.
+}
+//
+// And again for trivial cpp_ints:
+//
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::value
+eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& b) noexcept
+{
+   return (a.sign() == b.sign()) && (*a.limbs() == *b.limbs());
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::value
+eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
+{
+   return *a.limbs() == *b.limbs();
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, U b) noexcept
+{
+   return !a.sign() && (*a.limbs() == b);
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, S b) noexcept
+{
+   return (a.sign() == (b < 0)) && (*a.limbs() == boost::multiprecision::detail::unsigned_abs(b));
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, U b) noexcept
+{
+   return *a.limbs() == b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_eq(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, S b) noexcept
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
+   if (b < 0)
+   {
+      cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> t(b);
+      return *a.limbs() == *t.limbs();
+   }
+   else
+   {
+      return *a.limbs() == static_cast<ui_type>(b);
+   }
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
+{
+   if (a.sign() != b.sign())
+      return a.sign();
+   return a.sign() ? *a.limbs() > *b.limbs() : *a.limbs() < *b.limbs();
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
+{
+   return *a.limbs() < *b.limbs();
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, U b) noexcept
+{
+   if (a.sign())
+      return true;
+   return *a.limbs() < b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, S b) noexcept
+{
+   if (a.sign() != (b < 0))
+      return a.sign();
+   return a.sign() ? (*a.limbs() > boost::multiprecision::detail::unsigned_abs(b)) : (*a.limbs() < boost::multiprecision::detail::unsigned_abs(b));
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, U b) noexcept
+{
+   return *a.limbs() < b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_lt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, S b) noexcept
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
+   if (b < 0)
+   {
+      cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> t(b);
+      return *a.limbs() < *t.limbs();
+   }
+   else
+   {
+      return *a.limbs() < static_cast<ui_type>(b);
+   }
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& b) noexcept
+{
+   if (a.sign() != b.sign())
+      return !a.sign();
+   return a.sign() ? *a.limbs() < *b.limbs() : *a.limbs() > *b.limbs();
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& b) noexcept
+{
+   return *a.limbs() > *b.limbs();
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, U b) noexcept
+{
+   if (a.sign())
+      return false;
+   return *a.limbs() > b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, signed_magnitude, Checked, void>& a, S b) noexcept
+{
+   if (a.sign() != (b < 0))
+      return !a.sign();
+   return a.sign() ? (*a.limbs() < boost::multiprecision::detail::unsigned_abs(b)) : (*a.limbs() > boost::multiprecision::detail::unsigned_abs(b));
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class U>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_unsigned<U>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, U b) noexcept
+{
+   return *a.limbs() > b;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_int_check_type Checked, class S>
+BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<
+    boost::multiprecision::detail::is_signed<S>::value && boost::multiprecision::detail::is_integral<S>::value && is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> >::value,
+    bool>::type
+eval_gt(const cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void>& a, S b) noexcept
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<S>::type;
+   if (b < 0)
+   {
+      cpp_int_backend<MinBits, MaxBits, unsigned_magnitude, Checked, void> t(b);
+      return *a.limbs() > *t.limbs();
+   }
+   else
+   {
+      return *a.limbs() > static_cast<ui_type>(b);
+   }
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+}}} // namespace boost::multiprecision::backends
+
+#endif