boost/random/hyperexponential_distribution.hpp
/* 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