passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/random/beta_distribution.hpp

@@ -13,9 +13,9 @@
 #ifndef BOOST_RANDOM_BETA_DISTRIBUTION_HPP
 #define BOOST_RANDOM_BETA_DISTRIBUTION_HPP
 
-#include <cassert>
 #include <istream>
 #include <iosfwd>
+#include <boost/assert.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/gamma_distribution.hpp>
 
@@ -48,8 +48,8 @@ public:
                             RealType beta_arg = RealType(1.0))
           : _alpha(alpha_arg), _beta(beta_arg)
         {
-            assert(alpha_arg > 0);
-            assert(beta_arg > 0);
+            BOOST_ASSERT(alpha_arg > 0);
+            BOOST_ASSERT(beta_arg > 0);
         }
 
         /** Returns the "alpha" parameter of the distribtuion. */
@@ -86,8 +86,8 @@ public:
                                RealType beta_arg = RealType(1.0))
       : _alpha(alpha_arg), _beta(beta_arg)
     {
-        assert(alpha_arg > 0);
-        assert(beta_arg > 0);
+        BOOST_ASSERT(alpha_arg > 0);
+        BOOST_ASSERT(beta_arg > 0);
     }
     /** Constructs an @c beta_distribution from its parameters. */
     explicit beta_distribution(const param_type& parm)

data/src/cxx_supportlib/vendor-modified/boost/random/hyperexponential_distribution.hpp

@@ -18,6 +18,7 @@
 #define BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP
 
 
+#include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/core/cmath.hpp>
 #include <boost/random/detail/operators.hpp>
@@ -28,7 +29,6 @@
 #include <boost/range/end.hpp>
 #include <boost/range/size.hpp>
 #include <boost/type_traits/has_pre_increment.hpp>
-#include <cassert>
 #include <cmath>
 #include <cstddef>
 #include <iterator>
@@ -266,7 +266,7 @@ class hyperexponential_distribution
         {
             hyperexp_detail::normalize(probs_);
 
-            assert( hyperexp_detail::check_params(probs_, rates_) );
+            BOOST_ASSERT( hyperexp_detail::check_params(probs_, rates_) );
         }
 
         /**
@@ -299,7 +299,7 @@ class hyperexponential_distribution
         {
             hyperexp_detail::normalize(probs_);
 
-            assert( hyperexp_detail::check_params(probs_, rates_) );
+            BOOST_ASSERT( hyperexp_detail::check_params(probs_, rates_) );
         }
 
         /**
@@ -336,7 +336,7 @@ class hyperexponential_distribution
         : probs_(std::distance(rate_first, rate_last), 1), // will be normalized below
           rates_(rate_first, rate_last)
         {
-            assert(probs_.size() == rates_.size());
+            BOOST_ASSERT(probs_.size() == rates_.size());
         }
 
         /**
@@ -360,7 +360,7 @@ class hyperexponential_distribution
         {
             hyperexp_detail::normalize(probs_);
 
-            assert( hyperexp_detail::check_params(probs_, rates_) );
+            BOOST_ASSERT( hyperexp_detail::check_params(probs_, rates_) );
         }
 
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
@@ -387,7 +387,7 @@ class hyperexponential_distribution
         {
             hyperexp_detail::normalize(probs_);
 
-            assert( hyperexp_detail::check_params(probs_, rates_) );
+            BOOST_ASSERT( hyperexp_detail::check_params(probs_, rates_) );
         }
 
         /**
@@ -413,7 +413,7 @@ class hyperexponential_distribution
         {
             hyperexp_detail::normalize(probs_);
 
-            assert( hyperexp_detail::check_params(probs_, rates_) );
+            BOOST_ASSERT( hyperexp_detail::check_params(probs_, rates_) );
         }
 #endif // BOOST_NO_CXX11_HDR_INITIALIZER_LIST
 
@@ -518,7 +518,7 @@ class hyperexponential_distribution
             hyperexp_detail::normalize(param.probs_);
 
             //post: vector size conformance
-            assert(param.probs_.size() == param.rates_.size());
+            BOOST_ASSERT(param.probs_.size() == param.rates_.size());
 
             return is;
         }
@@ -578,7 +578,7 @@ class hyperexponential_distribution
     : dd_(prob_first, prob_last),
       rates_(rate_first, rate_last)
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 
     /**
@@ -610,7 +610,7 @@ class hyperexponential_distribution
     : dd_(prob_range),
       rates_(boost::begin(rate_range), boost::end(rate_range))
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 
     /**
@@ -648,7 +648,7 @@ class hyperexponential_distribution
     : dd_(std::vector<RealT>(std::distance(rate_first, rate_last), 1)),
       rates_(rate_first, rate_last)
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 
     /**
@@ -670,7 +670,7 @@ class hyperexponential_distribution
     : dd_(std::vector<RealT>(boost::size(rate_range), 1)),
       rates_(boost::begin(rate_range), boost::end(rate_range))
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 
     /**
@@ -682,7 +682,7 @@ class hyperexponential_distribution
     : dd_(param.probabilities()),
       rates_(param.rates())
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
@@ -708,7 +708,7 @@ class hyperexponential_distribution
     : dd_(l1.begin(), l1.end()),
       rates_(l2.begin(), l2.end())
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 
     /**
@@ -733,7 +733,7 @@ class hyperexponential_distribution
     : dd_(std::vector<RealT>(std::distance(l1.begin(), l1.end()), 1)),
       rates_(l1.begin(), l1.end())
     {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+        BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/random/inversive_congruential.hpp

@@ -129,7 +129,7 @@ public:
             _value = x0 % modulus;
         }
         // handle negative seeds
-        if(_value <= 0 && _value != 0) {
+        if(_value < 0) {
             _value += modulus;
         }
         // adjust to the correct range

data/src/cxx_supportlib/vendor-modified/boost/random/splitmix64.hpp

@@ -0,0 +1,203 @@
+/* 
+ * Copyright Sebastiano Vigna 2015.
+ * Copyright Matt Borland 2022.
+ * 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_RANDOM_SPLITMIX64_HPP
+#define BOOST_RANDOM_SPLITMIX64_HPP
+
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include <array>
+#include <string>
+#include <ios>
+#include <type_traits>
+
+namespace boost { namespace random {
+
+/**
+ *  This is a fixed-increment version of Java 8's SplittableRandom generator
+ *  See http://dx.doi.org/10.1145/2714064.2660195 and
+ *  http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html
+ *  It is a very fast generator passing BigCrush, and it can be useful if
+ *  for some reason you absolutely want 64 bits of state; otherwise, we
+ *  rather suggest to use a xoroshiro128+ (for moderately parallel
+ *  computations) or xorshift1024* (for massively parallel computations)
+ *  generator.
+ */
+class splitmix64
+{
+private:
+    std::uint64_t state_;
+
+    inline std::uint64_t concatenate(std::uint32_t word1, std::uint32_t word2) noexcept
+    {
+        return static_cast<std::uint64_t>(word1) << 32 | word2;
+    }
+
+public:
+    using result_type = std::uint64_t;
+    using seed_type = std::uint64_t;
+
+    // Required for old Boost.Random concept
+    static constexpr bool has_fixed_range {false};
+
+    /** Seeds the generator with the default seed. */
+    void seed(result_type value = 0) noexcept
+    {
+        if (value == 0)
+        {
+            state_ = UINT64_C(0xA164B43C8F634A13);
+        }
+        else
+        {
+            state_ = value;
+        }
+    }
+
+    /**
+     * Seeds the generator with 32-bit values produced by @c seq.generate().
+     */
+    template <typename Sseq, typename std::enable_if<!std::is_convertible<Sseq, std::uint64_t>::value, bool>::type = true>
+    void seed(Sseq& seq)
+    {
+        std::array<std::uint32_t, 2> seeds;
+        seq.generate(seeds.begin(), seeds.end());
+
+        state_ = concatenate(seeds[0], seeds[1]);
+    }
+
+    /**
+     * Seeds the generator with 64-bit values produced by @c seq.generate().
+     */
+    template <typename Sseq, typename std::enable_if<!std::is_convertible<Sseq, splitmix64>::value, bool>::type = true>
+    explicit splitmix64(Sseq& seq)
+    {
+        seed(seq);
+    }
+
+    /** Seeds the generator with a user provided seed. */
+    template <typename T, typename std::enable_if<std::is_convertible<T, std::uint64_t>::value, bool>::type = true>
+    void seed(T value = 0) noexcept
+    {
+        seed(static_cast<std::uint64_t>(value));
+    }
+
+    /** Seeds the generator with a user provided seed. */
+    explicit splitmix64(std::uint64_t state = 0) noexcept
+    {
+        seed(state);
+    }
+
+    splitmix64(const splitmix64& other) = default;
+    splitmix64& operator=(const splitmix64& other) = default;
+
+    /**  Returns the next value of the generator. */
+    inline result_type next() noexcept
+    {
+        std::uint64_t z {state_ += UINT64_C(0x9E3779B97F4A7C15)};
+	    z = (z ^ (z >> 30)) * UINT64_C(0xBF58476D1CE4E5B9);
+	    z = (z ^ (z >> 27)) * UINT64_C(0x94D049BB133111EB);
+	    
+        return z ^ (z >> 31);
+    }
+
+    /**  Returns the next value of the generator. */
+    inline result_type operator()() noexcept
+    {
+        return next();
+    }
+
+    /** Advances the state of the generator by @c z. */
+    inline void discard(std::uint64_t z) noexcept
+    {
+        for (std::uint64_t i {}; i < z; ++i)
+        {
+            next();
+        }
+    }
+
+    /**
+     * Returns true if the two generators will produce identical
+     * sequences of values.
+     */
+    inline friend bool operator==(const splitmix64& lhs, const splitmix64& rhs) noexcept
+    {
+        return lhs.state_ == rhs.state_;
+    }
+
+    /**
+     * Returns true if the two generators will produce different
+     * sequences of values.
+     */
+    inline friend bool operator!=(const splitmix64& lhs, const splitmix64& rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /**  Writes a @c splitmix64 to a @c std::ostream. */
+    template <typename CharT, typename Traits>
+    inline friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& ost, 
+                                                               const splitmix64& e)
+    {
+        ost << e.state_;
+        return ost;
+    }
+
+    /**  Writes a @c splitmix64 to a @c std::istream. */
+    template <typename CharT, typename Traits>
+    inline friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& ist,
+                                                               splitmix64& e)
+    {
+        std::string sstate;
+        CharT val;
+        while (ist >> val)
+        {
+            if (std::isdigit(val))
+            {
+                sstate.push_back(val);
+            }
+        }
+        
+        e.state_ = std::strtoull(sstate.c_str(), nullptr, 10);
+
+        return ist;
+    }
+
+    /** Fills a range with random values */
+    template <typename FIter>
+    inline void generate(FIter first, FIter last) noexcept
+    {
+        while (first != last)
+        {
+            *first++ = next();
+        }
+    }
+
+    /**
+     * Returns the largest value that the @c splitmix64
+     * can produce.
+     */
+    static constexpr result_type (max)() noexcept
+    {
+        return (std::numeric_limits<std::uint64_t>::max)();
+    }
+
+    /**
+     * Returns the smallest value that the @c splitmix64
+     * can produce.
+     */
+    static constexpr result_type (min)() noexcept
+    {
+        return (std::numeric_limits<std::uint64_t>::min)();
+    }
+};
+
+}} // Namespace boost::random
+
+#endif // BOOST_RANDOM_SPLITMIX64_HPP

data/src/cxx_supportlib/vendor-modified/boost/random/subtract_with_carry.hpp

@@ -244,10 +244,10 @@ public:
      * Returns true if the two generators will produce identical
      * sequences of values.
      */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_engine, x, y)
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_engine, x_, y)
     {
         for(unsigned int j = 0; j < r; ++j)
-            if(x.compute(j) != y.compute(j))
+            if(x_.compute(j) != y.compute(j))
                 return false;
         return true;
     }
@@ -268,21 +268,21 @@ private:
 
     friend struct detail::subtract_with_carry_discard;
 
-    IntType do_update(std::size_t current, std::size_t short_index, IntType carry)
+    IntType do_update(std::size_t current, std::size_t short_index, IntType carry_)
     {
         IntType delta;
-        IntType temp = x[current] + carry;
+        IntType temp = x[current] + carry_;
         if (x[short_index] >= temp) {
             // x(n) >= 0
             delta =  x[short_index] - temp;
-            carry = 0;
+            carry_ = 0;
         } else {
             // x(n) < 0
             delta = modulus - temp + x[short_index];
-            carry = 1;
+            carry_ = 1;
         }
         x[current] = delta;
-        return carry;
+        return carry_;
     }
     /// \endcond
 
@@ -478,10 +478,10 @@ public:
     }
 
     /** Returns true if the two generators will produce identical sequences. */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_01_engine, x, y)
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_01_engine, x_, y)
     {
         for(unsigned int j = 0; j < r; ++j)
-            if(x.compute(j) != y.compute(j))
+            if(x_.compute(j) != y.compute(j))
                 return false;
         return true;
     }
@@ -498,17 +498,17 @@ private:
 
     friend struct detail::subtract_with_carry_discard;
 
-    RealType do_update(std::size_t current, std::size_t short_index, RealType carry)
+    RealType do_update(std::size_t current, std::size_t short_index, RealType carry_)
     {
-        RealType delta = x[short_index] - x[current] - carry;
+        RealType delta = x[short_index] - x[current] - carry_;
         if(delta < 0) {
             delta += RealType(1);
-            carry = RealType(1)/_modulus;
+            carry_ = RealType(1)/_modulus;
         } else {
-            carry = 0;
+            carry_ = 0;
         }
         x[current] = delta;
-        return carry;
+        return carry_;
     }
     /// \endcond
     std::size_t k;

data/src/cxx_supportlib/vendor-modified/boost/random/uniform_real_distribution.hpp

@@ -95,7 +95,7 @@ public:
         /**
          * Constructs the parameters of a uniform_real_distribution.
          *
-         * Requires min <= max
+         * Requires min < max
          */
         explicit param_type(RealType min_arg = RealType(0.0),
                             RealType max_arg = RealType(1.0))
@@ -148,7 +148,7 @@ public:
      * Constructs a uniform_real_distribution. @c min and @c max are
      * the parameters of the distribution.
      *
-     * Requires: min <= max
+     * Requires: min < max
      */
     explicit uniform_real_distribution(
         RealType min_arg = RealType(0.0),

data/src/cxx_supportlib/vendor-modified/boost/random.hpp

@@ -48,6 +48,7 @@
 #include <boost/random/subtract_with_carry.hpp>
 #include <boost/random/taus88.hpp>
 #include <boost/random/xor_combine.hpp>
+#include <boost/random/splitmix64.hpp>
 
 // misc
 #include <boost/random/generate_canonical.hpp>

data/src/cxx_supportlib/vendor-modified/boost/ratio/config.hpp

@@ -9,88 +9,10 @@
 #ifndef BOOST_RATIO_CONFIG_HPP
 #define BOOST_RATIO_CONFIG_HPP
 
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
+// This header is no longer useful and is only retained for compatibility
 
+#include <cstdint>
 
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  if ! defined BOOST_NO_CXX11_U16STRING
-#    define BOOST_NO_CXX11_U16STRING
-#  endif
-#  if ! defined BOOST_NO_CXX11_U32STRING
-#    define BOOST_NO_CXX11_U32STRING
-#  endif
-#endif
+#define BOOST_RATIO_INTMAX_C INTMAX_C
 
-
-#if !defined BOOST_RATIO_VERSION
-#define BOOST_RATIO_VERSION 1
-#else
-#if BOOST_RATIO_VERSION!=1  && BOOST_RATIO_VERSION!=2
-#error "BOOST_RATIO_VERSION must be 1 or 2"
-#endif
-#endif
-
-#if BOOST_RATIO_VERSION==1
-#if ! defined BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
-#define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
-#endif
-#endif
-
-#if BOOST_RATIO_VERSION==2
-#if ! defined BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
-#define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
-#endif
-#endif
-
-#ifdef INTMAX_C
-#define BOOST_RATIO_INTMAX_C(a) INTMAX_C(a)
-#elif __cplusplus >= 201103L
-#define BOOST_RATIO_INTMAX_C(a) a##LL
-#else
-#define BOOST_RATIO_INTMAX_C(a) a##L
-#endif
-
-#ifdef UINTMAX_C
-#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
-#elif __cplusplus >= 201103L
-#define BOOST_RATIO_UINTMAX_C(a) a##ULL
-#else
-#define BOOST_RATIO_UINTMAX_C(a) a##UL
-#endif
-
-#define BOOST_RATIO_INTMAX_T_MAX (0x7FFFFFFFFFFFFFFELL)
-
-
-#ifndef BOOST_NO_CXX11_STATIC_ASSERT
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
-#elif defined(BOOST_RATIO_USES_STATIC_ASSERT)
-#include <boost/static_assert.hpp>
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
-#elif defined(BOOST_RATIO_USES_MPL_ASSERT)
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)                                 \
-    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
-#else
-//~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT)
-#define BOOST_RATIO_CONCAT(A,B) A##B
-#define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B)
-#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1]
-//~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
-#endif
-
-#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT)
-#define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add"
-#define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub"
-#define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul"
-#define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div"
-#define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
-#define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0"
-#define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
-#endif
-
-
-//#define BOOST_RATIO_EXTENSIONS
-
-#endif  // header
+#endif  // #ifndef BOOST_RATIO_CONFIG_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/detail/gcd_lcm.hpp

@@ -0,0 +1,53 @@
+#ifndef BOOST_RATIO_DETAIL_GCD_LCM_HPP
+#define BOOST_RATIO_DETAIL_GCD_LCM_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+#include <cstdint>
+
+namespace boost
+{
+namespace ratio_detail
+{
+
+template<std::intmax_t A> struct abs_: std::integral_constant<std::intmax_t, A < 0? -A: A>
+{
+};
+
+template<> struct abs_<INTMAX_MIN>: std::integral_constant<std::intmax_t, INTMAX_MIN>
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct gcd_: public gcd_<B, A % B>
+{
+};
+
+template<std::intmax_t A> struct gcd_<A, 0>: std::integral_constant<std::intmax_t, A>
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct lcm_: std::integral_constant<std::intmax_t, (A / gcd_<A, B>::value) * B>
+{
+};
+
+template<> struct lcm_<0, 0>: std::integral_constant<std::intmax_t, 0>
+{
+};
+
+//
+
+template<std::intmax_t A, std::intmax_t B> struct gcd: abs_< gcd_<A, B>::value >
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct lcm: abs_< lcm_<A, B>::value >
+{
+};
+
+} // namespace ratio_detail
+} // namespace boost
+
+#endif // BOOST_RATIO_DETAIL_GCD_LCM_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/detail/is_evenly_divisible_by.hpp

@@ -0,0 +1,32 @@
+#ifndef BOOST_RATIO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP
+#define BOOST_RATIO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+#include <cstdint>
+
+namespace boost
+{
+namespace ratio_detail
+{
+
+template<std::intmax_t A, std::intmax_t B> struct is_evenly_divisible_by_: std::integral_constant<bool, A % B == 0>
+{
+};
+
+template<std::intmax_t A> struct is_evenly_divisible_by_<A, 0>: std::false_type
+{
+};
+
+template<class R1, class R2> struct is_evenly_divisible_by: std::integral_constant<bool,
+    is_evenly_divisible_by_<R1::num, R2::num>::value && is_evenly_divisible_by_<R2::den, R1::den>::value>
+{
+};
+
+} // namespace ratio_detail
+} // namespace boost
+
+#endif // BOOST_RATIO_DETAIL_IS_EVENLY_DIVISIBLE_BY_HPP

data/src/cxx_supportlib/vendor-modified/boost/ratio/detail/is_ratio.hpp

@@ -0,0 +1,28 @@
+#ifndef BOOST_RATIO_DETAIL_IS_RATIO_HPP
+#define BOOST_RATIO_DETAIL_IS_RATIO_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/ratio/ratio_fwd.hpp>
+#include <type_traits>
+#include <cstdint>
+
+namespace boost
+{
+namespace ratio_detail
+{
+
+template<class T> struct is_ratio: std::false_type
+{
+};
+
+template<std::intmax_t A, std::intmax_t B> struct is_ratio< boost::ratio<A, B> >: std::true_type
+{
+};
+
+} // namespace ratio_detail
+} // namespace boost
+
+#endif // BOOST_RATIO_DETAIL_IS_RATIO_HPP