mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.whl

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

@@ -0,0 +1,95 @@
+//  (C) Copyright John Maddock 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:
+//
+
+#ifndef BOOST_MP_DETAIL_FLOAT128_FUNCTIONS_HPP
+#define BOOST_MP_DETAIL_FLOAT128_FUNCTIONS_HPP
+
+#include <boost/multiprecision/detail/standalone_config.hpp>
+
+#ifndef BOOST_MP_STANDALONE
+#include <boost/cstdfloat.hpp>
+#if defined(BOOST_MATH_USE_FLOAT128) && !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_SUPPORT)
+#  define BOOST_MP_HAVE_CSTDFLOAT
+#endif
+#endif
+
+#if defined(BOOST_HAS_FLOAT128)
+
+namespace boost 
+{
+namespace multiprecision 
+{
+namespace float128_procs 
+{
+extern "C" __float128 ldexpq(__float128, int) throw();
+extern "C" __float128 frexpq(__float128, int*) throw();
+extern "C" __float128 floorq(__float128) throw();
+extern "C" __float128 nextafterq(__float128, __float128) throw();
+extern "C" int        isinfq(__float128) throw();
+extern "C" int        isnanq(__float128) throw();
+extern "C" __float128 strtoflt128(const char*, char**) throw();
+
+#ifdef BOOST_MP_HAVE_CSTDFLOAT
+using std::ldexp;
+using std::frexp;
+using std::floor;
+using std::nextafter;
+#else
+inline __float128 ldexp(__float128 f, int i) throw() { return ldexpq(f, i); }
+inline __float128 frexp(__float128 f, int* p) throw() { return frexpq(f, p); }
+inline __float128 floor(__float128 f) throw() { return floorq(f); }
+inline __float128 nextafter(__float128 a, __float128 b) throw() { return nextafterq(a, b); }
+#endif
+}
+
+namespace detail {
+
+template <class T>
+struct is_float128 : public std::is_same<__float128, T>
+{};
+
+}
+}
+}
+
+namespace boost {
+namespace math {
+
+   inline __float128 float_next(const __float128& f)
+   {
+      return boost::multiprecision::float128_procs::nextafterq(f, 2 * f);
+   }
+   inline int (isinf)(const __float128& f)
+   {
+      return boost::multiprecision::float128_procs::isinfq(f);
+   }
+   inline int (isnan)(const __float128& f)
+   {
+      return boost::multiprecision::float128_procs::isnanq(f);
+   }
+
+}}
+
+#define BOOST_MP_FLOAT128_USING using boost::multiprecision::float128_procs::ldexp; using boost::multiprecision::float128_procs::frexp; using boost::multiprecision::float128_procs::floor; using boost::multiprecision::float128_procs::nextafter; using boost::math::isinf; using boost::math::isnan;
+
+#else
+#define BOOST_MP_FLOAT128_USING
+
+namespace boost {
+namespace multiprecision {
+namespace detail {
+
+template <class T>
+struct is_float128 : public std::false_type
+{};
+
+}}} // namespace boost::multiprecision::detail
+
+#endif
+
+#endif // BOOST_MP_DETAIL_FLOAT128_FUNCTIONS_HPP

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

@@ -0,0 +1,333 @@
+///////////////////////////////////////////////////////////////
+//  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
+//
+// Generic routines for converting floating point values to and from decimal strings.
+// Note that these use "naive" algorithms which result in rounding error - so they
+// do not round trip to and from the string representation (but should only be out
+// in the last bit).
+//
+
+#ifndef BOOST_MP_FLOAT_STRING_CVT_HPP
+#define BOOST_MP_FLOAT_STRING_CVT_HPP
+
+#include <string>
+#include <cctype>
+#include <boost/multiprecision/detail/no_exceptions_support.hpp>
+#include <boost/multiprecision/detail/assert.hpp>
+
+namespace boost { namespace multiprecision { namespace detail {
+
+template <class I>
+inline void round_string_up_at(std::string& s, std::ptrdiff_t pos, I& expon)
+{
+   //
+   // Rounds up a string representation of a number at pos:
+   //
+   if (pos < 0)
+   {
+      s.insert(static_cast<std::string::size_type>(0), 1, '1');
+      s.erase(s.size() - 1);
+      ++expon;
+   }
+   else if (s[static_cast<std::size_t>(pos)] == '9')
+   {
+      s[static_cast<std::size_t>(pos)] = '0';
+      round_string_up_at(s, pos - 1, expon);
+   }
+   else
+   {
+      if ((pos == 0) && (s[static_cast<std::size_t>(pos)] == '0') && (s.size() == 1))
+         ++expon;
+      ++s[static_cast<std::size_t>(pos)];
+   }
+}
+
+template <class Backend>
+std::string convert_to_string(Backend b, std::streamsize digits, std::ios_base::fmtflags f)
+{
+   using default_ops::eval_convert_to;
+   using default_ops::eval_divide;
+   using default_ops::eval_floor;
+   using default_ops::eval_fpclassify;
+   using default_ops::eval_log10;
+   using default_ops::eval_multiply;
+   using default_ops::eval_pow;
+   using default_ops::eval_subtract;
+
+   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
+   using exponent_type = typename Backend::exponent_type                            ;
+
+   std::string     result;
+   bool            iszero     = false;
+   bool            isneg      = false;
+   exponent_type   expon      = 0;
+   std::streamsize org_digits = digits;
+   BOOST_MP_ASSERT(digits > 0);
+
+   int fpt = eval_fpclassify(b);
+
+   if (fpt == static_cast<int>(FP_ZERO))
+   {
+      result = "0";
+      iszero = true;
+   }
+   else if (fpt == static_cast<int>(FP_INFINITE))
+   {
+      if (b.compare(ui_type(0)) < 0)
+         return "-inf";
+      else
+         return ((f & std::ios_base::showpos) == std::ios_base::showpos) ? "+inf" : "inf";
+   }
+   else if (fpt == static_cast<int>(FP_NAN))
+   {
+      return "nan";
+   }
+   else
+   {
+      //
+      // Start by figuring out the exponent:
+      //
+      isneg = b.compare(ui_type(0)) < 0;
+      if (isneg)
+         b.negate();
+      Backend t;
+      Backend ten;
+      ten = ui_type(10);
+
+      eval_log10(t, b);
+      eval_floor(t, t);
+      eval_convert_to(&expon, t);
+      if (-expon > std::numeric_limits<number<Backend> >::max_exponent10 - 3)
+      {
+         int     e = -expon / 2;
+         Backend t2;
+         eval_pow(t2, ten, e);
+         eval_multiply(t, t2, b);
+         eval_multiply(t, t2);
+         if (expon & 1)
+            eval_multiply(t, ten);
+      }
+      else
+      {
+         eval_pow(t, ten, -expon);
+         eval_multiply(t, b);
+      }
+      //
+      // Make sure we're between [1,10) and adjust if not:
+      //
+      if (t.compare(ui_type(1)) < 0)
+      {
+         eval_multiply(t, ui_type(10));
+         --expon;
+      }
+      else if (t.compare(ui_type(10)) >= 0)
+      {
+         eval_divide(t, ui_type(10));
+         ++expon;
+      }
+      Backend digit;
+      ui_type cdigit;
+      //
+      // Adjust the number of digits required based on formatting options:
+      //
+      if (((f & std::ios_base::fixed) == std::ios_base::fixed) && (expon != -1))
+         digits += expon + 1;
+      if ((f & std::ios_base::scientific) == std::ios_base::scientific)
+         ++digits;
+      //
+      // Extract the digits one at a time:
+      //
+      for (unsigned i = 0; i < digits; ++i)
+      {
+         eval_floor(digit, t);
+         eval_convert_to(&cdigit, digit);
+         result += static_cast<char>('0' + cdigit);
+         eval_subtract(t, digit);
+         eval_multiply(t, ten);
+      }
+      //
+      // Possibly round result:
+      //
+      if (digits >= 0)
+      {
+         eval_floor(digit, t);
+         eval_convert_to(&cdigit, digit);
+         eval_subtract(t, digit);
+         if ((cdigit == 5) && (t.compare(ui_type(0)) == 0))
+         {
+            // Bankers rounding:
+            if ((*result.rbegin() - '0') & 1)
+            {
+               round_string_up_at(result, static_cast<std::ptrdiff_t>(result.size() - 1u), expon);
+            }
+         }
+         else if (cdigit >= 5)
+         {
+            round_string_up_at(result, static_cast<std::ptrdiff_t>(result.size() - 1u), expon);
+         }
+      }
+      eval_floor(t, b);
+      if ((t.compare(b) == 0) && (static_cast<std::size_t>(expon + 1) < result.size()))
+      {
+         // Input is an integer, sometimes we get a result which is not an integer here as a result of printing too
+         // many digits, so lets round if required:
+         round_string_up_at(result, expon + 1, expon);
+         result.erase(static_cast<std::string::size_type>(expon + 1));
+      }
+   }
+   while ((static_cast<std::streamsize>(result.size()) > digits) && (result.size() != 0U))
+   {
+      // We may get here as a result of rounding...
+      if (result.size() > 1)
+         result.erase(result.size() - 1);
+      else
+      {
+         if (expon > 0)
+            --expon; // so we put less padding in the result.
+         else
+            ++expon;
+         ++digits;
+      }
+   }
+   BOOST_MP_ASSERT(org_digits >= 0);
+   if (isneg)
+      result.insert(static_cast<std::string::size_type>(0), 1, '-');
+   format_float_string(result, expon, org_digits, f, iszero);
+
+   return result;
+}
+
+template <class Backend>
+void convert_from_string(Backend& b, const char* p)
+{
+   using default_ops::eval_add;
+   using default_ops::eval_divide;
+   using default_ops::eval_multiply;
+   using default_ops::eval_pow;
+
+   using ui_type = typename std::tuple_element<0, typename Backend::unsigned_types>::type;
+   b = ui_type(0);
+   if (!p || (*p == 0))
+      return;
+
+   bool                            is_neg       = false;
+   bool                            is_neg_expon = false;
+   constexpr ui_type               ten          = ui_type(10);
+   typename Backend::exponent_type expon        = 0;
+   int                             digits_seen  = 0;
+
+   using limits = std::numeric_limits<number<Backend, et_off>>;
+
+   constexpr int max_digits = limits::is_specialized ? limits::max_digits10 + 1 : INT_MAX;
+
+   if (*p == '+')
+      ++p;
+   else if (*p == '-')
+   {
+      is_neg = true;
+      ++p;
+   }
+   if ((std::strcmp(p, "nan") == 0) || (std::strcmp(p, "NaN") == 0) || (std::strcmp(p, "NAN") == 0))
+   {
+      eval_divide(b, ui_type(0));
+      if (is_neg)
+         b.negate();
+      return;
+   }
+   if ((std::strcmp(p, "inf") == 0) || (std::strcmp(p, "Inf") == 0) || (std::strcmp(p, "INF") == 0))
+   {
+      b = ui_type(1);
+      eval_divide(b, ui_type(0));
+      if (is_neg)
+         b.negate();
+      return;
+   }
+   //
+   // Grab all the leading digits before the decimal point:
+   //
+   while (std::isdigit(*p))
+   {
+      eval_multiply(b, ten);
+      eval_add(b, ui_type(*p - '0'));
+      ++p;
+      ++digits_seen;
+   }
+   if (*p == '.')
+   {
+      //
+      // Grab everything after the point, stop when we've seen
+      // enough digits, even if there are actually more available:
+      //
+      ++p;
+      while (std::isdigit(*p))
+      {
+         eval_multiply(b, ten);
+         eval_add(b, ui_type(*p - '0'));
+         ++p;
+         --expon;
+         if (++digits_seen > max_digits)
+            break;
+      }
+      while (std::isdigit(*p))
+         ++p;
+   }
+   //
+   // Parse the exponent:
+   //
+   if ((*p == 'e') || (*p == 'E'))
+   {
+      ++p;
+      if (*p == '+')
+         ++p;
+      else if (*p == '-')
+      {
+         is_neg_expon = true;
+         ++p;
+      }
+      typename Backend::exponent_type e2 = 0;
+      while (std::isdigit(*p))
+      {
+         e2 *= 10;
+         e2 += (*p - '0');
+         ++p;
+      }
+      if (is_neg_expon)
+         e2 = -e2;
+      expon += e2;
+   }
+   if (expon)
+   {
+      // Scale by 10^expon, note that 10^expon can be
+      // outside the range of our number type, even though the
+      // result is within range, if that looks likely, then split
+      // the calculation in two:
+      Backend t;
+      t = ten;
+      if (expon > limits::min_exponent10 + 2)
+      {
+         eval_pow(t, t, expon);
+         eval_multiply(b, t);
+      }
+      else
+      {
+         eval_pow(t, t, expon + digits_seen + 1);
+         eval_multiply(b, t);
+         t = ten;
+         eval_pow(t, t, -digits_seen - 1);
+         eval_multiply(b, t);
+      }
+   }
+   if (is_neg)
+      b.negate();
+   if (*p)
+   {
+      // Unexpected input in string:
+      BOOST_MP_THROW_EXCEPTION(std::runtime_error("Unexpected characters in string being interpreted as a float128."));
+   }
+}
+
+}}} // namespace boost::multiprecision::detail
+
+#endif

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

@@ -0,0 +1,101 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2022 Matt Borland. 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_FPCLASSIFY_HPP
+#define BOOST_MP_DETAIL_FPCLASSIFY_HPP
+
+#include <cmath>
+#include <limits>
+#include <type_traits>
+#include <boost/multiprecision/detail/standalone_config.hpp>
+#include <boost/multiprecision/detail/float128_functions.hpp>
+
+#ifdef BOOST_MP_MATH_AVAILABLE
+#include <boost/math/special_functions/fpclassify.hpp>
+
+#define BOOST_MP_ISNAN(x) (boost::math::isnan)(x)
+#define BOOST_MP_ISINF(x) (boost::math::isinf)(x)
+#define BOOST_MP_FPCLASSIFY(x) (boost::math::fpclassify)(x)
+#define BOOST_MP_ISFINITE(x) (!(boost::math::isnan)(x) && !(boost::math::isinf)(x))
+
+#else
+
+namespace boost { namespace multiprecision { namespace detail {
+
+template <typename T, typename std::enable_if<std::is_floating_point<T>::value
+                      #ifdef BOOST_HAS_FLOAT128
+                      || std::is_same<T, float128_type>::value
+                      #endif
+                      , bool>::type = true>
+inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
+{
+    BOOST_MP_FLOAT128_USING;
+    using std::isnan;
+    return static_cast<bool>((isnan)(x));
+}
+
+template <typename T, typename std::enable_if<!std::is_floating_point<T>::value
+                      #ifdef BOOST_HAS_FLOAT128
+                      && !std::is_same<T, float128_type>::value
+                      #endif
+                      , bool>::type = true>
+inline bool isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
+{
+    return x != x;
+}
+
+template <typename T, typename std::enable_if<std::is_floating_point<T>::value
+                      #ifdef BOOST_HAS_FLOAT128
+                      || std::is_same<T, float128_type>::value
+                      #endif
+                      , bool>::type = true>
+inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
+{
+    BOOST_MP_FLOAT128_USING;
+    using std::isinf;
+    return static_cast<bool>((isinf)(x));
+}
+
+template <typename T, typename std::enable_if<!std::is_floating_point<T>::value
+                      #ifdef BOOST_HAS_FLOAT128
+                      && !std::is_same<T, float128_type>::value
+                      #endif
+                      , bool>::type = true>
+inline bool isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
+{
+    return x == std::numeric_limits<T>::infinity() || x == -std::numeric_limits<T>::infinity();
+}
+
+template <typename T, typename std::enable_if<std::is_floating_point<T>::value, bool>::type = true>
+inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
+{
+    using std::fpclassify;
+    return fpclassify(x);
+}
+
+template <typename T, typename std::enable_if<!std::is_floating_point<T>::value, bool>::type = true>
+inline int fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const T x)
+{
+    BOOST_MP_FLOAT128_USING;
+    using std::isnan;
+    using std::isinf;
+    using std::abs;
+
+    return (isnan)(x) ? FP_NAN :
+           (isinf)(x) ? FP_INFINITE :
+           abs(x) == T(0) ? FP_ZERO :
+           abs(x) > 0 && abs(x) < (std::numeric_limits<T>::min)() ? FP_SUBNORMAL : FP_NORMAL;
+}
+
+}}} // Namespace boost::multiprecision::detail
+
+#define BOOST_MP_ISNAN(x) (boost::multiprecision::detail::isnan)(x)
+#define BOOST_MP_ISINF(x) (boost::multiprecision::detail::isinf)(x)
+#define BOOST_MP_FPCLASSIFY(x) (boost::multiprecision::detail::fpclassify)(x)
+#define BOOST_MP_ISFINITE(x) (!(boost::multiprecision::detail::isnan)(x) && !(boost::multiprecision::detail::isinf)(x))
+
+#endif
+
+#endif // BOOST_MP_DETAIL_FPCLASSIFY_HPP