mqt-core 3.3.2__cp312-cp312-win_amd64.whl

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

@@ -0,0 +1,248 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2015 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_IMPORT_EXPORT_HPP
+#define BOOST_MP_CPP_INT_IMPORT_EXPORT_HPP
+
+#include <climits>
+#include <cstring>
+#include <boost/multiprecision/detail/endian.hpp>
+
+namespace boost {
+namespace multiprecision {
+
+namespace detail {
+
+template <class Backend, class Unsigned>
+void assign_bits(Backend& val, Unsigned bits, std::size_t bit_location, std::size_t chunk_bits, const std::integral_constant<bool, false>& tag)
+{
+   std::size_t limb  = bit_location / (sizeof(limb_type) * CHAR_BIT);
+   std::size_t shift = bit_location % (sizeof(limb_type) * CHAR_BIT);
+
+   limb_type mask = chunk_bits >= sizeof(limb_type) * CHAR_BIT ? ~static_cast<limb_type>(0u) : (static_cast<limb_type>(1u) << chunk_bits) - 1;
+
+   limb_type value = static_cast<limb_type>(bits & mask) << shift;
+   if (value)
+   {
+      if (val.size() == limb)
+      {
+         val.resize(limb + 1, limb + 1);
+         if (val.size() > limb)
+            val.limbs()[limb] = value;
+      }
+      else if (val.size() > limb)
+         val.limbs()[limb] |= value;
+   }
+   if (chunk_bits > sizeof(limb_type) * CHAR_BIT - shift)
+   {
+      shift = sizeof(limb_type) * CHAR_BIT - shift;
+      chunk_bits -= shift;
+      bit_location += shift;
+      bits >>= shift;
+      if (bits)
+         assign_bits(val, bits, bit_location, chunk_bits, tag);
+   }
+}
+template <class Backend, class Unsigned>
+void assign_bits(Backend& val, Unsigned bits, std::size_t bit_location, std::size_t chunk_bits, const std::integral_constant<bool, true>&)
+{
+   using local_limb_type = typename Backend::local_limb_type;
+   //
+   // Check for possible overflow, this may trigger an exception, or have no effect
+   // depending on whether this is a checked integer or not:
+   //
+   if ((bit_location >= sizeof(local_limb_type) * CHAR_BIT) && bits)
+      val.resize(2, 2);
+   else
+   {
+      local_limb_type mask  = chunk_bits >= sizeof(local_limb_type) * CHAR_BIT ? ~static_cast<local_limb_type>(0u) : (static_cast<local_limb_type>(1u) << chunk_bits) - 1;
+      local_limb_type value = (static_cast<local_limb_type>(bits) & mask) << bit_location;
+      *val.limbs() |= value;
+      //
+      // Check for overflow bits:
+      //
+      bit_location = sizeof(local_limb_type) * CHAR_BIT - bit_location;
+      if ((bit_location < sizeof(bits) * CHAR_BIT) && (bits >>= bit_location))
+         val.resize(2, 2); // May throw!
+   }
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
+inline void resize_to_bit_size(cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& newval, std::size_t bits, const std::integral_constant<bool, false>&)
+{
+   std::size_t limb_count = static_cast<unsigned>(bits / (sizeof(limb_type) * CHAR_BIT));
+   if (bits % (sizeof(limb_type) * CHAR_BIT))
+      ++limb_count;
+   constexpr std::size_t max_limbs = MaxBits ? MaxBits / (CHAR_BIT * sizeof(limb_type)) + ((MaxBits % (CHAR_BIT * sizeof(limb_type))) ? 1 : 0) : (std::numeric_limits<unsigned>::max)();
+   if (limb_count > max_limbs)
+      limb_count = max_limbs;
+   newval.resize(limb_count, limb_count);
+   std::memset(newval.limbs(), 0, newval.size() * sizeof(limb_type));
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator>
+inline void resize_to_bit_size(cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& newval, unsigned, const std::integral_constant<bool, true>&)
+{
+   *newval.limbs() = 0;
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class Iterator>
+number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
+import_bits_generic(
+    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, Iterator i, Iterator j, std::size_t chunk_size = 0, bool msv_first = true)
+{
+   typename number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>::backend_type newval;
+
+   using value_type = typename std::iterator_traits<Iterator>::value_type                                  ;
+   using unsigned_value_type = typename boost::multiprecision::detail::make_unsigned<value_type>::type                                        ;
+   using difference_type = typename std::iterator_traits<Iterator>::difference_type                             ;
+   using size_type = typename boost::multiprecision::detail::make_unsigned<difference_type>::type                                   ;
+   using tag_type = typename cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>::trivial_tag;
+
+   if (!chunk_size)
+      chunk_size = std::numeric_limits<value_type>::digits;
+
+   size_type limbs = std::distance(i, j);
+   size_type bits  = limbs * chunk_size;
+
+   detail::resize_to_bit_size(newval, static_cast<unsigned>(bits), tag_type());
+
+   difference_type bit_location        = msv_first ? bits - chunk_size : 0;
+   difference_type bit_location_change = msv_first ? -static_cast<difference_type>(chunk_size) : chunk_size;
+
+   while (i != j)
+   {
+      detail::assign_bits(newval, static_cast<unsigned_value_type>(*i), static_cast<std::size_t>(bit_location), chunk_size, tag_type());
+      ++i;
+      bit_location += bit_location_change;
+   }
+
+   newval.normalize();
+
+   val.backend().swap(newval);
+   return val;
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class T>
+inline typename std::enable_if< !boost::multiprecision::backends::is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value, number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&>::type
+import_bits_fast(
+    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, T* i, T* j, std::size_t chunk_size = 0)
+{
+   std::size_t byte_len = (j - i) * (chunk_size ? chunk_size / CHAR_BIT : sizeof(*i));
+   std::size_t limb_len = byte_len / sizeof(limb_type);
+   if (byte_len % sizeof(limb_type))
+      ++limb_len;
+   cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& result = val.backend();
+   result.resize(static_cast<unsigned>(limb_len), static_cast<unsigned>(limb_len)); // checked types may throw here if they're not large enough to hold the data!
+   result.limbs()[result.size() - 1] = 0u;
+   std::memcpy(result.limbs(), i, (std::min)(byte_len, result.size() * sizeof(limb_type)));
+   result.normalize(); // In case data has leading zeros.
+   return val;
+}
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class T>
+inline typename std::enable_if<boost::multiprecision::backends::is_trivial_cpp_int<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator> >::value, number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&>::type
+import_bits_fast(
+    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, T* i, T* j, std::size_t chunk_size = 0)
+{
+   cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>& result   = val.backend();
+   std::size_t                                                      byte_len = (j - i) * (chunk_size ? chunk_size / CHAR_BIT : sizeof(*i));
+   std::size_t                                                      limb_len = byte_len / sizeof(result.limbs()[0]);
+   if (byte_len % sizeof(result.limbs()[0]))
+      ++limb_len;
+   result.limbs()[0] = 0u;
+   result.resize(static_cast<unsigned>(limb_len), static_cast<unsigned>(limb_len)); // checked types may throw here if they're not large enough to hold the data!
+   std::memcpy(result.limbs(), i, (std::min)(byte_len, result.size() * sizeof(result.limbs()[0])));
+   result.normalize(); // In case data has leading zeros.
+   return val;
+}
+} // namespace detail
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class Iterator>
+inline number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
+import_bits(
+    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, Iterator i, Iterator j, std::size_t chunk_size = 0, bool msv_first = true)
+{
+   return detail::import_bits_generic(val, i, j, chunk_size, msv_first);
+}
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class T>
+inline number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>&
+import_bits(
+    number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, T* i, T* j, std::size_t chunk_size = 0, bool msv_first = true)
+{
+#if BOOST_MP_ENDIAN_LITTLE_BYTE
+   if (((chunk_size % CHAR_BIT) == 0) && !msv_first && (sizeof(*i) * CHAR_BIT == chunk_size))
+      return detail::import_bits_fast(val, i, j, chunk_size);
+#endif
+   return detail::import_bits_generic(val, i, j, chunk_size, msv_first);
+}
+
+namespace detail {
+
+template <class Backend>
+std::uintmax_t extract_bits(const Backend& val, std::size_t location, std::size_t count, const std::integral_constant<bool, false>& tag)
+{
+   std::size_t         limb   = location / (sizeof(limb_type) * CHAR_BIT);
+   std::size_t         shift  = location % (sizeof(limb_type) * CHAR_BIT);
+   std::uintmax_t result = 0;
+   std::uintmax_t mask   = count == std::numeric_limits<std::uintmax_t>::digits ? ~static_cast<std::uintmax_t>(0) : (static_cast<std::uintmax_t>(1u) << count) - 1;
+   if (count > (sizeof(limb_type) * CHAR_BIT - shift))
+   {
+      result = extract_bits(val, location + sizeof(limb_type) * CHAR_BIT - shift, count - sizeof(limb_type) * CHAR_BIT + shift, tag);
+      result <<= sizeof(limb_type) * CHAR_BIT - shift;
+   }
+   if (limb < val.size())
+      result |= (val.limbs()[limb] >> shift) & mask;
+   return result;
+}
+
+template <class Backend>
+inline std::uintmax_t extract_bits(const Backend& val, std::size_t location, std::size_t count, const std::integral_constant<bool, true>&)
+{
+   typename Backend::local_limb_type result = *val.limbs();
+   typename Backend::local_limb_type mask   = count >= std::numeric_limits<typename Backend::local_limb_type>::digits ? ~static_cast<typename Backend::local_limb_type>(0) : (static_cast<typename Backend::local_limb_type>(1u) << count) - 1;
+   return (result >> location) & mask;
+}
+
+} // namespace detail
+
+template <std::size_t MinBits, std::size_t MaxBits, cpp_integer_type SignType, cpp_int_check_type Checked, class Allocator, expression_template_option ExpressionTemplates, class OutputIterator>
+OutputIterator export_bits(
+    const number<cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>, ExpressionTemplates>& val, OutputIterator out, std::size_t chunk_size, bool msv_first = true)
+{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+   using tag_type = typename cpp_int_backend<MinBits, MaxBits, SignType, Checked, Allocator>::trivial_tag;
+   if (!val)
+   {
+      *out = 0;
+      ++out;
+      return out;
+   }
+   std::size_t bitcount = boost::multiprecision::backends::eval_msb_imp(val.backend()) + 1;
+
+         std::ptrdiff_t bit_location = msv_first ? static_cast<std::ptrdiff_t>(bitcount - chunk_size) : 0;
+   const std::ptrdiff_t bit_step     = msv_first ? static_cast<std::ptrdiff_t>(-static_cast<std::ptrdiff_t>(chunk_size)) : static_cast<std::ptrdiff_t>(chunk_size);
+   while (bit_location % bit_step)
+      ++bit_location;
+
+   do
+   {
+      *out = detail::extract_bits(val.backend(), bit_location, chunk_size, tag_type());
+      ++out;
+      bit_location += bit_step;
+   } while ((bit_location >= 0) && (bit_location < static_cast<int>(bitcount)));
+
+   return out;
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+}
+
+}
+} // namespace boost::multiprecision
+
+#endif // BOOST_MP_CPP_INT_IMPORT_EXPORT_HPP

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

@@ -0,0 +1,138 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2020 Madhur Chauhan.
+//  Copyright 2020 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_INTEL_INTRINSICS_HPP
+#define BOOST_MP_INTEL_INTRINSICS_HPP
+//
+// Select which actual implementation header to use:
+//
+#ifdef __has_include
+#if __has_include(<immintrin.h>)
+#define BOOST_MP_HAS_IMMINTRIN_H
+#endif
+#endif
+//
+// If this is GCC/clang, then check that the actual intrinsic exists:
+//
+#if defined(__has_builtin) && defined(__GNUC__)
+#if !__has_builtin(__builtin_ia32_addcarryx_u64) && defined(BOOST_MP_HAS_IMMINTRIN_H) \
+   && !(defined(BOOST_GCC) && (__GNUC__ >= 9) \
+      && (defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64)\
+          || defined(i386) || defined(__i386) || defined(__i386__) || defined(_M_AMD64) \
+          || defined(_M_X64) || defined(__amd64__) || defined(_M_X64)))
+#undef BOOST_MP_HAS_IMMINTRIN_H
+#endif
+#elif defined(BOOST_MP_HAS_IMMINTRIN_H) && defined(__GNUC__) && !(defined(BOOST_GCC) && (__GNUC__ >= 9))
+#undef BOOST_MP_HAS_IMMINTRIN_H
+#endif
+
+#if defined(__clang_major__) && (__clang_major__ < 9)
+// We appear to crash the compiler if we try to use these intrinsics?
+#undef BOOST_MP_HAS_IMMINTRIN_H
+#endif
+
+#if defined(_WIN32) && (defined(_M_ARM64) || defined(_M_ARM))
+//
+// When targeting platforms such as ARM, msvc (and also clang when emulating msvc) still has the
+// Intel headers in its include path even though they're not usable.
+// See https://github.com/boostorg/multiprecision/issues/321
+// Also https://github.com/boostorg/multiprecision/issues/475
+//
+#undef BOOST_MP_HAS_IMMINTRIN_H
+#endif
+
+#if defined(__APPLE_CC__) && defined(__clang_major__) && (__clang_major__ < 11) && defined(BOOST_MP_HAS_IMMINTRIN_H)
+// Apple clang has it's own version numbers.
+#undef BOOST_MP_HAS_IMMINTRIN_H
+#endif
+
+
+//
+// If the compiler supports the intrinsics used by GCC internally
+// inside <immintrin.h> then we'll use them directly.
+// This is a bit of defensive programming, mostly for a modern clang
+// sitting on top of an older GCC header install.
+//
+#if defined(__has_builtin) && !defined(BOOST_INTEL)
+
+# if __has_builtin(__builtin_ia32_addcarryx_u64)
+#  define BOOST_MP_ADDC __builtin_ia32_addcarryx_u
+# endif
+
+# if __has_builtin(__builtin_ia32_subborrow_u64)
+#  define BOOST_MP_SUBB __builtin_ia32_subborrow_u
+# elif __has_builtin(__builtin_ia32_sbb_u64)
+#  define BOOST_MP_SUBB __builtin_ia32_sbb_u
+# endif
+
+#endif
+
+#ifndef BOOST_MP_ADDC
+#define BOOST_MP_ADDC _addcarry_u
+#endif
+#ifndef BOOST_MP_SUBB
+#define BOOST_MP_SUBB _subborrow_u
+#endif
+
+#ifdef BOOST_MP_HAS_IMMINTRIN_H
+
+#ifdef BOOST_MSVC
+//
+// This is a subset of the full <immintrin.h> :
+//
+#include <intrin.h>
+#else
+#include <immintrin.h>
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+namespace boost { namespace multiprecision { namespace detail {
+
+BOOST_MP_FORCEINLINE unsigned char addcarry_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
+{
+#ifdef BOOST_INTEL
+   using cast_type = unsigned __int64;
+#else
+   using cast_type = unsigned long long;
+#endif
+   return BOOST_JOIN(BOOST_MP_ADDC, 64)(carry, a, b, reinterpret_cast<cast_type*>(p_result));
+}
+
+BOOST_MP_FORCEINLINE unsigned char subborrow_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
+{
+#ifdef BOOST_INTEL
+   using cast_type = unsigned __int64;
+#else
+   using cast_type = unsigned long long;
+#endif
+   return BOOST_JOIN(BOOST_MP_SUBB, 64)(carry, a, b, reinterpret_cast<cast_type*>(p_result));
+}
+
+}}} // namespace boost::multiprecision::detail
+
+#else
+
+namespace boost { namespace multiprecision { namespace detail {
+
+BOOST_MP_FORCEINLINE unsigned char addcarry_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
+{
+   return BOOST_JOIN(BOOST_MP_ADDC, 32)(carry, a, b, reinterpret_cast<unsigned int*>(p_result));
+}
+
+BOOST_MP_FORCEINLINE unsigned char subborrow_limb(unsigned char carry, limb_type a, limb_type b, limb_type* p_result)
+{
+   return BOOST_JOIN(BOOST_MP_SUBB, 32)(carry, a, b, reinterpret_cast<unsigned int*>(p_result));
+}
+
+}}} // namespace boost::multiprecision::detail
+
+#endif
+
+#endif
+
+#endif