passenger 6.1.0 → 6.1.1

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

@@ -0,0 +1,339 @@
+/* boost random/generalized_inverse_gaussian_distribution.hpp header file
+ * 
+ * Copyright Young Geun Kim 2025
+ * 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)
+ * 
+ * See http://www.boost.org for most recent version including documentation.
+ * 
+ * $Id$
+ */
+
+#ifndef BOOST_GENERALIZED_RANDOM_INVERSE_GAUSSIAN_DISTRIBUTION_HPP
+#define BOOST_GENERALIZED_RANDOM_INVERSE_GAUSSIAN_DISTRIBUTION_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <istream>
+#include <iosfwd>
+#include <limits>
+#include <boost/assert.hpp>
+#include <boost/limits.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/uniform_01.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * The generalized inverse gaussian distribution is a real-valued distribution with
+ * three parameters p, a, and b. It produced values > 0.
+ * 
+ * It has
+ * \f$\displaystyle p(x) = \frac{(a / b)^{p / 2}}{2 K_{p}(\sqrt{a b})} x^{p - 1} e^{-(a x + b / 2) / 2}\f$.
+ * where \f$\displaystyle K_{p}\f$ is a modified Bessel function of the second kind.
+ * 
+ * The algorithm used is from
+ * 
+ * @blockquote
+ * "Random variate generation for the generalized inverse Gaussian distribution",
+ * Luc Devroye,
+ * Statistics and Computing,
+ * Volume 24, 2014, Pages 236 - 246
+ * @endblockquote
+ */
+template<class RealType = double>
+class generalized_inverse_gaussian_distribution
+{
+public:
+	typedef RealType result_type;
+	typedef RealType input_type;
+
+	class param_type {
+	public:
+		typedef generalized_inverse_gaussian_distribution distribution_type;
+
+		/**
+		 * Constructs a @c param_type object from the "p", "a", and "b"
+		 * parameters.
+		 *
+		 * Requires:
+			 * a > 0 && b >= 0 if p > 0,
+			 * a > 0 && b > 0 if p == 0,
+			 * a >= 0 && b > 0 if p < 0
+		 */
+		explicit param_type(RealType p_arg = RealType(1.0),
+		                   	RealType a_arg = RealType(1.0),
+							RealType b_arg = RealType(1.0))
+		: _p(p_arg), _a(a_arg), _b(b_arg)
+		{
+			BOOST_ASSERT(
+				(p_arg > RealType(0) && a_arg > RealType(0) && b_arg >= RealType(0)) ||
+				(p_arg == RealType(0) && a_arg > RealType(0) && b_arg > RealType(0)) ||
+				(p_arg < RealType(0) && a_arg >= RealType(0) && b_arg > RealType(0))
+			);
+		}
+
+		/** Returns the "p" parameter of the distribution. */
+		RealType p() const { return _p; }
+		/** Returns the "a" parameter of the distribution. */
+		RealType a() const { return _a; }
+		/** Returns the "b" parameter of the distribution. */
+		RealType b() const { return _b; }
+
+		/** Writes a @c param_type to a @c std::ostream. */
+		BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+		{
+			os << parm._p << ' ' << parm._a << ' ' << parm._b;
+			return os;
+		}
+
+		/** Reads a @c param_type from a @c std::istream. */
+		BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+		{
+			is >> parm._p >> std::ws >> parm._a >> std::ws >> parm._b;
+			return is;
+		}
+
+		/** Returns true if the two sets of parameters are the same. */
+		BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+		{ return lhs._p == rhs._p && lhs._a == rhs._a && lhs._b == rhs._b; }
+
+		/** Returns true if the two sets of parameters are different. */
+		BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+	private:
+		RealType _p;
+		RealType _a;
+		RealType _b;
+	};
+
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+	BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
+#endif
+
+	/**
+	 * Constructs an @c generalized_inverse_gaussian_distribution from its "p", "a", and "b" parameters.
+	 *
+	 * Requires:
+	 * a > 0 && b >= 0 if p > 0,
+	 * a > 0 && b > 0 if p == 0,
+	 * a >= 0 && b > 0 if p < 0
+	 */
+	explicit generalized_inverse_gaussian_distribution(RealType p_arg = RealType(1.0),
+                       								   RealType a_arg = RealType(1.0),
+													   RealType b_arg = RealType(1.0))
+    : _p(p_arg), _a(a_arg), _b(b_arg)
+	{
+		BOOST_ASSERT(
+			(p_arg > RealType(0) && a_arg > RealType(0) && b_arg >= RealType(0)) ||
+			(p_arg == RealType(0) && a_arg > RealType(0) && b_arg > RealType(0)) ||
+			(p_arg < RealType(0) && a_arg >= RealType(0) && b_arg > RealType(0))
+		);
+		init();
+	}
+	/** Constructs an @c generalized_inverse_gaussian_distribution from its parameters. */
+	explicit generalized_inverse_gaussian_distribution(const param_type& parm)
+	: _p(parm.p()), _a(parm.a()), _b(parm.b())
+	{
+		init();
+	}
+
+	/**
+	 * Returns a random variate distributed according to the
+	 * generalized inverse gaussian distribution.
+	 */
+	template<class URNG>
+	RealType operator()(URNG& urng) const
+	{
+#ifndef BOOST_NO_STDC_NAMESPACE
+		using std::sqrt;
+		using std::log;
+		using std::min;
+		using std::exp;
+		using std::cosh;
+#endif
+		RealType t = result_type(1);
+		RealType s = result_type(1);
+		RealType log_concave = -psi(result_type(1));
+		if (log_concave >= result_type(.5) && log_concave <= result_type(2)) {
+			t = result_type(1);
+		} else if (log_concave > result_type(2)) {
+			t = sqrt(result_type(2) / (_alpha + _abs_p));
+		} else if (log_concave < result_type(.5)) {
+			t = log(result_type(4) / (_alpha + result_type(2) * _abs_p));
+		}
+		log_concave = -psi(result_type(-1));
+		if (log_concave >= result_type(.5) && log_concave <= result_type(2)) {
+			s = result_type(1);
+		} else if (log_concave > result_type(2)) {
+			s = sqrt(result_type(4) / (_alpha * cosh(1) + _abs_p));
+		} else if (log_concave < result_type(.5)) {
+			s = min(result_type(1) / _abs_p, log(result_type(1) + result_type(1) / _alpha + sqrt(result_type(1) / (_alpha * _alpha) + result_type(2) / _alpha)));
+		}
+		RealType eta = -psi(t);
+		RealType zeta = -psi_deriv(t);
+		RealType theta = -psi(-s);
+		RealType xi = psi_deriv(-s);
+		RealType p = result_type(1) / xi;
+		RealType r = result_type(1) / zeta;
+		RealType t_deriv = t - r * eta;
+		RealType s_deriv = s - p * theta;
+		RealType q = t_deriv + s_deriv;
+		RealType u = result_type(0);
+		RealType v = result_type(0);
+		RealType w = result_type(0);
+		RealType cand = result_type(0);
+		do
+		{
+			u = uniform_01<RealType>()(urng);
+			v = uniform_01<RealType>()(urng);
+			w = uniform_01<RealType>()(urng);
+			if (u < q / (p + q + r)) {
+				cand = -s_deriv + q * v;
+			} else if (u < (q + r) / (p + q + r)) {
+				cand = t_deriv - r * log(v);
+			} else {
+				cand = -s_deriv + p * log(v);
+			}
+		} while (w * chi(cand, s, t, s_deriv, t_deriv, eta, zeta, theta, xi) > exp(psi(cand)));
+		cand = (_abs_p / _omega + sqrt(result_type(1) + _abs_p * _abs_p / (_omega * _omega))) * exp(cand);
+		return _p > 0 ? cand * sqrt(_b / _a) : sqrt(_b / _a) / cand;
+	}
+
+	/**
+	 * Returns a random variate distributed accordint to the beta
+	 * distribution with parameters specified by @c param.
+	 */
+	template<class URNG>
+	result_type operator()(URNG& urng, const param_type& parm) const
+	{
+		return generalized_inverse_gaussian_distribution(parm)(urng);
+	}
+
+	/** Returns the "p" parameter of the distribution. */
+	RealType p() const { return _p; }
+	/** Returns the "a" parameter of the distribution. */
+	RealType a() const { return _a; }
+	/** Returns the "b" parameter of the distribution. */
+	RealType b() const { return _b; }
+
+	/** Returns the smallest value that the distribution can produce. */
+	RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
+	{ return RealType(0.0); }
+	/** Returns the largest value that the distribution can produce. */
+	RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+	{ return (std::numeric_limits<RealType>::infinity)(); }
+
+	/** Returns the parameters of the distribution. */
+	param_type param() const { return param_type(_p, _a, _b); }
+	/** Sets the parameters of the distribution. */
+	void param(const param_type& parm)
+	{
+		_p = parm.p();
+		_a = parm.a();
+		_b = parm.b();
+		init();
+	}
+
+	/**
+	 * Effects: Subsequent uses of the distribution do not depend
+	 * on values produced by any engine prior to invoking reset.
+	 */
+	void reset() { }
+
+	/** Writes an @c generalized_inverse_gaussian_distribution to a @c std::ostream. */
+	BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, generalized_inverse_gaussian_distribution, wd)
+	{
+		os << wd.param();
+		return os;
+	}
+
+	/** Reads an @c generalized_inverse_gaussian_distribution from a @c std::istream. */
+	BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, generalized_inverse_gaussian_distribution, wd)
+	{
+		param_type parm;
+		if(is >> parm) {
+			wd.param(parm);
+		}
+		return is;
+	}
+
+	/**
+	 * Returns true if the two instances of @c generalized_inverse_gaussian_distribution will
+	 * return identical sequences of values given equal generators.
+	 */
+	BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(generalized_inverse_gaussian_distribution, lhs, rhs)
+	{ return lhs._p == rhs._p && lhs._a == rhs._a && lhs._b == rhs._b; }
+
+	/**
+	 * Returns true if the two instances of @c generalized_inverse_gaussian_distribution will
+	 * return different sequences of values given equal generators.
+	 */
+	BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(generalized_inverse_gaussian_distribution)
+
+private:
+	RealType _p;
+	RealType _a;
+	RealType _b;
+	// some data precomputed from the parameters
+	RealType _abs_p;
+	RealType _omega;
+	RealType _alpha;
+
+	/// \cond hide_private_members
+	void init()
+    {
+#ifndef BOOST_NO_STDC_NAMESPACE
+		using std::abs;
+		using std::sqrt;
+#endif
+        _abs_p = abs(_p);
+		_omega = sqrt(_a * _b); // two-parameter representation (p, omega)
+		_alpha = sqrt(_omega * _omega + _abs_p * _abs_p) - _abs_p;
+    }
+
+	result_type psi(const RealType& x) const
+	{
+#ifndef BOOST_NO_STDC_NAMESPACE
+		using std::cosh;
+		using std::exp;
+#endif
+		return -_alpha * (cosh(x) - result_type(1)) - _abs_p * (exp(x) - x - result_type(1));
+	}
+
+	result_type psi_deriv(const RealType& x) const
+	{
+#ifndef BOOST_NO_STDC_NAMESPACE
+		using std::sinh;
+		using std::exp;
+#endif
+		return -_alpha * sinh(x) - _abs_p * (exp(x) - result_type(1));
+	}
+
+	static result_type chi(const RealType& x, 
+						   const RealType& s, const RealType& t,
+						   const RealType& s_deriv, const RealType& t_deriv,
+						   const RealType& eta, const RealType& zeta, const RealType& theta, const RealType& xi)
+	{
+#ifndef BOOST_NO_STDC_NAMESPACE
+		using std::exp;
+#endif
+		if (x >= -s_deriv && x <= t_deriv) {
+			return result_type(1);
+		} else if (x > t_deriv) {
+			return exp(-eta - zeta * (x - t));
+		}
+		return exp(-theta + xi * (x + s));
+	}
+	/// \endcond
+};
+
+} // namespace random
+
+using random::generalized_inverse_gaussian_distribution;
+
+} // namespace boost
+
+#endif // BOOST_GENERALIZED_RANDOM_INVERSE_GAUSSIAN_DISTRIBUTION_HPP

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

@@ -23,11 +23,9 @@
 #include <boost/core/cmath.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/vector_io.hpp>
+#include <boost/random/detail/size.hpp>
 #include <boost/random/discrete_distribution.hpp>
 #include <boost/random/exponential_distribution.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/size.hpp>
 #include <boost/type_traits/has_pre_increment.hpp>
 #include <cmath>
 #include <cstddef>
@@ -294,8 +292,8 @@ class hyperexponential_distribution
                 param_type(ProbRangeT const& prob_range,
                            RateRangeT const& rate_range,
                            typename boost::disable_if_c<boost::has_pre_increment<ProbRangeT>::value || boost::has_pre_increment<RateRangeT>::value>::type* = 0)
-        : probs_(boost::begin(prob_range), boost::end(prob_range)),
-          rates_(boost::begin(rate_range), boost::end(rate_range))
+        : probs_(std::begin(prob_range), std::end(prob_range)),
+          rates_(std::begin(rate_range), std::end(rate_range))
         {
             hyperexp_detail::normalize(probs_);
 
@@ -330,8 +328,8 @@ class hyperexponential_distribution
         //  We SFINAE this out of existance if the argument type is
         //  incrementable as in that case the type is probably an iterator.
         public: template <typename RateIterT>
-                param_type(RateIterT rate_first, 
-                           RateIterT rate_last,  
+                param_type(RateIterT rate_first,
+                           RateIterT rate_last,
                            typename boost::enable_if_c<boost::has_pre_increment<RateIterT>::value>::type* = 0)
         : probs_(std::distance(rate_first, rate_last), 1), // will be normalized below
           rates_(rate_first, rate_last)
@@ -355,8 +353,8 @@ class hyperexponential_distribution
          */
         public: template <typename RateRangeT>
                 param_type(RateRangeT const& rate_range)
-        : probs_(boost::size(rate_range), 1), // Will be normalized below
-          rates_(boost::begin(rate_range), boost::end(rate_range))
+        : probs_(boost::random::detail::size(rate_range), 1), // Will be normalized below
+          rates_(std::begin(rate_range), std::end(rate_range))
         {
             hyperexp_detail::normalize(probs_);
 
@@ -529,7 +527,7 @@ class hyperexponential_distribution
             return lhs.probs_ == rhs.probs_
                    && lhs.rates_ == rhs.rates_;
         }
-        
+
         /** Returns true if the two sets of parameters are the different. */
         public: BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
 
@@ -608,7 +606,7 @@ class hyperexponential_distribution
                                           RateRangeT const& rate_range,
                                           typename boost::disable_if_c<boost::has_pre_increment<ProbRangeT>::value || boost::has_pre_increment<RateRangeT>::value>::type* = 0)
     : dd_(prob_range),
-      rates_(boost::begin(rate_range), boost::end(rate_range))
+      rates_(std::begin(rate_range), std::end(rate_range))
     {
         BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
@@ -667,8 +665,8 @@ class hyperexponential_distribution
      */
     public: template <typename RateRangeT>
             hyperexponential_distribution(RateRangeT const& rate_range)
-    : dd_(std::vector<RealT>(boost::size(rate_range), 1)),
-      rates_(boost::begin(rate_range), boost::end(rate_range))
+    : dd_(std::vector<RealT>(boost::random::detail::size(rate_range), 1)),
+      rates_(std::begin(rate_range), std::end(rate_range))
     {
         BOOST_ASSERT( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
     }
@@ -854,7 +852,7 @@ class hyperexponential_distribution
         return lhs.dd_ == rhs.dd_
                && lhs.rates_ == rhs.rates_;
     }
-    
+
     /**
      * Returns true if the two instances of @c hyperexponential_distribution will
      * return different sequences of values given equal generators.

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

@@ -0,0 +1,226 @@
+/* boost random/inverse_gaussian_distribution.hpp header file
+ *
+ * Copyright Young Geun Kim 2025
+ * 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)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id$
+ */
+
+#ifndef BOOST_RANDOM_INVERSE_GAUSSIAN_DISTRIBUTION_HPP
+#define BOOST_RANDOM_INVERSE_GAUSSIAN_DISTRIBUTION_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <istream>
+#include <iosfwd>
+#include <limits>
+#include <boost/assert.hpp>
+#include <boost/limits.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/uniform_01.hpp>
+#include <boost/random/chi_squared_distribution.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * The inverse gaussian distribution is a real-valued distribution with
+ * two parameters alpha (mean) and beta (shape). It produced values > 0.
+ *
+ * It has
+ * \f$\displaystyle p(x) = \sqrt{\beta / (2 \pi x^3)} \exp(-\frac{\beta (x - \alpha)^2}{2 \alpha^2 x})$.
+ *
+ * The algorithm used is from
+ *
+ * @blockquote
+ * "Generating Random Variates Using Transformations with Multiple Roots",
+ * Michael, J. R., Schucany, W. R. and Haas, R. W.,
+ * The American Statistician,
+ * Volume 30, Issue 2, 1976, Pages 88 - 90
+ * @endblockquote
+ */
+template<class RealType = double>
+class inverse_gaussian_distribution
+{
+public:
+	typedef RealType result_type;
+    typedef RealType input_type;
+
+	class param_type {
+	public:
+		typedef inverse_gaussian_distribution distribution_type;
+
+		/**
+		 * Constructs a @c param_type object from the "alpha" and "beta"
+         * parameters.
+         *
+         * Requires: alpha > 0 && beta > 0
+		 */
+		explicit param_type(RealType alpha_arg = RealType(1.0),
+											 RealType beta_arg = RealType(1.0))
+			: _alpha(alpha_arg), _beta(beta_arg)
+		{
+			BOOST_ASSERT(alpha_arg > 0);
+			BOOST_ASSERT(beta_arg > 0);
+		}
+
+    	/** Returns the "alpha" parameter of the distribution. */
+        RealType alpha() const { return _alpha; }
+        /** Returns the "beta" parameter of the distribution. */
+        RealType beta() const { return _beta; }
+
+    	/** Writes a @c param_type to a @c std::ostream. */
+        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+        { os << parm._alpha << ' ' << parm._beta; return os; }
+
+        /** Reads a @c param_type from a @c std::istream. */
+        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+        { is >> parm._alpha >> std::ws >> parm._beta; return is; }
+
+    	/** Returns true if the two sets of parameters are the same. */
+        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        { return lhs._alpha == rhs._alpha && lhs._beta == rhs._beta; }
+
+        /** Returns true if the two sets fo parameters are different. */
+        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+    	private:
+    		RealType _alpha;
+    		RealType _beta;
+	};
+
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
+#endif
+
+	/**
+     * Constructs an @c inverse_gaussian_distribution from its "alpha" and "beta" parameters.
+     *
+     * Requires: alpha > 0, beta > 0
+     */
+	explicit inverse_gaussian_distribution(RealType alpha_arg = RealType(1.0),
+											 									 RealType beta_arg = RealType(1.0))
+		: _alpha(alpha_arg), _beta(beta_arg)
+	{
+		BOOST_ASSERT(alpha_arg > 0);
+		BOOST_ASSERT(beta_arg > 0);
+		init();
+	}
+
+	/** Constructs an @c inverse_gaussian_distribution from its parameters. */
+	explicit inverse_gaussian_distribution(const param_type& parm)
+		: _alpha(parm.alpha()), _beta(parm.beta())
+	{
+		init();
+	}
+
+	/**
+     * Returns a random variate distributed according to the
+     * inverse gaussian distribution.
+     */
+    template<class URNG>
+    RealType operator()(URNG& urng) const
+    {
+#ifndef BOOST_NO_STDC_NAMESPACE
+		using std::sqrt;
+#endif
+		RealType w = _alpha * chi_squared_distribution<RealType>(result_type(1))(urng);
+		RealType cand = _alpha + _c * (w - sqrt(w * (result_type(4) * _beta + w)));
+		RealType u = uniform_01<RealType>()(urng);
+		if (u < _alpha / (_alpha + cand)) {
+			return cand;
+		}
+    return _alpha * _alpha / cand;
+    }
+
+    /**
+     * Returns a random variate distributed accordint to the beta
+     * distribution with parameters specified by @c param.
+     */
+    template<class URNG>
+    RealType operator()(URNG& urng, const param_type& parm) const
+    {
+        return inverse_gaussian_distribution(parm)(urng);
+    }
+
+	/** Returns the "alpha" parameter of the distribution. */
+    RealType alpha() const { return _alpha; }
+    /** Returns the "beta" parameter of the distribution. */
+    RealType beta() const { return _beta; }
+
+	/** Returns the smallest value that the distribution can produce. */
+    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    { return RealType(0.0); }
+    /** Returns the largest value that the distribution can produce. */
+    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    { return (std::numeric_limits<RealType>::infinity)(); }
+
+	/** Returns the parameters of the distribution. */
+    param_type param() const { return param_type(_alpha, _beta); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm)
+    {
+        _alpha = parm.alpha();
+        _beta = parm.beta();
+		init();
+    }
+
+	/**
+     * Effects: Subsequent uses of the distribution do not depend
+     * on values produced by any engine prior to invoking reset.
+     */
+    void reset() { }
+
+	/** Writes an @c inverse_gaussian_distribution to a @c std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, inverse_gaussian_distribution, wd)
+    {
+        os << wd.param();
+        return os;
+    }
+
+    /** Reads an @c inverse_gaussian_distribution from a @c std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, inverse_gaussian_distribution, wd)
+    {
+        param_type parm;
+        if(is >> parm) {
+            wd.param(parm);
+        }
+        return is;
+    }
+
+	/**
+     * Returns true if the two instances of @c inverse_gaussian_distribution will
+     * return identical sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(inverse_gaussian_distribution, lhs, rhs)
+    { return lhs._alpha == rhs._alpha && lhs._beta == rhs._beta; }
+
+    /**
+     * Returns true if the two instances of @c inverse_gaussian_distribution will
+     * return different sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(inverse_gaussian_distribution)
+
+private:
+	result_type _alpha;
+	result_type _beta;
+	// some data precomputed from the parameters
+	result_type _c;
+
+	void init()
+    {
+		_c = _alpha / (result_type(2) * _beta);
+    }
+};
+
+} // namespace random
+
+using random::inverse_gaussian_distribution;
+
+} // namespace boost
+
+#endif // BOOST_RANDOM_INVERSE_GAUSSIAN_DISTRIBUTION_HPP

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

@@ -434,10 +434,7 @@ private:
         // already know what they are.
         for(std::size_t j = 0; j < num_bits; ++j) {
             if(tmp.i >= n) tmp.twist();
-            if(j == num_bits - 1)
-                assert((tmp.x[tmp.i] & 1) == 1);
-            else
-                assert((tmp.x[tmp.i] & 1) == 0);
+            assert((tmp.x[tmp.i] & 1) == (j == num_bits - 1));
             ++tmp.i;
         }
         detail::polynomial phi;