mqt-core 3.3.2__cp313-cp313t-win_amd64.whl

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

@@ -0,0 +1,313 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2018 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_DETAIL_PRECISION_HPP
+#define BOOST_MP_DETAIL_PRECISION_HPP
+
+#include <boost/multiprecision/traits/is_variable_precision.hpp>
+#include <boost/multiprecision/detail/number_base.hpp>
+#include <boost/multiprecision/detail/digits.hpp>
+#include <boost/multiprecision/detail/assert.hpp>
+
+namespace boost { namespace multiprecision { namespace detail {
+
+template <class B, boost::multiprecision::expression_template_option ET>
+inline constexpr unsigned current_precision_of_last_chance_imp(const boost::multiprecision::number<B, ET>&, const std::integral_constant<int, 0>&)
+{
+   return std::numeric_limits<boost::multiprecision::number<B, ET> >::digits10;
+}
+template <class B, boost::multiprecision::expression_template_option ET>
+inline BOOST_MP_CXX14_CONSTEXPR unsigned current_precision_of_last_chance_imp(const boost::multiprecision::number<B, ET>& val, const std::integral_constant<int, 1>&)
+{
+   //
+   // We have an arbitrary precision integer, take it's "precision" as the
+   // location of the most-significant-bit less the location of the
+   // least-significant-bit, ie the number of bits required to represent the
+   // the value assuming we will have an exponent to shift things by:
+   //
+   return static_cast<unsigned>(val.is_zero() ? 1 : 1 + digits2_2_10(msb(abs(val)) - lsb(abs(val)) + 1));
+}
+template <class B, boost::multiprecision::expression_template_option ET>
+inline BOOST_MP_CXX14_CONSTEXPR unsigned current_precision_of_last_chance_imp(const boost::multiprecision::number<B, ET>& val, const std::integral_constant<int, 2>&)
+{
+   //
+   // We have an arbitrary precision rational, take it's "precision" as the
+   // the larger of the "precision" of numerator and denominator:
+   //
+   return (std::max)(current_precision_of_last_chance_imp(numerator(val), std::integral_constant<int, 1>()), current_precision_of_last_chance_imp(denominator(val), std::integral_constant<int, 1>()));
+}
+
+template <class B, boost::multiprecision::expression_template_option ET>
+inline BOOST_MP_CXX14_CONSTEXPR unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& n, const std::integral_constant<bool, true>&)
+{
+   return n.precision();
+}
+template <class B, boost::multiprecision::expression_template_option ET>
+inline constexpr unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& val, const std::integral_constant<bool, false>&)
+{
+   using tag = std::integral_constant<int,
+                                      std::numeric_limits<boost::multiprecision::number<B, ET> >::is_specialized &&
+                                              std::numeric_limits<boost::multiprecision::number<B, ET> >::is_integer &&
+                                              std::numeric_limits<boost::multiprecision::number<B, ET> >::is_exact &&
+                                              !std::numeric_limits<boost::multiprecision::number<B, ET> >::is_modulo
+                                          ? 1
+                                      : boost::multiprecision::number_category<boost::multiprecision::number<B, ET> >::value == boost::multiprecision::number_kind_rational ? 2
+                                                                                                                                                                            : 0>;
+   return current_precision_of_last_chance_imp(val, tag());
+}
+
+template <class R, class Terminal>
+inline constexpr unsigned current_precision_of_terminal(const Terminal&)
+{
+   return (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) 
+      ? (std::numeric_limits<Terminal>::min_exponent ? std::numeric_limits<Terminal>::digits10 : 1 + std::numeric_limits<Terminal>::digits10) : 0;
+}
+template <class R, class Terminal>
+inline constexpr unsigned current_precision_of(const Terminal& r)
+{
+   return current_precision_of_terminal<R>(R::canonical_value(r));
+}
+template <class R>
+inline constexpr unsigned current_precision_of(const float&)
+{
+   using list = typename R::backend_type::float_types;
+   using first_float = typename std::tuple_element<0, list>::type;
+
+   return (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) ? std::numeric_limits<first_float>::digits10 : 0;
+}
+
+template <class R, class Terminal, std::size_t N>
+inline constexpr unsigned current_precision_of(const Terminal (&)[N])
+{ // For string literals:
+   return 0;
+}
+
+template <class R, class B, boost::multiprecision::expression_template_option ET>
+inline constexpr unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& n, const std::true_type&)
+{
+   return std::is_same<R, boost::multiprecision::number<B, ET> >::value 
+      || (std::is_same<typename R::value_type, boost::multiprecision::number<B, ET> >::value && (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_component_precision))
+      || (R::thread_default_variable_precision_options() >= variable_precision_options::preserve_all_precision) 
+      ? current_precision_of_imp(n, boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<B, ET> >()) : 0;
+}
+template <class R, class B, boost::multiprecision::expression_template_option ET>
+inline constexpr unsigned current_precision_of_imp(const boost::multiprecision::number<B, ET>& n, const std::false_type&)
+{
+   return std::is_same<R, boost::multiprecision::number<B, ET> >::value 
+      || std::is_same<typename R::value_type, boost::multiprecision::number<B, ET> >::value
+      ? current_precision_of_imp(n, boost::multiprecision::detail::is_variable_precision<boost::multiprecision::number<B, ET> >()) : 0;
+}
+
+template <class R, class B, boost::multiprecision::expression_template_option ET>
+inline constexpr unsigned current_precision_of(const boost::multiprecision::number<B, ET>& n)
+{
+   return current_precision_of_imp<R>(n, boost::multiprecision::detail::is_variable_precision<R>());
+}
+
+template <class R, class tag, class Arg1>
+inline constexpr unsigned current_precision_of(const expression<tag, Arg1, void, void, void>& expr)
+{
+   return current_precision_of<R>(expr.left_ref());
+}
+
+template <class R, class Arg1>
+inline constexpr unsigned current_precision_of(const expression<terminal, Arg1, void, void, void>& expr)
+{
+   return current_precision_of<R>(expr.value());
+}
+
+template <class R, class tag, class Arg1, class Arg2>
+inline constexpr unsigned current_precision_of(const expression<tag, Arg1, Arg2, void, void>& expr)
+{
+   return (std::max)(current_precision_of<R>(expr.left_ref()), current_precision_of<R>(expr.right_ref()));
+}
+
+template <class R, class tag, class Arg1, class Arg2, class Arg3>
+inline constexpr unsigned current_precision_of(const expression<tag, Arg1, Arg2, Arg3, void>& expr)
+{
+   return (std::max)((std::max)(current_precision_of<R>(expr.left_ref()), current_precision_of<R>(expr.right_ref())), current_precision_of<R>(expr.middle_ref()));
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4130)
+#endif
+
+template <class R, bool = boost::multiprecision::detail::is_variable_precision<R>::value>
+struct scoped_default_precision
+{
+   template <class T>
+   constexpr scoped_default_precision(const T&) {}
+   template <class T, class U>
+   constexpr scoped_default_precision(const T&, const U&) {}
+   template <class T, class U, class V>
+   constexpr scoped_default_precision(const T&, const U&, const V&) {}
+
+   //
+   // This function is never called: in C++17 it won't be compiled either:
+   //
+   unsigned precision() const
+   {
+      BOOST_MP_ASSERT("This function should never be called!!" == nullptr);
+      return 0;
+   }
+};
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <class R>
+struct scoped_default_precision<R, true>
+{
+   template <class T>
+   BOOST_MP_CXX14_CONSTEXPR scoped_default_precision(const T& a)
+   {
+      init(has_uniform_precision() ? R::thread_default_precision() : (std::max)(R::thread_default_precision(), current_precision_of<R>(a)));
+   }
+   template <class T, class U>
+   BOOST_MP_CXX14_CONSTEXPR scoped_default_precision(const T& a, const U& b)
+   {
+      init(has_uniform_precision() ? R::thread_default_precision() : (std::max)(R::thread_default_precision(), (std::max)(current_precision_of<R>(a), current_precision_of<R>(b))));
+   }
+   template <class T, class U, class V>
+   BOOST_MP_CXX14_CONSTEXPR scoped_default_precision(const T& a, const U& b, const V& c)
+   {
+      init(has_uniform_precision() ? R::thread_default_precision() : (std::max)((std::max)(current_precision_of<R>(a), current_precision_of<R>(b)), (std::max)(R::thread_default_precision(), current_precision_of<R>(c))));
+   }
+   ~scoped_default_precision()
+   {
+      if(m_new_prec != m_old_prec)
+         R::thread_default_precision(m_old_prec);
+   }
+   BOOST_MP_CXX14_CONSTEXPR unsigned precision() const
+   {
+      return m_new_prec;
+   }
+
+   static constexpr bool has_uniform_precision()
+   {
+      return R::thread_default_variable_precision_options() <= boost::multiprecision::variable_precision_options::assume_uniform_precision;
+   }
+
+ private:
+   BOOST_MP_CXX14_CONSTEXPR void init(unsigned p)
+   {
+      m_old_prec = R::thread_default_precision();
+      if (p && (p != m_old_prec))
+      {
+         R::thread_default_precision(p);
+         m_new_prec = p;
+      }
+      else
+         m_new_prec = m_old_prec;
+   }
+   unsigned m_old_prec, m_new_prec;
+};
+
+template <class T>
+inline BOOST_MP_CXX14_CONSTEXPR void maybe_promote_precision(T*, const std::integral_constant<bool, false>&) {}
+
+template <class T>
+inline BOOST_MP_CXX14_CONSTEXPR void maybe_promote_precision(T* obj, const std::integral_constant<bool, true>&)
+{
+   if (obj->precision() != T::thread_default_precision())
+   {
+      obj->precision(T::thread_default_precision());
+   }
+}
+
+template <class T>
+inline BOOST_MP_CXX14_CONSTEXPR void maybe_promote_precision(T* obj)
+{
+   maybe_promote_precision(obj, std::integral_constant<bool, boost::multiprecision::detail::is_variable_precision<T>::value>());
+}
+
+#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
+#define BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(T) \
+   if                                               \
+   constexpr(boost::multiprecision::detail::is_variable_precision<T>::value)
+#else
+#define BOOST_MP_CONSTEXPR_IF_VARIABLE_PRECISION(T) if (boost::multiprecision::detail::is_variable_precision<T>::value)
+#endif
+
+template <class T, bool = boost::multiprecision::detail::is_variable_precision<T>::value>
+struct scoped_target_precision
+{
+   variable_precision_options opts;
+   scoped_target_precision() : opts(T::thread_default_variable_precision_options())
+   {
+      T::thread_default_variable_precision_options(variable_precision_options::preserve_target_precision);
+   }
+   ~scoped_target_precision()
+   {
+      T::thread_default_variable_precision_options(opts);
+   }
+};
+template <class T>
+struct scoped_target_precision<T, false> {};
+
+template <class T, bool = boost::multiprecision::detail::is_variable_precision<T>::value>
+struct scoped_source_precision
+{
+   variable_precision_options opts;
+   scoped_source_precision() : opts(T::thread_default_variable_precision_options())
+   {
+      T::thread_default_variable_precision_options(variable_precision_options::preserve_source_precision);
+   }
+   ~scoped_source_precision()
+   {
+      T::thread_default_variable_precision_options(opts);
+   }
+};
+template <class T>
+struct scoped_source_precision<T, false> {};
+
+template <class T, bool = boost::multiprecision::detail::is_variable_precision<T>::value>
+struct scoped_precision_options
+{
+   unsigned saved_digits;
+   boost::multiprecision::variable_precision_options saved_options;
+
+   scoped_precision_options(unsigned digits) 
+      : saved_digits(T::thread_default_precision()), saved_options(T::thread_default_variable_precision_options())
+   {
+      T::thread_default_precision(digits);
+   }
+   scoped_precision_options(unsigned digits, variable_precision_options opts)
+      : saved_digits(T::thread_default_precision()), saved_options(T::thread_default_variable_precision_options())
+   {
+      T::thread_default_precision(digits);
+      T::thread_default_variable_precision_options(opts);
+   }
+   template <class U>
+   scoped_precision_options(const U& u)
+      : saved_digits(T::thread_default_precision()), saved_options(T::thread_default_variable_precision_options())
+   {
+      T::thread_default_precision(u.precision());
+      T::thread_default_variable_precision_options(U::thread_default_variable_precision_options());
+   }
+   ~scoped_precision_options()
+   {
+      T::thread_default_variable_precision_options(saved_options);
+      T::thread_default_precision(saved_digits);
+   }
+};
+
+template <class T>
+struct scoped_precision_options<T, false>
+{
+   scoped_precision_options(unsigned) {}
+   scoped_precision_options(unsigned, variable_precision_options) {}
+   template <class U>
+   scoped_precision_options(const U&) {}
+   ~scoped_precision_options() {}
+};
+
+}
+}
+} // namespace boost::multiprecision::detail
+
+#endif // BOOST_MP_DETAIL_PRECISION_HPP

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

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2012 John Maddock.
+//  Copyright Christopher Kormanyos 2013. 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_REBIND_HPP
+#define BOOST_MP_DETAIL_REBIND_HPP
+
+namespace boost { namespace multiprecision { namespace backends { namespace detail {
+template <class value_type, class my_allocator>
+struct rebind
+{
+   using type = typename std::allocator_traits<my_allocator>::template rebind_alloc<value_type>;
+};
+}}}} // namespace boost::multiprecision::backends::detail
+
+#endif // BOOST_MP_DETAIL_REBIND_HPP

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

@@ -0,0 +1,148 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2010 - 2021 Douglas Gregor
+//  Copyright 2021 Matt Borland.
+//  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
+//
+//  Used to support configuration options depending on standalone context
+//  by providing either required support or disabling functionality  
+
+#ifndef BOOST_MP_STANDALONE_CONFIG_HPP
+#define BOOST_MP_STANDALONE_CONFIG_HPP
+
+#include <climits>
+
+// Boost.Config is dependency free so it is considered a requirement to use Boost.Multiprecision in standalone mode
+#ifdef __has_include
+#  if __has_include(<boost/config.hpp>)
+#    include <boost/config.hpp>
+#    include <boost/config/workaround.hpp>
+#  else
+#    error "Boost.Config is considered a requirement to use Boost.Multiprecision in standalone mode. A package is provided at https://github.com/boostorg/multiprecision/releases"
+#  endif
+#else
+// Provides the less helpful fatal error: 'boost/config.hpp' file not found if not available
+#  include <boost/config.hpp>
+#  include <boost/config/workaround.hpp>
+#endif
+
+// Minimum language standard transition
+ #ifdef _MSVC_LANG
+ #  if _MSVC_LANG < 201402L
+ #    pragma warning("The minimum language standard to use Boost.Math will be C++14 starting in July 2023 (Boost 1.82 release)");
+ #  endif
+ #else
+ #  if __cplusplus < 201402L
+ #    warning "The minimum language standard to use Boost.Math will be C++14 starting in July 2023 (Boost 1.82 release)"
+ #  endif
+ #endif
+
+// If any of the most frequently used boost headers are missing assume that standalone mode is supposed to be used
+#ifdef __has_include
+#if !__has_include(<boost/assert.hpp>) || !__has_include(<boost/lexical_cast.hpp>) || \
+    !__has_include(<boost/throw_exception.hpp>) || !__has_include(<boost/predef/other/endian.h>)
+#   ifndef BOOST_MP_STANDALONE
+#       define BOOST_MP_STANDALONE
+#   endif
+#endif
+#endif
+
+#ifndef BOOST_MP_STANDALONE
+
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+
+// Required typedefs for interoperability with standalone mode
+#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
+namespace boost { namespace multiprecision {
+   using int128_type = boost::int128_type;
+   using uint128_type = boost::uint128_type;
+}}
+#endif
+#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
+namespace boost { namespace multiprecision {
+   using float128_type = boost::float128_type;
+}}
+#endif
+
+// Boost.Math available by default
+#define BOOST_MP_MATH_AVAILABLE
+
+#else // Standalone mode
+
+#ifdef BOOST_MATH_STANDALONE
+#  define BOOST_MP_MATH_AVAILABLE
+#endif
+
+#ifndef BOOST_MP_MATH_AVAILABLE
+#  define BOOST_MATH_INSTRUMENT_CODE(x)
+#endif
+
+// Prevent Macro sub
+#ifndef BOOST_PREVENT_MACRO_SUBSTITUTION
+#  define BOOST_PREVENT_MACRO_SUBSTITUTION
+#endif
+
+#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
+namespace boost { namespace multiprecision {
+#  ifdef __GNUC__
+   __extension__ typedef __int128 int128_type;
+   __extension__ typedef unsigned __int128 uint128_type;
+#  else
+   typedef __int128 int128_type;
+   typedef unsigned __int128 uint128_type;
+#  endif
+}}
+
+#endif
+// same again for __float128:
+#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
+namespace boost { namespace multiprecision {
+#  ifdef __GNUC__
+   __extension__ typedef __float128 float128_type;
+#  else
+   typedef __float128 float128_type;
+#  endif
+}}
+
+#endif
+
+#endif // BOOST_MP_STANDALONE
+
+// Workarounds for numeric limits on old compilers
+#ifdef BOOST_HAS_INT128
+#  ifndef INT128_MAX
+#    define INT128_MAX static_cast<boost::multiprecision::int128_type>((static_cast<boost::multiprecision::uint128_type>(1) << ((__SIZEOF_INT128__ * __CHAR_BIT__) - 1)) - 1)
+#  endif
+#  ifndef INT128_MIN
+#    define INT128_MIN (-INT128_MAX - 1)
+#  endif
+#  ifndef UINT128_MAX
+#    define UINT128_MAX ((2 * static_cast<boost::multiprecision::uint128_type>(INT128_MAX)) + 1)
+#  endif
+#endif
+
+#define BOOST_MP_CXX14_CONSTEXPR BOOST_CXX14_CONSTEXPR
+//
+// Early compiler versions trip over the constexpr code:
+//
+#if defined(__clang__) && (__clang_major__ < 5)
+#undef BOOST_MP_CXX14_CONSTEXPR
+#define BOOST_MP_CXX14_CONSTEXPR
+#endif
+#if defined(__apple_build_version__) && (__clang_major__ < 9)
+#undef BOOST_MP_CXX14_CONSTEXPR
+#define BOOST_MP_CXX14_CONSTEXPR
+#endif
+#if defined(BOOST_GCC) && (__GNUC__ < 6)
+#undef BOOST_MP_CXX14_CONSTEXPR
+#define BOOST_MP_CXX14_CONSTEXPR
+#endif
+#if defined(BOOST_INTEL)
+#undef BOOST_MP_CXX14_CONSTEXPR
+#define BOOST_MP_CXX14_CONSTEXPR
+#define BOOST_MP_NO_CONSTEXPR_DETECTION
+#endif
+
+
+#endif // BOOST_MP_STANDALONE_CONFIG_HPP

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

@@ -0,0 +1,42 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2021 John Maddock.
+//  Copyright Christopher Kormanyos 2021. 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_STATIC_ARRAY_HPP
+#define BOOST_MP_DETAIL_STATIC_ARRAY_HPP
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+
+namespace boost { namespace multiprecision { namespace backends { namespace detail {
+template <class ValueType, const std::uint32_t ElemNumber>
+struct static_array : public std::array<ValueType, std::size_t(ElemNumber)>
+{
+private:
+   using base_class_type = std::array<ValueType, std::size_t(ElemNumber)>;
+
+public:
+   static_array() noexcept
+   {
+      base_class_type::fill(typename base_class_type::value_type(0u));
+   }
+
+   static_array(std::initializer_list<std::uint32_t> lst) noexcept
+   {
+      std::copy(lst.begin(),
+                lst.begin() + (std::min)(std::size_t(lst.size()), std::size_t(ElemNumber)),
+                base_class_type::begin());
+
+      std::fill(base_class_type::begin() + (std::min)(std::size_t(lst.size()), std::size_t(ElemNumber)),
+                base_class_type::end(),
+                typename base_class_type::value_type(0u));
+   }
+};
+}}}} // namespace boost::multiprecision::backends::detail
+
+#endif // BOOST_MP_DETAIL_STATIC_ARRAY_HPP

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

@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2023 John Maddock.
+//  Copyright Christopher Kormanyos 2013. 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_STRING_HELPERS_HPP
+#define BOOST_MP_DETAIL_STRING_HELPERS_HPP
+
+#include <algorithm>
+#include <cstring>
+
+namespace boost { namespace multiprecision { namespace detail {
+
+   struct is_in_string
+   {
+      const char* begin;
+      const char* end;
+      is_in_string(const char* p) : begin(p), end(p + std::strlen(p)) {}
+
+      bool operator()(char s) { return std::find(begin, end, s) != end; }
+   };
+
+   struct is_not_in_string
+   {
+      const char* begin;
+      const char* end;
+      is_not_in_string(const char* p) : begin(p), end(p + std::strlen(p)) {}
+
+      bool operator()(char s) { return std::find(begin, end, s) == end; }
+   };
+
+   template <class Iterator>
+   std::size_t find_first_of(Iterator begin, Iterator end, const char* what)
+   {
+      return static_cast<std::size_t>(std::find_if(begin, end, is_in_string(what)) - begin);
+   }
+   template <class Iterator>
+   std::size_t find_first_not_of(Iterator begin, Iterator end, const char* what)
+   {
+      return static_cast<std::size_t>(std::find_if(begin, end, is_not_in_string(what)) - begin);
+   }
+
+
+}}} // namespace boost::multiprecision::detail
+
+#endif // BOOST_MP_DETAIL_STRING_HELPERS_HPP

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

@@ -0,0 +1,80 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2021 John Maddock.
+//  Copyright Christopher Kormanyos 2021. 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_TABLES_HPP
+#define BOOST_MP_DETAIL_TABLES_HPP
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+
+namespace boost { namespace multiprecision { namespace backends { namespace detail {
+struct a029750
+{
+   static constexpr std::uint32_t a029750_as_constexpr(const std::uint32_t value)
+   {
+      // Sloane's A029750 List of numbers of the form 2^k times 1, 3, 5 or 7.
+      // CoefficientList[Series[-(x + 1)^2 (x^2 + 1)^2/(2 x^4 - 1), {x, 0, 78}], x]
+      return ((value <= UINT32_C(     32)) ? UINT32_C(     32) : ((value <=  UINT32_C(     40)) ?  UINT32_C(     40) : ((value <= UINT32_C(     48)) ? UINT32_C(     48) : ((value <= UINT32_C(     56)) ? UINT32_C(     56) :
+             ((value <= UINT32_C(     64)) ? UINT32_C(     64) : ((value <=  UINT32_C(     80)) ?  UINT32_C(     80) : ((value <= UINT32_C(     96)) ? UINT32_C(     96) : ((value <= UINT32_C(    112)) ? UINT32_C(    112) :
+             ((value <= UINT32_C(    128)) ? UINT32_C(    128) : ((value <=  UINT32_C(    160)) ?  UINT32_C(    160) : ((value <= UINT32_C(    192)) ? UINT32_C(    192) : ((value <= UINT32_C(    224)) ? UINT32_C(    224) :
+             ((value <= UINT32_C(    256)) ? UINT32_C(    256) : ((value <=  UINT32_C(    320)) ?  UINT32_C(    320) : ((value <= UINT32_C(    384)) ? UINT32_C(    384) : ((value <= UINT32_C(    448)) ? UINT32_C(    448) :
+             ((value <= UINT32_C(    512)) ? UINT32_C(    512) : ((value <=  UINT32_C(    640)) ?  UINT32_C(    640) : ((value <= UINT32_C(    768)) ? UINT32_C(    768) : ((value <= UINT32_C(    896)) ? UINT32_C(    896) :
+             ((value <= UINT32_C(   1024)) ? UINT32_C(   1024) : ((value <=  UINT32_C(   1280)) ?  UINT32_C(   1280) : ((value <= UINT32_C(   1536)) ? UINT32_C(   1536) : ((value <= UINT32_C(   1792)) ? UINT32_C(   1792) :
+             ((value <= UINT32_C(   2048)) ? UINT32_C(   2048) : ((value <=  UINT32_C(   2560)) ?  UINT32_C(   2560) : ((value <= UINT32_C(   3072)) ? UINT32_C(   3072) : ((value <= UINT32_C(   3584)) ? UINT32_C(   3584) :
+             ((value <= UINT32_C(   4096)) ? UINT32_C(   4096) : ((value <=  UINT32_C(   5120)) ?  UINT32_C(   5120) : ((value <= UINT32_C(   6144)) ? UINT32_C(   6144) : ((value <= UINT32_C(   7168)) ? UINT32_C(   7168) :
+             ((value <= UINT32_C(   8192)) ? UINT32_C(   8192) : ((value <=  UINT32_C(  10240)) ?  UINT32_C(  10240) : ((value <= UINT32_C(  12288)) ? UINT32_C(  12288) : ((value <= UINT32_C(  14336)) ? UINT32_C(  14336) :
+             ((value <= UINT32_C(  16384)) ? UINT32_C(  16384) : ((value <=  UINT32_C(  20480)) ?  UINT32_C(  20480) : ((value <= UINT32_C(  24576)) ? UINT32_C(  24576) : ((value <= UINT32_C(  28672)) ? UINT32_C(  28672) :
+             ((value <= UINT32_C(  32768)) ? UINT32_C(  32768) : ((value <=  UINT32_C(  40960)) ?  UINT32_C(  40960) : ((value <= UINT32_C(  49152)) ? UINT32_C(  49152) : ((value <= UINT32_C(  57344)) ? UINT32_C(  57344) :
+             ((value <= UINT32_C(  65536)) ? UINT32_C(  65536) : ((value <=  UINT32_C(  81920)) ?  UINT32_C(  81920) : ((value <= UINT32_C(  98304)) ? UINT32_C(  98304) : ((value <= UINT32_C( 114688)) ? UINT32_C( 114688) :
+             ((value <= UINT32_C( 131072)) ? UINT32_C( 131072) : ((value <=  UINT32_C( 163840)) ?  UINT32_C( 163840) : ((value <= UINT32_C( 196608)) ? UINT32_C( 196608) : ((value <= UINT32_C( 229376)) ? UINT32_C( 229376) :
+             ((value <= UINT32_C( 262144)) ? UINT32_C( 262144) : ((value <=  UINT32_C( 327680)) ?  UINT32_C( 327680) : ((value <= UINT32_C( 393216)) ? UINT32_C( 393216) : ((value <= UINT32_C( 458752)) ? UINT32_C( 458752) :
+             ((value <= UINT32_C( 524288)) ? UINT32_C( 524288) : ((value <=  UINT32_C( 655360)) ?  UINT32_C( 655360) : ((value <= UINT32_C( 786432)) ? UINT32_C( 786432) : ((value <= UINT32_C( 917504)) ? UINT32_C( 917504) :
+             ((value <= UINT32_C(1048576)) ? UINT32_C(1048576) : ((value <=  UINT32_C(1310720)) ?  UINT32_C(1310720) : ((value <= UINT32_C(1572864)) ? UINT32_C(1572864) : ((value <= UINT32_C(1835008)) ? UINT32_C(1835008) : UINT32_C(0x7FFFFFFF)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))));
+   }
+
+   static std::uint32_t a029750_as_runtime_value(const std::uint32_t value)
+   {
+      // Sloane's A029750 List of numbers of the form 2^k times 1, 3, 5 or 7.
+      // CoefficientList[Series[-(x + 1)^2 (x^2 + 1)^2/(2 x^4 - 1), {x, 0, 78}], x]
+      constexpr std::array<std::uint32_t, 65U> a029750_data =
+      {{
+         UINT32_C(        32), UINT32_C(     40), UINT32_C(     48), UINT32_C(     56),
+         UINT32_C(        64), UINT32_C(     80), UINT32_C(     96), UINT32_C(    112),
+         UINT32_C(       128), UINT32_C(    160), UINT32_C(    192), UINT32_C(    224),
+         UINT32_C(       256), UINT32_C(    320), UINT32_C(    384), UINT32_C(    448),
+         UINT32_C(       512), UINT32_C(    640), UINT32_C(    768), UINT32_C(    896),
+         UINT32_C(      1024), UINT32_C(   1280), UINT32_C(   1536), UINT32_C(   1792),
+         UINT32_C(      2048), UINT32_C(   2560), UINT32_C(   3072), UINT32_C(   3584),
+         UINT32_C(      4096), UINT32_C(   5120), UINT32_C(   6144), UINT32_C(   7168),
+         UINT32_C(      8192), UINT32_C(  10240), UINT32_C(  12288), UINT32_C(  14336),
+         UINT32_C(     16384), UINT32_C(  20480), UINT32_C(  24576), UINT32_C(  28672),
+         UINT32_C(     32768), UINT32_C(  40960), UINT32_C(  49152), UINT32_C(  57344),
+         UINT32_C(     65536), UINT32_C(  81920), UINT32_C(  98304), UINT32_C( 114688),
+         UINT32_C(    131072), UINT32_C( 163840), UINT32_C( 196608), UINT32_C( 229376),
+         UINT32_C(    262144), UINT32_C( 327680), UINT32_C( 393216), UINT32_C( 458752),
+         UINT32_C(    524288), UINT32_C( 655360), UINT32_C( 786432), UINT32_C( 917504),
+         UINT32_C(   1048576), UINT32_C(1310720), UINT32_C(1572864), UINT32_C(1835008),
+         UINT32_C(0x7FFFFFFF)
+      }};
+
+      const std::array<std::uint32_t, 65U>::const_iterator it =
+         std::lower_bound(a029750_data.cbegin(), a029750_data.cend(), value);
+
+      return ((it != a029750_data.cend()) ? *it : UINT32_C(0xFFFFFFFF));
+   }
+};
+
+constexpr std::uint32_t pow10_maker(std::uint32_t n)
+{
+   // Make the constant power of 10^n.
+   return ((n == UINT32_C(0)) ? UINT32_C(1) : pow10_maker(n - UINT32_C(1)) * UINT32_C(10));
+}
+
+}}}} // namespace boost::multiprecision::backends::detail
+
+#endif // BOOST_MP_DETAIL_TABLES_HPP