mqt-core 3.3.2__cp314-cp314t-macosx_11_0_x86_64.whl

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

@@ -0,0 +1,75 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2013 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_UBLAS_INTEROP_HPP
+#define BOOST_MP_UBLAS_INTEROP_HPP
+
+namespace boost { namespace numeric { namespace ublas {
+
+template <class V>
+class sparse_vector_element;
+
+template <class V, class Backend, multiprecision::expression_template_option ExpressionTemplates>
+inline bool operator==(const sparse_vector_element<V>& a, const ::boost::multiprecision::number<Backend, ExpressionTemplates>& b)
+{
+   using ref_type = typename sparse_vector_element<V>::const_reference;
+   return static_cast<ref_type>(a) == b;
+}
+
+template <class X, class Y>
+struct promote_traits;
+
+template <class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1, class Backend2, boost::multiprecision::expression_template_option ExpressionTemplates2>
+struct promote_traits<boost::multiprecision::number<Backend1, ExpressionTemplates1>, boost::multiprecision::number<Backend2, ExpressionTemplates2> >
+{
+   using number1_t = boost::multiprecision::number<Backend1, ExpressionTemplates1>;
+   using number2_t = boost::multiprecision::number<Backend2, ExpressionTemplates2>;
+   using promote_type = typename std::conditional<
+       std::is_convertible<number1_t, number2_t>::value && !std::is_convertible<number2_t, number1_t>::value,
+       number2_t, number1_t>::type;
+};
+
+template <class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1, class Arithmetic>
+struct promote_traits<boost::multiprecision::number<Backend1, ExpressionTemplates1>, Arithmetic>
+{
+   using promote_type = boost::multiprecision::number<Backend1, ExpressionTemplates1>;
+};
+
+template <class Arithmetic, class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1>
+struct promote_traits<Arithmetic, boost::multiprecision::number<Backend1, ExpressionTemplates1> >
+{
+   using promote_type = boost::multiprecision::number<Backend1, ExpressionTemplates1>;
+};
+
+template <class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
+struct promote_traits<boost::multiprecision::number<Backend1, ExpressionTemplates1>, boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
+{
+   using number1_t = boost::multiprecision::number<Backend1, ExpressionTemplates1>         ;
+   using expression_type = boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>;
+   using number2_t = typename expression_type::result_type                                 ;
+   using promote_type = typename promote_traits<number1_t, number2_t>::promote_type           ;
+};
+
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class Backend1, boost::multiprecision::expression_template_option ExpressionTemplates1>
+struct promote_traits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::number<Backend1, ExpressionTemplates1> >
+{
+   using number1_t = boost::multiprecision::number<Backend1, ExpressionTemplates1>         ;
+   using expression_type = boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>;
+   using number2_t = typename expression_type::result_type                                 ;
+   using promote_type = typename promote_traits<number1_t, number2_t>::promote_type           ;
+};
+
+template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tagb, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
+struct promote_traits<boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, boost::multiprecision::detail::expression<tagb, Arg1b, Arg2b, Arg3b, Arg4b> >
+{
+   using expression1_t = boost::multiprecision::detail::expression<tag, Arg1, Arg2, Arg3, Arg4>     ;
+   using number1_t = typename expression1_t::result_type                                        ;
+   using expression2_t = boost::multiprecision::detail::expression<tagb, Arg1b, Arg2b, Arg3b, Arg4b>;
+   using number2_t = typename expression2_t::result_type                                        ;
+};
+
+}}} // namespace boost::numeric::ublas
+
+#endif

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

@@ -0,0 +1,212 @@
+///////////////////////////////////////////////////////////////
+//  Copyright Jens Maurer 2000-2021
+//  Copyright Steven Watanabe 2011-2021
+//  Copyright John Maddock 2015-2021
+//  Copyright Matt Borland 2021
+//  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
+//
+//  This is a C++11 compliant port of Boost.Random's implementation
+//  of uniform_int_distribution. See their comments for detailed
+//  descriptions
+
+#ifndef BOOST_MP_UNIFORM_INT_DISTRIBUTION_HPP
+#define BOOST_MP_UNIFORM_INT_DISTRIBUTION_HPP
+
+#include <limits>
+#include <type_traits>
+#include <boost/multiprecision/detail/standalone_config.hpp>
+#include <boost/multiprecision/detail/assert.hpp>
+#include <boost/multiprecision/traits/std_integer_traits.hpp>
+
+namespace boost { namespace multiprecision { 
+    
+namespace detail {
+
+template <typename T, bool intrinsic>
+struct make_unsigned_impl
+{
+    using type = typename boost::multiprecision::detail::make_unsigned<T>::type;
+};
+
+template <typename T>
+struct make_unsigned_impl<T, false>
+{
+    using type = T;
+};
+
+template <typename T>
+struct make_unsigned_mp
+{
+    using type = typename make_unsigned_impl<T, boost::multiprecision::detail::is_integral<T>::value>::type;
+};
+
+template <typename Engine, typename T>
+T generate_uniform_int (Engine& eng, T min_value, T max_value)
+{
+    using range_type = typename boost::multiprecision::detail::make_unsigned_mp<T>::type;
+    using base_result = typename Engine::result_type;
+    using base_unsigned = typename boost::multiprecision::detail::make_unsigned_mp<base_result>::type;
+
+    const range_type range = max_value - min_value;
+    const base_result bmin = (eng.min)();
+    const base_unsigned brange = (eng.max)() - (eng.min)();
+
+    if(range == 0)
+    {
+        return min_value;
+    }
+    else if (brange < range)
+    {
+        for(;;)
+        {
+            range_type limit;
+            if(range == (std::numeric_limits<range_type>::max)())
+            {
+                limit = range / (range_type(brange) + 1);
+                if(range % (range_type(brange) + 1) == range_type(brange))
+                {
+                    ++limit;
+                }
+            }
+            else
+            {
+                limit = (range + 1) / (range_type(brange) + 1);
+            }
+
+            range_type result = 0;
+            range_type mult = 1;
+
+            while (mult <= limit)
+            {
+                result += static_cast<range_type>(static_cast<range_type>(eng() - bmin) * mult);
+
+                if(mult * range_type(brange) == range - mult + 1)
+                {
+                    return(result);
+                }
+
+                mult *= range_type(brange)+range_type(1);
+            }
+
+            range_type result_increment = generate_uniform_int(eng, range_type(0), range_type(range/mult));
+
+            if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment))
+            {
+                continue;
+            }
+
+            result_increment *= mult;
+            result += result_increment;
+
+            if(result < result_increment)
+            {
+                continue;
+            }
+            if(result > range)
+            {
+                continue;
+            }
+
+            return result + min_value;
+        }
+    }
+    else
+    {
+        using mixed_range_type = 
+        typename std::conditional<std::numeric_limits<range_type>::is_specialized && std::numeric_limits<base_unsigned>::is_specialized &&
+                                  (std::numeric_limits<range_type>::digits >= std::numeric_limits<base_unsigned>::digits),
+                                  range_type, base_unsigned>::type;
+
+        mixed_range_type bucket_size;
+
+        if(brange == (std::numeric_limits<base_unsigned>::max)()) 
+        {
+            bucket_size = static_cast<mixed_range_type>(brange) / (static_cast<mixed_range_type>(range)+1);
+            if(static_cast<mixed_range_type>(brange) % (static_cast<mixed_range_type>(range)+1) == static_cast<mixed_range_type>(range)) 
+            {
+                ++bucket_size;
+            }
+        } 
+        else 
+        {
+            bucket_size = static_cast<mixed_range_type>(brange + 1) / (static_cast<mixed_range_type>(range)+1);
+        }
+
+        for(;;) 
+        {
+            mixed_range_type result = eng() - bmin;
+            result /= bucket_size;
+
+            if(result <= static_cast<mixed_range_type>(range))
+            {
+                return result + min_value;
+            }
+        }
+    }
+}
+
+} // Namespace detail
+
+template <typename Integer = int>
+class uniform_int_distribution
+{
+private:
+    Integer min_;
+    Integer max_;
+
+public:
+    class param_type
+    {
+    private:
+        Integer min_;
+        Integer max_;
+    
+    public:
+        explicit param_type(Integer min_val, Integer max_val) : min_ {min_val}, max_ {max_val}
+        {
+            BOOST_MP_ASSERT(min_ <= max_);
+        }
+
+        Integer a() const { return min_; }
+        Integer b() const { return max_; }
+    };
+
+    explicit uniform_int_distribution(Integer min_arg, Integer max_arg) : min_ {min_arg}, max_ {max_arg}
+    {
+        BOOST_MP_ASSERT(min_ <= max_);
+    }
+
+    explicit uniform_int_distribution(const param_type& param_arg) : min_ {param_arg.a()}, max_ {param_arg.b()} {}
+
+    Integer min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return min_; }
+    Integer max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return max_; }
+    
+    Integer a() const { return min_; }
+    Integer b() const { return max_; }
+
+    param_type param() const { return param_type(min_, max_); }
+
+    void param(const param_type& param_arg)
+    {
+        min_ = param_arg.a();
+        max_ = param_arg.b();
+    }
+
+    template <typename Engine>
+    Integer operator() (Engine& eng) const
+    {
+        return detail::generate_uniform_int(eng, min_, max_);
+    }
+
+    template <typename Engine>
+    Integer operator() (Engine& eng, const param_type& param_arg) const
+    {
+        return detail::generate_uniform_int(eng, param_arg.a(), param_arg.b());
+    }
+};
+
+}} // Namespaces
+
+#endif // BOOST_MP_UNIFORM_INT_DISTRIBUTION_HPP

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

@@ -0,0 +1,374 @@
+///////////////////////////////////////////////////////////////////////////////
+//  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_UTYPE_HELPER_HPP
+#define BOOST_MP_UTYPE_HELPER_HPP
+
+#include <limits>
+#include <cstdint>
+
+namespace boost {
+namespace multiprecision {
+namespace detail {
+template <const unsigned>
+struct utype_helper
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<0U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<1U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<2U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<3U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<4U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<5U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<6U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<7U>
+{
+   using exact = boost::uint8_t;
+};
+template <>
+struct utype_helper<8U>
+{
+   using exact = boost::uint8_t;
+};
+
+template <>
+struct utype_helper<9U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<10U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<11U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<12U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<13U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<14U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<15U>
+{
+   using exact = std::uint16_t;
+};
+template <>
+struct utype_helper<16U>
+{
+   using exact = std::uint16_t;
+};
+
+template <>
+struct utype_helper<17U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<18U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<19U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<20U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<21U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<22U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<23U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<24U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<25U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<26U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<27U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<28U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<29U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<30U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<31U>
+{
+   using exact = std::uint32_t;
+};
+template <>
+struct utype_helper<32U>
+{
+   using exact = std::uint32_t;
+};
+
+template <>
+struct utype_helper<33U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<34U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<35U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<36U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<37U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<38U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<39U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<40U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<41U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<42U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<43U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<44U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<45U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<46U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<47U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<48U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<49U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<50U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<51U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<52U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<53U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<54U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<55U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<56U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<57U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<58U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<59U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<60U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<61U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<62U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<63U>
+{
+   using exact = std::uint64_t;
+};
+template <>
+struct utype_helper<64U>
+{
+   using exact = std::uint64_t;
+};
+
+template <class unsigned_type>
+int utype_prior(unsigned_type ui)
+{
+   // TBD: Implement a templated binary search for this.
+   int priority_bit;
+
+   unsigned_type priority_mask = unsigned_type(unsigned_type(1U) << (std::numeric_limits<unsigned_type>::digits - 1));
+
+   for (priority_bit = std::numeric_limits<unsigned_type>::digits - 1; priority_bit >= 0; --priority_bit)
+   {
+      if (unsigned_type(priority_mask & ui) != unsigned_type(0U))
+      {
+         break;
+      }
+
+      priority_mask >>= 1;
+   }
+
+   return priority_bit;
+}
+
+}}} // namespace boost::multiprecision::detail
+
+#endif // BOOST_MP_UTYPE_HELPER_HPP