passenger 5.1.12 → 5.2.0

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

@@ -0,0 +1,96 @@
+/* boost random/generate_canonical.hpp header file
+ *
+ * Copyright Steven Watanabe 2011
+ * 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_GENERATE_CANONICAL_HPP
+#define BOOST_RANDOM_GENERATE_CANONICAL_HPP
+
+#include <algorithm>
+#include <boost/assert.hpp>
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/limits.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/random/detail/signed_unsigned_tools.hpp>
+#include <boost/random/detail/generator_bits.hpp>
+
+namespace boost {
+namespace random {
+
+namespace detail {
+
+template<class RealType, std::size_t bits, class URNG>
+RealType generate_canonical_impl(URNG& g, boost::mpl::true_ /*is_integral*/)
+{
+    using std::pow;
+    typedef typename URNG::result_type base_result;
+    std::size_t digits = std::numeric_limits<RealType>::digits;
+    RealType R = RealType((g.max)()) - RealType((g.min)()) + 1;
+    RealType mult = R;
+    RealType limit =
+        pow(RealType(2),
+            RealType((std::min)(static_cast<std::size_t>(bits), digits)));
+    RealType S = RealType(detail::subtract<base_result>()(g(), (g.min)()));
+    while(mult < limit) {
+        RealType inc = RealType(detail::subtract<base_result>()(g(), (g.min)()));
+        S += inc * mult;
+        mult *= R;
+    }
+    return S / mult;
+}
+
+template<class RealType, std::size_t bits, class URNG>
+RealType generate_canonical_impl(URNG& g, boost::mpl::false_ /*is_integral*/)
+{
+    using std::pow;
+    using std::floor;
+    BOOST_ASSERT((g.min)() == 0);
+    BOOST_ASSERT((g.max)() == 1);
+    std::size_t digits = std::numeric_limits<RealType>::digits;
+    std::size_t engine_bits = detail::generator_bits<URNG>::value();
+    std::size_t b = (std::min)(bits, digits);
+    RealType R = pow(RealType(2), RealType(engine_bits));
+    RealType mult = R;
+    RealType limit = pow(RealType(2), RealType(b));
+    RealType S = RealType(g() - (g.min)());
+    while(mult < limit) {
+        RealType inc(floor((RealType(g()) - RealType((g.min)())) * R));
+        S += inc * mult;
+        mult *= R;
+    }
+    return S / mult;
+}
+
+}
+
+/**
+ * Returns a value uniformly distributed in the range [0, 1)
+ * with at least @c bits random bits.
+ */
+template<class RealType, std::size_t bits, class URNG>
+RealType generate_canonical(URNG& g)
+{
+    RealType result = detail::generate_canonical_impl<RealType, bits>(
+        g, boost::random::traits::is_integral<typename URNG::result_type>());
+    BOOST_ASSERT(result >= 0);
+    BOOST_ASSERT(result <= 1);
+    if(result == 1) {
+        result -= std::numeric_limits<RealType>::epsilon() / 2;
+        BOOST_ASSERT(result != 1);
+    }
+    return result;
+}
+
+} // namespace random
+} // namespace boost
+
+#endif // BOOST_RANDOM_GENERATE_CANONICAL_HPP

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

@@ -0,0 +1,267 @@
+/* boost random/geometric_distribution.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Copyright Steven Watanabe 2011
+ * 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$
+ *
+ * Revision history
+ *  2001-02-18  moved to individual header files
+ */
+
+#ifndef BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
+#define BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>          // std::log
+#include <iosfwd>
+#include <ios>
+#include <boost/assert.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/uniform_01.hpp>
+
+namespace boost {
+namespace random {
+
+/**
+ * An instantiation of the class template @c geometric_distribution models
+ * a \random_distribution.  The distribution produces positive
+ * integers which are the number of bernoulli trials
+ * with probability @c p required to get one that fails.
+ *
+ * For the geometric distribution, \f$p(i) = p(1-p)^{i}\f$.
+ *
+ * @xmlwarning
+ * This distribution has been updated to match the C++ standard.
+ * Its behavior has changed from the original
+ * boost::geometric_distribution.  A backwards compatible
+ * wrapper is provided in namespace boost.
+ * @endxmlwarning
+ */
+template<class IntType = int, class RealType = double>
+class geometric_distribution
+{
+public:
+    typedef RealType input_type;
+    typedef IntType result_type;
+
+    class param_type
+    {
+    public:
+
+        typedef geometric_distribution distribution_type;
+
+        /** Constructs the parameters with p. */
+        explicit param_type(RealType p_arg = RealType(0.5))
+          : _p(p_arg)
+        {
+            BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
+        }
+
+        /** Returns the p parameter of the distribution. */
+        RealType p() const { return _p; }
+
+        /** Writes the parameters to a std::ostream. */
+        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+        {
+            os << parm._p;
+            return os;
+        }
+
+        /** Reads the parameters from a std::istream. */
+        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+        {
+            double p_in;
+            if(is >> p_in) {
+                if(p_in > RealType(0) && p_in < RealType(1)) {
+                    parm._p = p_in;
+                } else {
+                    is.setstate(std::ios_base::failbit);
+                }
+            }
+            return is;
+        }
+
+        /** Returns true if the two sets of parameters are equal. */
+        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        { return lhs._p == rhs._p; }
+
+        /** Returns true if the two sets of parameters are different. */
+        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+
+    private:
+        RealType _p;
+    };
+
+    /**
+     * Contructs a new geometric_distribution with the paramter @c p.
+     *
+     * Requires: 0 < p < 1
+     */
+    explicit geometric_distribution(const RealType& p_arg = RealType(0.5))
+      : _p(p_arg)
+    {
+        BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
+        init();
+    }
+
+    /** Constructs a new geometric_distribution from its parameters. */
+    explicit geometric_distribution(const param_type& parm)
+      : _p(parm.p())
+    {
+        init();
+    }
+
+    // compiler-generated copy ctor and assignment operator are fine
+
+    /** Returns: the distribution parameter @c p  */
+    RealType p() const { return _p; }
+
+    /** Returns the smallest value that the distribution can produce. */
+    IntType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return IntType(0); }
+
+    /** Returns the largest value that the distribution can produce. */
+    IntType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    { return (std::numeric_limits<IntType>::max)(); }
+
+    /** Returns the parameters of the distribution. */
+    param_type param() const { return param_type(_p); }
+
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm)
+    {
+        _p = parm.p();
+        init();
+    }
+  
+    /**
+     * Effects: Subsequent uses of the distribution do not depend
+     * on values produced by any engine prior to invoking reset.
+     */
+    void reset() { }
+
+    /**
+     * Returns a random variate distributed according to the
+     * geometric_distribution.
+     */
+    template<class Engine>
+    result_type operator()(Engine& eng) const
+    {
+        using std::log;
+        using std::floor;
+        RealType x = RealType(1) - boost::uniform_01<RealType>()(eng);
+        return IntType(floor(log(x) / _log_1mp));
+    }
+
+    /**
+     * Returns a random variate distributed according to the
+     * geometric distribution with parameters specified by param.
+     */
+    template<class Engine>
+    result_type operator()(Engine& eng, const param_type& parm) const
+    { return geometric_distribution(parm)(eng); }
+
+    /** Writes the distribution to a @c std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, geometric_distribution, gd)
+    {
+        os << gd._p;
+        return os;
+    }
+
+    /** Reads the distribution from a @c std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, geometric_distribution, gd)
+    {
+        param_type parm;
+        if(is >> parm) {
+            gd.param(parm);
+        }
+        return is;
+    }
+
+    /**
+     * Returns true if the two distributions will produce identical
+     * sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(geometric_distribution, lhs, rhs)
+    { return lhs._p == rhs._p; }
+
+    /**
+     * Returns true if the two distributions may produce different
+     * sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(geometric_distribution)
+
+private:
+
+    /// \cond show_private
+
+    void init()
+    {
+        using std::log;
+        _log_1mp = log(1 - _p);
+    }
+
+    RealType _p;
+    RealType _log_1mp;
+
+    /// \endcond
+};
+
+} // namespace random
+
+/// \cond show_deprecated
+
+/**
+ * Provided for backwards compatibility.  This class is
+ * deprecated.  It provides the old behavior of geometric_distribution
+ * with \f$p(i) = (1-p) p^{i-1}\f$.
+ */
+template<class IntType = int, class RealType = double>
+class geometric_distribution
+{
+public:
+    typedef RealType input_type;
+    typedef IntType result_type;
+
+    explicit geometric_distribution(RealType p_arg = RealType(0.5))
+      : _impl(1 - p_arg) {}
+
+    RealType p() const { return 1 - _impl.p(); }
+
+    void reset() {}
+
+    template<class Engine>
+    IntType operator()(Engine& eng) const { return _impl(eng) + IntType(1); }
+
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, geometric_distribution, gd)
+    {
+        os << gd.p();
+        return os;
+    }
+
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, geometric_distribution, gd)
+    {
+        RealType val;
+        if(is >> val) {
+            typename impl_type::param_type impl_param(1 - val);
+            gd._impl.param(impl_param);
+        }
+        return is;
+    }
+
+private:
+    typedef random::geometric_distribution<IntType, RealType> impl_type;
+    impl_type _impl;
+};
+
+/// \endcond
+
+} // namespace boost
+
+#endif // BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP

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

@@ -0,0 +1,883 @@
+/* boost random/hyperexponential_distribution.hpp header file
+ *
+ * Copyright Marco Guazzone 2014
+ * 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.
+ *
+ * Much of the code here taken by boost::math::hyperexponential_distribution.
+ * To this end, we would like to thank Paul Bristow and John Maddock for their
+ * valuable feedback.
+ *
+ * \author Marco Guazzone (marco.guazzone@gmail.com)
+ */
+
+#ifndef BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP
+#define BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP
+
+
+#include <boost/config.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/detail/vector_io.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 <cassert>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+# include <initializer_list>
+#endif // BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <iostream>
+#include <limits>
+#include <numeric>
+#include <vector>
+
+
+namespace boost { namespace random {
+
+namespace hyperexp_detail {
+
+template <typename T>
+std::vector<T>& normalize(std::vector<T>& v)
+{
+    if (v.size() == 0)
+    {
+        return v;
+    }
+
+    const T sum = std::accumulate(v.begin(), v.end(), static_cast<T>(0));
+    T final_sum = 0;
+
+    const typename std::vector<T>::iterator end = --v.end();
+    for (typename std::vector<T>::iterator it = v.begin();
+         it != end;
+         ++it)
+    {
+        *it /= sum;
+        final_sum += *it;
+    }
+    *end = 1-final_sum; // avoids round off errors thus ensuring the probabilities really sum to 1
+
+    return v;
+}
+
+template <typename RealT>
+bool check_probabilities(std::vector<RealT> const& probabilities)
+{
+    const std::size_t n = probabilities.size();
+    RealT sum = 0;
+    for (std::size_t i = 0; i < n; ++i)
+    {
+        if (probabilities[i] < 0
+            || probabilities[i] > 1
+            || !(boost::math::isfinite)(probabilities[i]))
+        {
+            return false;
+        }
+        sum += probabilities[i];
+    }
+
+    //NOTE: the check below seems to fail on some architectures.
+    //      So we commented it.
+    //// - We try to keep phase probabilities correctly normalized in the distribution constructors
+    //// - However in practice we have to allow for a very slight divergence from a sum of exactly 1:
+    ////if (std::abs(sum-1) > (std::numeric_limits<RealT>::epsilon()*2))
+    //// This is from Knuth "The Art of Computer Programming: Vol.2, 3rd Ed", and can be used to
+    //// check is two numbers are approximately equal
+    //const RealT one = 1;
+    //const RealT tol = std::numeric_limits<RealT>::epsilon()*2.0;
+    //if (std::abs(sum-one) > (std::max(std::abs(sum), std::abs(one))*tol))
+    //{
+    //    return false;
+    //}
+
+    return true;
+}
+
+template <typename RealT>
+bool check_rates(std::vector<RealT> const& rates)
+{
+    const std::size_t n = rates.size();
+    for (std::size_t i = 0; i < n; ++i)
+    {
+        if (rates[i] <= 0
+            || !(boost::math::isfinite)(rates[i]))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+template <typename RealT>
+bool check_params(std::vector<RealT> const& probabilities, std::vector<RealT> const& rates)
+{
+    if (probabilities.size() != rates.size())
+    {
+        return false;
+    }
+
+    return check_probabilities(probabilities)
+           && check_rates(rates);
+}
+
+} // Namespace hyperexp_detail
+
+
+/**
+ * The hyperexponential distribution is a real-valued continuous distribution
+ * with two parameters, the <em>phase probability vector</em> \c probs and the
+ * <em>rate vector</em> \c rates.
+ *
+ * A \f$k\f$-phase hyperexponential distribution is a mixture of \f$k\f$
+ * exponential distributions.
+ * For this reason, it is also referred to as <em>mixed exponential
+ * distribution</em> or <em>parallel \f$k\f$-phase exponential
+ * distribution</em>.
+ *
+ * A \f$k\f$-phase hyperexponential distribution is characterized by two
+ * parameters, namely a <em>phase probability vector</em> \f$\mathbf{\alpha}=(\alpha_1,\ldots,\alpha_k)\f$ and a <em>rate vector</em> \f$\mathbf{\lambda}=(\lambda_1,\ldots,\lambda_k)\f$.
+ *
+ * A \f$k\f$-phase hyperexponential distribution is frequently used in
+ * <em>queueing theory</em> to model the distribution of the superposition of
+ * \f$k\f$ independent events, like, for instance, the  service time distribution
+ * of a queueing station with \f$k\f$ servers in parallel where the \f$i\f$-th
+ * server is chosen with probability \f$\alpha_i\f$ and its service time
+ * distribution is an exponential distribution with rate \f$\lambda_i\f$
+ * (Allen,1990; Papadopolous et al.,1993; Trivedi,2002).
+ *
+ * For instance, CPUs service-time distribution in a computing system has often
+ * been observed to possess such a distribution (Rosin,1965).
+ * Also, the arrival of different types of customer to a single queueing station
+ * is often modeled as a hyperexponential distribution (Papadopolous et al.,1993).
+ * Similarly, if a product manufactured in several parallel assemply lines and
+ * the outputs are merged, the failure density of the overall product is likely
+ * to be hyperexponential (Trivedi,2002).
+ *
+ * Finally, since the hyperexponential distribution exhibits a high Coefficient
+ * of Variation (CoV), that is a CoV > 1, it is especially suited to fit
+ * empirical data with large CoV (Feitelson,2014; Wolski et al.,2013) and to
+ * approximate <em>long-tail probability distributions</em> (Feldmann et al.,1998).
+ *
+ * See (Boost,2014) for more information and examples.
+ *
+ * A \f$k\f$-phase hyperexponential distribution has a probability density
+ * function
+ * \f[
+ *  f(x) = \sum_{i=1}^k \alpha_i \lambda_i e^{-x\lambda_i}
+ * \f]
+ * where:
+ * - \f$k\f$ is the <em>number of phases</em> and also the size of the input
+ *   vector parameters,
+ * - \f$\mathbf{\alpha}=(\alpha_1,\ldots,\alpha_k)\f$ is the <em>phase probability
+ *   vector</em> parameter, and
+ * - \f$\mathbf{\lambda}=(\lambda_1,\ldots,\lambda_k)\f$ is the <em>rate vector</em>
+ *   parameter.
+ * .
+ *
+ * Given a \f$k\f$-phase hyperexponential distribution with phase probability
+ * vector \f$\mathbf{\alpha}\f$ and rate vector \f$\mathbf{\lambda}\f$, the
+ * random variate generation algorithm consists of the following steps (Tyszer,1999):
+ * -# Generate a random variable \f$U\f$ uniformly distribution on the interval \f$(0,1)\f$.
+ * -# Use \f$U\f$ to select the appropriate \f$\lambda_i\f$ (e.g., the
+ *  <em>alias method</em> can possibly be used for this step).
+ * -# Generate an exponentially distributed random variable \f$X\f$ with rate parameter \f$\lambda_i\f$.
+ * -# Return \f$X\f$.
+ * .
+ *
+ * References:
+ * -# A.O. Allen, <em>Probability, Statistics, and Queuing Theory with Computer Science Applications, Second Edition</em>, Academic Press, 1990.
+ * -# Boost C++ Libraries, <em>Boost.Math / Statistical Distributions: Hyperexponential Distribution</em>, Online: http://www.boost.org/doc/libs/release/libs/math/doc/html/dist.html , 2014.
+ * -# D.G. Feitelson, <em>Workload Modeling for Computer Systems Performance Evaluation</em>, Cambridge University Press, 2014
+ * -# A. Feldmann and W. Whitt, <em>Fitting mixtures of exponentials to long-tail distributions to analyze network performance models</em>, Performance Evaluation 31(3-4):245, doi:10.1016/S0166-5316(97)00003-5, 1998.
+ * -# H.T. Papadopolous, C. Heavey and J. Browne, <em>Queueing Theory in Manufacturing Systems Analysis and Design</em>, Chapman & Hall/CRC, 1993, p. 35.
+ * -# R.F. Rosin, <em>Determining a computing center environment</em>, Communications of the ACM 8(7):463-468, 1965.
+ * -# K.S. Trivedi, <em>Probability and Statistics with Reliability, Queueing, and Computer Science Applications</em>, John Wiley & Sons, Inc., 2002.
+ * -# J. Tyszer, <em>Object-Oriented Computer Simulation of Discrete-Event Systems</em>, Springer, 1999.
+ * -# Wikipedia, <em>Hyperexponential Distribution</em>, Online: http://en.wikipedia.org/wiki/Hyperexponential_distribution , 2014.
+ * -# Wolfram Mathematica, <em>Hyperexponential Distribution</em>, Online: http://reference.wolfram.com/language/ref/HyperexponentialDistribution.html , 2014.
+ * .
+ *
+ * \author Marco Guazzone (marco.guazzone@gmail.com)
+ */
+template<class RealT = double>
+class hyperexponential_distribution
+{
+    public: typedef RealT result_type;
+    public: typedef RealT input_type;
+
+
+    /**
+     * The parameters of a hyperexponential distribution.
+     *
+     * Stores the <em>phase probability vector</em> and the <em>rate vector</em>
+     * of the hyperexponential distribution.
+     *
+     * \author Marco Guazzone (marco.guazzone@gmail.com)
+     */
+    public: class param_type
+    {
+        public: typedef hyperexponential_distribution distribution_type;
+
+        /**
+         * Constructs a \c param_type with the default parameters
+         * of the distribution.
+         */
+        public: param_type()
+        : probs_(1, 1),
+          rates_(1, 1)
+        {
+        }
+
+        /**
+         * Constructs a \c param_type from the <em>phase probability vector</em>
+         * and <em>rate vector</em> parameters of the distribution.
+         *
+         * The <em>phase probability vector</em> parameter is given by the range
+         * defined by [\a prob_first, \a prob_last) iterator pair, and the
+         * <em>rate vector</em> parameter is given by the range defined by
+         * [\a rate_first, \a rate_last) iterator pair.
+         *
+         * \tparam ProbIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+         * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+         *
+         * \param prob_first The iterator to the beginning of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
+         * \param prob_last The iterator to the ending of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
+         * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
+         * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
+         *
+         * References:
+         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+         * .
+         */
+        public: template <typename ProbIterT, typename RateIterT>
+                param_type(ProbIterT prob_first, ProbIterT prob_last,
+                           RateIterT rate_first, RateIterT rate_last)
+        : probs_(prob_first, prob_last),
+          rates_(rate_first, rate_last)
+        {
+            hyperexp_detail::normalize(probs_);
+
+            assert( hyperexp_detail::check_params(probs_, rates_) );
+        }
+
+        /**
+         * Constructs a \c param_type from the <em>phase probability vector</em>
+         * and <em>rate vector</em> parameters of the distribution.
+         *
+         * The <em>phase probability vector</em> parameter is given by the range
+         * defined by \a prob_range, and the <em>rate vector</em> parameter is
+         * given by the range defined by \a rate_range.
+         *
+         * \tparam ProbRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
+         * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
+         *
+         * \param prob_range The range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
+         * \param rate_range The range of positive real elements representing the rates.
+         *
+         * \note
+         *  The final \c disable_if parameter is an implementation detail that
+         *  differentiates between this two argument constructor and the
+         *  iterator-based two argument constructor described below.
+         */
+        //  We SFINAE this out of existance if either argument type is
+        //  incrementable as in that case the type is probably an iterator:
+        public: template <typename ProbRangeT, typename RateRangeT>
+                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))
+        {
+            hyperexp_detail::normalize(probs_);
+
+            assert( hyperexp_detail::check_params(probs_, rates_) );
+        }
+
+        /**
+         * Constructs a \c param_type from the <em>rate vector</em> parameter of
+         * the distribution and with equal phase probabilities.
+         *
+         * The <em>rate vector</em> parameter is given by the range defined by
+         * [\a rate_first, \a rate_last) iterator pair, and the <em>phase
+         * probability vector</em> parameter is set to the equal phase
+         * probabilities (i.e., to a vector of the same length \f$k\f$ of the
+         * <em>rate vector</em> and with each element set to \f$1.0/k\f$).
+         *
+         * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+         * \tparam RateIterT2 Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+         *
+         * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
+         * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
+         *
+         * \note
+         *  The final \c disable_if parameter is an implementation detail that
+         *  differentiates between this two argument constructor and the
+         *  range-based two argument constructor described above.
+         *
+         * References:
+         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+         * .
+         */
+        //  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,  
+                           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)
+        {
+            assert(probs_.size() == rates_.size());
+        }
+
+        /**
+         * Constructs a @c param_type from the "rates" parameters
+         * of the distribution and with equal phase probabilities.
+         *
+         * The <em>rate vector</em> parameter is given by the range defined by
+         * \a rate_range, and the <em>phase probability vector</em> parameter is
+         * set to the equal phase probabilities (i.e., to a vector of the same
+         * length \f$k\f$ of the <em>rate vector</em> and with each element set
+         * to \f$1.0/k\f$).
+         *
+         * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
+         *
+         * \param rate_range The range of positive real elements representing the rates.
+         */
+        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))
+        {
+            hyperexp_detail::normalize(probs_);
+
+            assert( hyperexp_detail::check_params(probs_, rates_) );
+        }
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+        /**
+         * Constructs a \c param_type from the <em>phase probability vector</em>
+         * and <em>rate vector</em> parameters of the distribution.
+         *
+         * The <em>phase probability vector</em> parameter is given by the
+         * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
+         * defined by \a l1, and the <em>rate vector</em> parameter is given by the
+         * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
+         * defined by \a l2.
+         *
+         * \param l1 The initializer list for inizializing the phase probability vector.
+         * \param l2 The initializer list for inizializing the rate vector.
+         *
+         * References:
+         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+         * .
+         */
+        public: param_type(std::initializer_list<RealT> l1, std::initializer_list<RealT> l2)
+        : probs_(l1.begin(), l1.end()),
+          rates_(l2.begin(), l2.end())
+        {
+            hyperexp_detail::normalize(probs_);
+
+            assert( hyperexp_detail::check_params(probs_, rates_) );
+        }
+
+        /**
+         * Constructs a \c param_type from the <em>rate vector</em> parameter
+         * of the distribution and with equal phase probabilities.
+         *
+         * The <em>rate vector</em> parameter is given by the
+         * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
+         * defined by \a l1, and the <em>phase probability vector</em> parameter is
+         * set to the equal phase probabilities (i.e., to a vector of the same
+         * length \f$k\f$ of the <em>rate vector</em> and with each element set
+         * to \f$1.0/k\f$).
+         *
+         * \param l1 The initializer list for inizializing the rate vector.
+         *
+         * References:
+         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+         * .
+         */
+        public: param_type(std::initializer_list<RealT> l1)
+        : probs_(std::distance(l1.begin(), l1.end()), 1), // Will be normalized below
+          rates_(l1.begin(), l1.end())
+        {
+            hyperexp_detail::normalize(probs_);
+
+            assert( hyperexp_detail::check_params(probs_, rates_) );
+        }
+#endif // BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+        /**
+         * Gets the <em>phase probability vector</em> parameter of the distribtuion.
+         *
+         * \return The <em>phase probability vector</em> parameter of the distribution.
+         *
+         * \note
+         *  The returned probabilities are the normalized version of the ones
+         *  passed at construction time.
+         */
+        public: std::vector<RealT> probabilities() const
+        {
+            return probs_;
+        }
+
+        /**
+         * Gets the <em>rate vector</em> parameter of the distribtuion.
+         *
+         * \return The <em>rate vector</em> parameter of the distribution.
+         */
+        public: std::vector<RealT> rates() const
+        {
+            return rates_;
+        }
+
+        /** Writes a \c param_type to a \c std::ostream. */
+        public: BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, param)
+        {
+            detail::print_vector(os, param.probs_);
+            os << ' ';
+            detail::print_vector(os, param.rates_);
+
+            return os;
+        }
+
+        /** Reads a \c param_type from a \c std::istream. */
+        public: BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, param)
+        {
+            // NOTE: if \c std::ios_base::exceptions is set, the code below may
+            //       throw in case of a I/O failure.
+            //       To prevent leaving the state of \c param inconsistent:
+            //       - if an exception is thrown, the state of \c param is left
+            //         unchanged (i.e., is the same as the one at the beginning
+            //         of the function's execution), and
+            //       - the state of \c param only after reading the whole input.
+
+            std::vector<RealT> probs;
+            std::vector<RealT> rates;
+
+            // Reads probability and rate vectors
+            detail::read_vector(is, probs);
+            if (!is)
+            {
+                return is;
+            }
+            is >> std::ws;
+            detail::read_vector(is, rates);
+            if (!is)
+            {
+                return is;
+            }
+
+            // Update the state of the param_type object
+            if (probs.size() > 0)
+            {
+                param.probs_.swap(probs);
+                probs.clear();
+            }
+            if (rates.size() > 0)
+            {
+                param.rates_.swap(rates);
+                rates.clear();
+            }
+
+            bool fail = false;
+
+            // Adjust vector sizes (if needed)
+            if (param.probs_.size() != param.rates_.size()
+                || param.probs_.size() == 0)
+            {
+                fail = true;
+
+                const std::size_t np = param.probs_.size();
+                const std::size_t nr = param.rates_.size();
+
+                if (np > nr)
+                {
+                    param.rates_.resize(np, 1);
+                }
+                else if (nr > np)
+                {
+                    param.probs_.resize(nr, 1);
+                }
+                else
+                {
+                    param.probs_.resize(1, 1);
+                    param.rates_.resize(1, 1);
+                }
+            }
+
+            // Normalize probabilities
+            // NOTE: this cannot be done earlier since the probability vector
+            //       can be changed due to size conformance
+            hyperexp_detail::normalize(param.probs_);
+
+            // Set the error state in the underlying stream in case of invalid input
+            if (fail)
+            {
+                // This throws an exception if ios_base::exception(failbit) is enabled
+                is.setstate(std::ios_base::failbit);
+            }
+
+            //post: vector size conformance
+            assert(param.probs_.size() == param.rates_.size());
+
+            return is;
+        }
+
+        /** Returns true if the two sets of parameters are the same. */
+        public: BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        {
+            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)
+
+
+        private: std::vector<RealT> probs_; ///< The <em>phase probability vector</em> parameter of the distribution
+        private: std::vector<RealT> rates_; ///< The <em>rate vector</em> parameter of the distribution
+    }; // param_type
+
+
+    /**
+     * Constructs a 1-phase \c hyperexponential_distribution (i.e., an
+     * exponential distribution) with rate 1.
+     */
+    public: hyperexponential_distribution()
+    : dd_(std::vector<RealT>(1, 1)),
+      rates_(1, 1)
+    {
+        // empty
+    }
+
+    /**
+     * Constructs a \c hyperexponential_distribution from the <em>phase
+     * probability vector</em> and <em>rate vector</em> parameters of the
+     * distribution.
+     *
+     * The <em>phase probability vector</em> parameter is given by the range
+     * defined by [\a prob_first, \a prob_last) iterator pair, and the
+     * <em>rate vector</em> parameter is given by the range defined by
+     * [\a rate_first, \a rate_last) iterator pair.
+     *
+     * \tparam ProbIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+     * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+     *
+     * \param prob_first The iterator to the beginning of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
+     * \param prob_last The iterator to the ending of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
+     * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
+     * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
+     *
+     * References:
+     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+     * .
+     */
+    public: template <typename ProbIterT, typename RateIterT>
+            hyperexponential_distribution(ProbIterT prob_first, ProbIterT prob_last,
+                                          RateIterT rate_first, RateIterT rate_last)
+    : dd_(prob_first, prob_last),
+      rates_(rate_first, rate_last)
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+
+    /**
+     * Constructs a \c hyperexponential_distribution from the <em>phase
+     * probability vector</em> and <em>rate vector</em> parameters of the
+     * distribution.
+     *
+     * The <em>phase probability vector</em> parameter is given by the range
+     * defined by \a prob_range, and the <em>rate vector</em> parameter is
+     * given by the range defined by \a rate_range.
+     *
+     * \tparam ProbRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
+     * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
+     *
+     * \param prob_range The range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
+     * \param rate_range The range of positive real elements representing the rates.
+     *
+     * \note
+     *  The final \c disable_if parameter is an implementation detail that
+     *  differentiates between this two argument constructor and the
+     *  iterator-based two argument constructor described below.
+     */
+    //  We SFINAE this out of existance if either argument type is
+    //  incrementable as in that case the type is probably an iterator:
+    public: template <typename ProbRangeT, typename RateRangeT>
+            hyperexponential_distribution(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)
+    : dd_(prob_range),
+      rates_(boost::begin(rate_range), boost::end(rate_range))
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+
+    /**
+     * Constructs a \c hyperexponential_distribution from the <em>rate
+     * vector</em> parameter of the distribution and with equal phase
+     * probabilities.
+     *
+     * The <em>rate vector</em> parameter is given by the range defined by
+     * [\a rate_first, \a rate_last) iterator pair, and the <em>phase
+     * probability vector</em> parameter is set to the equal phase
+     * probabilities (i.e., to a vector of the same length \f$k\f$ of the
+     * <em>rate vector</em> and with each element set to \f$1.0/k\f$).
+     *
+     * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+     * \tparam RateIterT2 Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
+     *
+     * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
+     * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
+     *
+     * \note
+     *  The final \c disable_if parameter is an implementation detail that
+     *  differentiates between this two argument constructor and the
+     *  range-based two argument constructor described above.
+     *
+     * References:
+     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+     * .
+     */
+    //  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>
+            hyperexponential_distribution(RateIterT rate_first,
+                                          RateIterT rate_last,
+                                          typename boost::enable_if_c<boost::has_pre_increment<RateIterT>::value>::type* = 0)
+    : dd_(std::vector<RealT>(std::distance(rate_first, rate_last), 1)),
+      rates_(rate_first, rate_last)
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+
+    /**
+     * Constructs a @c param_type from the "rates" parameters
+     * of the distribution and with equal phase probabilities.
+     *
+     * The <em>rate vector</em> parameter is given by the range defined by
+     * \a rate_range, and the <em>phase probability vector</em> parameter is
+     * set to the equal phase probabilities (i.e., to a vector of the same
+     * length \f$k\f$ of the <em>rate vector</em> and with each element set
+     * to \f$1.0/k\f$).
+     *
+     * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
+     *
+     * \param rate_range The range of positive real elements representing the rates.
+     */
+    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))
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+
+    /**
+     * Constructs a \c hyperexponential_distribution from its parameters.
+     *
+     * \param param The parameters of the distribution.
+     */
+    public: explicit hyperexponential_distribution(param_type const& param)
+    : dd_(param.probabilities()),
+      rates_(param.rates())
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+    /**
+     * Constructs a \c hyperexponential_distribution from the <em>phase
+     * probability vector</em> and <em>rate vector</em> parameters of the
+     * distribution.
+     *
+     * The <em>phase probability vector</em> parameter is given by the
+     * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
+     * defined by \a l1, and the <em>rate vector</em> parameter is given by the
+     * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
+     * defined by \a l2.
+     *
+     * \param l1 The initializer list for inizializing the phase probability vector.
+     * \param l2 The initializer list for inizializing the rate vector.
+     *
+     * References:
+     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+     * .
+     */
+    public: hyperexponential_distribution(std::initializer_list<RealT> const& l1, std::initializer_list<RealT> const& l2)
+    : dd_(l1.begin(), l1.end()),
+      rates_(l2.begin(), l2.end())
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+
+    /**
+     * Constructs a \c hyperexponential_distribution from the <em>rate
+     * vector</em> parameter of the distribution and with equal phase
+     * probabilities.
+     *
+     * The <em>rate vector</em> parameter is given by the
+     * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
+     * defined by \a l1, and the <em>phase probability vector</em> parameter is
+     * set to the equal phase probabilities (i.e., to a vector of the same
+     * length \f$k\f$ of the <em>rate vector</em> and with each element set
+     * to \f$1.0/k\f$).
+     *
+     * \param l1 The initializer list for inizializing the rate vector.
+     *
+     * References:
+     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
+     * .
+     */
+    public: hyperexponential_distribution(std::initializer_list<RealT> const& l1)
+    : dd_(std::vector<RealT>(std::distance(l1.begin(), l1.end()), 1)),
+      rates_(l1.begin(), l1.end())
+    {
+        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
+    }
+#endif
+
+    /**
+     * Gets a random variate distributed according to the
+     * hyperexponential distribution.
+     *
+     * \tparam URNG Must meet the requirements of \uniform_random_number_generator.
+     *
+     * \param urng A uniform random number generator object.
+     *
+     * \return A random variate distributed according to the hyperexponential distribution.
+     */
+    public: template<class URNG>\
+            RealT operator()(URNG& urng) const
+    {
+        const int i = dd_(urng);
+
+        return boost::random::exponential_distribution<RealT>(rates_[i])(urng);
+    }
+
+    /**
+     * Gets a random variate distributed according to the hyperexponential
+     * distribution with parameters specified by \c param.
+     *
+     * \tparam URNG Must meet the requirements of \uniform_random_number_generator.
+     *
+     * \param urng A uniform random number generator object.
+     * \param param A distribution parameter object.
+     *
+     * \return A random variate distributed according to the hyperexponential distribution.
+     *  distribution with parameters specified by \c param.
+     */
+    public: template<class URNG>
+            RealT operator()(URNG& urng, const param_type& param) const
+    {
+        return hyperexponential_distribution(param)(urng);
+    }
+
+    /** Returns the number of phases of the distribution. */
+    public: std::size_t num_phases() const
+    {
+        return rates_.size();
+    }
+
+    /** Returns the <em>phase probability vector</em> parameter of the distribution. */
+    public: std::vector<RealT> probabilities() const
+    {
+        return dd_.probabilities();
+    }
+
+    /** Returns the <em>rate vector</em> parameter of the distribution. */
+    public: std::vector<RealT> rates() const
+    {
+        return rates_;
+    }
+
+    /** Returns the smallest value that the distribution can produce. */
+    public: RealT min BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    {
+        return 0;
+    }
+
+    /** Returns the largest value that the distribution can produce. */
+    public: RealT max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    {
+        return std::numeric_limits<RealT>::infinity();
+    }
+
+    /** Returns the parameters of the distribution. */
+    public: param_type param() const
+    {
+        std::vector<RealT> probs = dd_.probabilities();
+
+        return param_type(probs.begin(), probs.end(), rates_.begin(), rates_.end());
+    }
+
+    /** Sets the parameters of the distribution. */
+    public: void param(param_type const& param)
+    {
+        dd_.param(typename boost::random::discrete_distribution<int,RealT>::param_type(param.probabilities()));
+        rates_ = param.rates();
+    }
+
+    /**
+     * Effects: Subsequent uses of the distribution do not depend
+     * on values produced by any engine prior to invoking reset.
+     */
+    public: void reset()
+    {
+        // empty
+    }
+
+    /** Writes an @c hyperexponential_distribution to a @c std::ostream. */
+    public: BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, hyperexponential_distribution, hd)
+    {
+        os << hd.param();
+        return os;
+    }
+
+    /** Reads an @c hyperexponential_distribution from a @c std::istream. */
+    public: BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, hyperexponential_distribution, hd)
+    {
+        param_type param;
+        if(is >> param)
+        {
+            hd.param(param);
+        }
+        return is;
+    }
+
+    /**
+     * Returns true if the two instances of @c hyperexponential_distribution will
+     * return identical sequences of values given equal generators.
+     */
+    public: BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(hyperexponential_distribution, lhs, rhs)
+    {
+        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.
+     */
+    public: BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(hyperexponential_distribution)
+
+
+    private: boost::random::discrete_distribution<int,RealT> dd_; ///< The \c discrete_distribution used to sample the phase probability and choose the rate
+    private: std::vector<RealT> rates_; ///< The <em>rate vector</em> parameter of the distribution
+}; // hyperexponential_distribution
+
+}} // namespace boost::random
+
+
+#endif // BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP