mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.whl

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

@@ -0,0 +1,29 @@
+//  (C) Copyright Matt Borland 2021.
+//  Use, modification and distribution are subject to 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)
+//
+// We deliberately use assert in here:
+//
+// boost-no-inspect
+
+#ifndef BOOST_MP_DETAIL_ASSERT_HPP
+#define BOOST_MP_DETAIL_ASSERT_HPP
+
+#include <boost/multiprecision/detail/standalone_config.hpp>
+
+#ifndef BOOST_MP_STANDALONE
+
+#include <boost/assert.hpp>
+#define BOOST_MP_ASSERT(expr) BOOST_ASSERT(expr)
+#define BOOST_MP_ASSERT_MSG(expr, msg) BOOST_ASSERT_MSG(expr, msg)
+
+#else // Standalone mode - use cassert
+
+#include <cassert>
+#define BOOST_MP_ASSERT(expr) assert(expr)
+#define BOOST_MP_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
+
+#endif
+
+#endif // BOOST_MP_DETAIL_ASSERT_HPP

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

@@ -0,0 +1,62 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2017 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_ATOMIC_HPP
+#define BOOST_MP_DETAIL_ATOMIC_HPP
+
+#include <boost/multiprecision/detail/standalone_config.hpp>
+
+#ifdef BOOST_HAS_THREADS
+
+#  include <atomic>
+#  define BOOST_MATH_ATOMIC_NS std
+namespace boost {
+   namespace multiprecision {
+      namespace detail {
+#if ATOMIC_INT_LOCK_FREE == 2
+         using atomic_counter_type = std::atomic<int>;
+         using atomic_unsigned_type = std::atomic<unsigned>;
+         using atomic_integer_type = int;
+         using atomic_unsigned_integer_type = unsigned;
+#elif ATOMIC_SHORT_LOCK_FREE == 2
+         using atomic_counter_type = std::atomic<short>;
+         using atomic_unsigned_type = std::atomic<unsigned short>;
+         using atomic_integer_type = short;
+         using atomic_unsigned_integer_type = unsigned short;
+#elif ATOMIC_LONG_LOCK_FREE == 2
+         using atomic_unsigned_integer_type = std::atomic<long>;
+         using atomic_unsigned_type = std::atomic<unsigned long>;
+         using atomic_unsigned_integer_type = unsigned long;
+         using atomic_integer_type = long;
+#elif ATOMIC_LLONG_LOCK_FREE == 2
+         using atomic_unsigned_integer_type = std::atomic<long long>;
+         using atomic_unsigned_type = std::atomic<unsigned long long>;
+         using atomic_integer_type = long long;
+         using atomic_unsigned_integer_type = unsigned long long;
+#else
+
+#define BOOST_MT_NO_ATOMIC_INT
+
+#endif
+      }
+   }}
+#else // BOOST_HAS_THREADS
+
+#define BOOST_MT_NO_ATOMIC_INT
+
+#endif // BOOST_HAS_THREADS
+
+namespace boost { namespace multiprecision { namespace detail {
+
+#ifdef BOOST_MT_NO_ATOMIC_INT
+using precision_type = unsigned;
+#else
+using precision_type = atomic_unsigned_type;
+#endif
+
+} } }
+
+#endif // BOOST_MP_DETAIL_ATOMIC_HPP

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

@@ -0,0 +1,317 @@
+///////////////////////////////////////////////////////////////
+//  Copyright 2013 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_DETAIL_BITSCAN_HPP
+#define BOOST_MP_DETAIL_BITSCAN_HPP
+
+#include <cstdint>
+#include <climits>
+#include <type_traits>
+#include <boost/multiprecision/detail/endian.hpp>
+#include <boost/multiprecision/detail/standalone_config.hpp>
+
+#if (defined(BOOST_MSVC) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
+#include <intrin.h>
+#endif
+
+namespace boost { namespace multiprecision { namespace detail {
+
+template <class Unsigned>
+inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb_default(Unsigned mask)
+{
+   std::size_t result = 0;
+   while (!(mask & 1u))
+   {
+      mask >>= 1;
+      ++result;
+   }
+   return result;
+}
+
+template <class Unsigned>
+inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb_default(Unsigned mask)
+{
+   std::size_t index = 0;
+   while (mask)
+   {
+      ++index;
+      mask >>= 1;
+   }
+   return --index;
+}
+
+template <class Unsigned>
+inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask, const std::integral_constant<int, 0>&)
+{
+   return find_lsb_default(mask);
+}
+
+template <class Unsigned>
+inline BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask, const std::integral_constant<int, 0>&)
+{
+   return find_msb_default(mask);
+}
+
+#if (defined(BOOST_MSVC) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
+
+#pragma intrinsic(_BitScanForward, _BitScanReverse)
+
+BOOST_FORCEINLINE std::size_t find_lsb(unsigned long mask, const std::integral_constant<int, 1>&)
+{
+   unsigned long result;
+   _BitScanForward(&result, mask);
+   return result;
+}
+
+BOOST_FORCEINLINE std::size_t find_msb(unsigned long mask, const std::integral_constant<int, 1>&)
+{
+   unsigned long result;
+   _BitScanReverse(&result, mask);
+   return result;
+}
+#ifdef _M_X64
+
+#pragma intrinsic(_BitScanForward64, _BitScanReverse64)
+
+BOOST_FORCEINLINE std::size_t find_lsb(unsigned __int64 mask, const std::integral_constant<int, 2>&)
+{
+   unsigned long result;
+   _BitScanForward64(&result, mask);
+   return result;
+}
+template <class Unsigned>
+BOOST_FORCEINLINE std::size_t find_msb(Unsigned mask, const std::integral_constant<int, 2>&)
+{
+   unsigned long result;
+   _BitScanReverse64(&result, mask);
+   return result;
+}
+#endif
+
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
+   using tag_type = typename std::conditional<
+       sizeof(Unsigned) <= sizeof(unsigned long),
+       std::integral_constant<int, 1>,
+#ifdef _M_X64
+       typename std::conditional<
+           sizeof(Unsigned) <= sizeof(__int64),
+           std::integral_constant<int, 2>,
+           std::integral_constant<int, 0> >::type
+#else
+       std::integral_constant<int, 0>
+#endif
+       >::type;
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(mask))
+   {
+      return find_lsb_default(mask);
+   }
+   else
+#endif
+      return find_lsb(static_cast<ui_type>(mask), tag_type());
+}
+
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
+   using tag_type = typename std::conditional<
+       sizeof(Unsigned) <= sizeof(unsigned long),
+       std::integral_constant<int, 1>,
+#ifdef _M_X64
+       typename std::conditional<
+           sizeof(Unsigned) <= sizeof(__int64),
+           std::integral_constant<int, 2>,
+           std::integral_constant<int, 0> >::type
+#else
+       std::integral_constant<int, 0>
+#endif
+       >::type;
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(mask))
+   {
+      return find_msb_default(mask);
+   }
+   else
+#endif
+      return find_msb(static_cast<ui_type>(mask), tag_type());
+}
+
+#elif defined(BOOST_GCC) || defined(__clang__) || (defined(BOOST_INTEL) && defined(__GNUC__))
+
+BOOST_FORCEINLINE std::size_t find_lsb(std::size_t mask, std::integral_constant<int, 1> const&)
+{
+   return static_cast<std::size_t>(__builtin_ctz(static_cast<unsigned int>(mask)));
+}
+BOOST_FORCEINLINE std::size_t find_lsb(unsigned long mask, std::integral_constant<int, 2> const&)
+{
+   return static_cast<std::size_t>(__builtin_ctzl(static_cast<unsigned long>(mask)));
+}
+BOOST_FORCEINLINE std::size_t find_lsb(unsigned long long mask, std::integral_constant<int, 3> const&)
+{
+   return static_cast<std::size_t>(__builtin_ctzll(static_cast<unsigned long long>(mask)));
+}
+BOOST_FORCEINLINE std::size_t find_msb(std::size_t mask, std::integral_constant<int, 1> const&)
+{
+   return static_cast<std::size_t>(static_cast<std::size_t>(sizeof(unsigned) * static_cast<std::size_t>(CHAR_BIT) - 1u) - static_cast<std::size_t>(__builtin_clz(static_cast<unsigned int>(mask))));
+}
+BOOST_FORCEINLINE std::size_t find_msb(unsigned long mask, std::integral_constant<int, 2> const&)
+{
+   return static_cast<std::size_t>(static_cast<std::size_t>(sizeof(unsigned long) * static_cast<std::size_t>(CHAR_BIT) - 1u) - static_cast<std::size_t>(__builtin_clzl(static_cast<unsigned long>(mask))));
+}
+BOOST_FORCEINLINE std::size_t find_msb(unsigned long long mask, std::integral_constant<int, 3> const&)
+{
+   return static_cast<std::size_t>(static_cast<std::size_t>(sizeof(unsigned long long) * static_cast<std::size_t>(CHAR_BIT) - 1u) - static_cast<std::size_t>(__builtin_clzll(static_cast<unsigned long long>(mask))));
+}
+#ifdef BOOST_HAS_INT128
+
+BOOST_FORCEINLINE std::size_t find_msb(uint128_type mask, std::integral_constant<int, 0> const&)
+{
+   union
+   {
+      uint128_type    v;
+      std::uint64_t sv[2];
+   } val;
+   val.v = mask;
+#if BOOST_MP_ENDIAN_LITTLE_BYTE
+   if (val.sv[1])
+      return find_msb(val.sv[1], std::integral_constant<int, 3>()) + 64;
+   return find_msb(val.sv[0], std::integral_constant<int, 3>());
+#else
+   if (val.sv[0])
+      return find_msb(val.sv[0], std::integral_constant<int, 3>()) + 64;
+   return find_msb(val.sv[1], std::integral_constant<int, 3>());
+#endif
+}
+BOOST_FORCEINLINE std::size_t find_lsb(uint128_type mask, std::integral_constant<int, 0> const&)
+{
+   union
+   {
+      uint128_type    v;
+      std::uint64_t sv[2];
+   } val;
+   val.v = mask;
+#if BOOST_MP_ENDIAN_LITTLE_BYTE
+   if (val.sv[0] == 0)
+      return find_lsb(val.sv[1], std::integral_constant<int, 3>()) + 64;
+   return find_lsb(val.sv[0], std::integral_constant<int, 3>());
+#else
+   if (val.sv[1] == 0)
+      return find_lsb(val.sv[0], std::integral_constant<int, 3>()) + 64;
+   return find_lsb(val.sv[1], std::integral_constant<int, 3>());
+#endif
+}
+#endif
+
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
+   using tag_type = typename std::conditional<
+       sizeof(Unsigned) <= sizeof(unsigned),
+       std::integral_constant<int, 1>,
+       typename std::conditional<
+           sizeof(Unsigned) <= sizeof(unsigned long),
+           std::integral_constant<int, 2>,
+           typename std::conditional<
+               sizeof(Unsigned) <= sizeof(unsigned long long),
+               std::integral_constant<int, 3>,
+               std::integral_constant<int, 0> >::type>::type>::type;
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(mask))
+   {
+      return find_lsb_default(mask);
+   }
+   else
+#endif
+   return find_lsb(static_cast<ui_type>(mask), tag_type());
+}
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
+   using tag_type = typename std::conditional<
+       sizeof(Unsigned) <= sizeof(unsigned),
+       std::integral_constant<int, 1>,
+       typename std::conditional<
+           sizeof(Unsigned) <= sizeof(unsigned long),
+           std::integral_constant<int, 2>,
+           typename std::conditional<
+               sizeof(Unsigned) <= sizeof(unsigned long long),
+               std::integral_constant<int, 3>,
+               std::integral_constant<int, 0> >::type>::type>::type;
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(mask))
+   {
+      return find_msb_default(mask);
+   }
+   else
+#endif
+      return find_msb(static_cast<ui_type>(mask), tag_type());
+}
+#elif defined(BOOST_INTEL)
+BOOST_FORCEINLINE std::size_t find_lsb(std::size_t mask, std::integral_constant<int, 1> const&)
+{
+   return _bit_scan_forward(mask);
+}
+BOOST_FORCEINLINE std::size_t find_msb(std::size_t mask, std::integral_constant<int, 1> const&)
+{
+   return _bit_scan_reverse(mask);
+}
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
+   using tag_type = typename std::conditional<
+       sizeof(Unsigned) <= sizeof(unsigned),
+       std::integral_constant<int, 1>,
+       std::integral_constant<int, 0> >::type;
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(mask))
+   {
+      return find_lsb_default(mask);
+   }
+   else
+#endif
+      return find_lsb(static_cast<ui_type>(mask), tag_type());
+}
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
+{
+   using ui_type = typename boost::multiprecision::detail::make_unsigned<Unsigned>::type;
+   using tag_type = typename std::conditional<
+       sizeof(Unsigned) <= sizeof(unsigned),
+       std::integral_constant<int, 1>,
+       std::integral_constant<int, 0> >::type;
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(mask))
+   {
+      return find_msb_default(mask);
+   }
+   else
+#endif
+      return find_msb(static_cast<ui_type>(mask), tag_type());
+}
+#else
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_lsb(Unsigned mask)
+{
+   return find_lsb(mask, std::integral_constant<int, 0>());
+}
+template <class Unsigned>
+BOOST_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR std::size_t find_msb(Unsigned mask)
+{
+   return find_msb(mask, std::integral_constant<int, 0>());
+}
+#endif
+
+}}} // namespace boost::multiprecision::detail
+
+#endif

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

@@ -0,0 +1,64 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2011 John Maddock. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MP_CHECK_CPP11_CONFIG_HPP
+#define BOOST_MP_CHECK_CPP11_CONFIG_HPP
+
+//
+// We now require C++11, if something we use is not supported, then error and say why:
+//
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_RVALUE_REFERENCES being set"
+#endif
+#ifdef BOOST_NO_CXX11_TEMPLATE_ALIASES
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_TEMPLATE_ALIASES being set"
+#endif
+#ifdef BOOST_NO_CXX11_HDR_ARRAY
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_HDR_ARRAY being set"
+#endif
+#ifdef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_HDR_TYPE_TRAITS being set"
+#endif
+#ifdef BOOST_NO_CXX11_ALLOCATOR
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_ALLOCATOR being set"
+#endif
+#ifdef BOOST_NO_CXX11_CONSTEXPR
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_CONSTEXPR being set"
+#endif
+#ifdef BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_MP_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS being set"
+#endif
+#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_REF_QUALIFIERS being set"
+#endif
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_HDR_FUNCTIONAL being set"
+#endif
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_VARIADIC_TEMPLATES being set"
+#endif
+#ifdef BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_USER_DEFINED_LITERALS being set"
+#endif
+#ifdef BOOST_NO_CXX11_DECLTYPE
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_DECLTYPE being set"
+#endif
+#ifdef BOOST_NO_CXX11_STATIC_ASSERT
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_STATIC_ASSERT being set"
+#endif
+#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_DEFAULTED_FUNCTIONS being set"
+#endif
+#ifdef BOOST_NO_CXX11_NOEXCEPT
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_NOEXCEPT being set"
+#endif
+#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_REF_QUALIFIERS being set"
+#endif
+#ifdef BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#error "This library now requires a C++11 or later compiler - this message was generated as a result of BOOST_NO_CXX11_USER_DEFINED_LITERALS being set"
+#endif
+
+#endif // BOOST_MP_CHECK_CPP11_CONFIG_HPP

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

@@ -0,0 +1,88 @@
+///////////////////////////////////////////////////////////////
+//  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
+
+#ifndef BOOST_MP_DETAIL_CONSTEXPR_HPP
+#define BOOST_MP_DETAIL_CONSTEXPR_HPP
+
+#include <cstring>
+#include <boost/multiprecision/detail/standalone_config.hpp>
+
+namespace boost {
+
+namespace multiprecision {
+
+namespace std_constexpr {
+
+template <class T>
+inline BOOST_CXX14_CONSTEXPR void swap(T& a, T& b)
+{
+   T t(a);
+   a = b;
+   b = t;
+}
+
+template <class InputIterator, class OutputIterator>
+inline BOOST_CXX14_CONSTEXPR OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
+{
+   //
+   // There are 3 branches here, only one of which is selected at compile time:
+   //
+#ifndef BOOST_MP_NO_CONSTEXPR_DETECTION
+   if (BOOST_MP_IS_CONST_EVALUATED(*first))
+   {
+      // constexpr safe code, never generates runtime code:
+      while (first != last)
+      {
+         *result = *first;
+         ++first;
+         ++result;
+      }
+      return result;
+   }
+   else
+#endif
+   {
+#ifndef BOOST_NO_CXX17_IF_CONSTEXPR
+      if constexpr (std::is_pointer<InputIterator>::value && std::is_pointer<OutputIterator>::value && std::is_trivially_copyable<typename std::remove_reference<decltype(*first)>::type>::value)
+      {
+         // The normal runtime branch:
+         std::memcpy(result, first, static_cast<std::size_t>(static_cast<std::size_t>(last - first) * sizeof(*first)));
+         return result + (last - first);
+      }
+      else
+#endif
+      {
+         // Alternate runtime branch:
+         while (first != last)
+         {
+            *result = *first;
+            ++first;
+            ++result;
+         }
+         return result;
+      }
+   }
+}
+
+template <class I>
+inline BOOST_CXX14_CONSTEXPR bool equal(const I* first, const I* last, const I* other)
+{
+   while (first != last)
+   {
+      if (*first != *other)
+         return false;
+      ++first;
+      ++other;
+   }
+   return true;
+}
+
+}
+
+}
+
+} // namespace boost::multiprecision::std_constexpr
+
+#endif