X-Git-Url: https://git.donarmstrong.com/?p=rsem.git;a=blobdiff_plain;f=boost%2Frandom%2Flognormal_distribution.hpp;fp=boost%2Frandom%2Flognormal_distribution.hpp;h=bc7ddfeff28339d7f74ad116769413a723e4dd40;hp=ed7d900dc08ea03117092ab79f1b75f8011b4fb3;hb=2d71eb92104693ca9baa5a2e1c23eeca776d8fd3;hpb=da57529b92adbb7ae74a89861cb39fb35ac7c62d diff --git a/boost/random/lognormal_distribution.hpp b/boost/random/lognormal_distribution.hpp index ed7d900..bc7ddfe 100644 --- a/boost/random/lognormal_distribution.hpp +++ b/boost/random/lognormal_distribution.hpp @@ -1,13 +1,14 @@ /* boost random/lognormal_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: lognormal_distribution.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $ + * $Id: lognormal_distribution.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $ * * Revision history * 2001-02-18 moved to individual header files @@ -18,112 +19,236 @@ #include // std::exp, std::sqrt #include -#include +#include +#include #include -#include #include +#include #include -#ifdef BOOST_NO_STDC_NAMESPACE -namespace std { - using ::log; - using ::sqrt; -} -#endif - namespace boost { - -#if defined(__GNUC__) && (__GNUC__ < 3) -// Special gcc workaround: gcc 2.95.x ignores using-declarations -// in template classes (confirmed by gcc author Martin v. Loewis) - using std::sqrt; - using std::exp; -#endif +namespace random { /** * Instantiations of class template lognormal_distribution model a * \random_distribution. Such a distribution produces random numbers - * with \f$p(x) = \frac{1}{x \sigma_N \sqrt{2\pi}} e^{\frac{-\left(\log(x)-\mu_N\right)^2}{2\sigma_N^2}}\f$ - * for x > 0, where \f$\mu_N = \log\left(\frac{\mu^2}{\sqrt{\sigma^2 + \mu^2}}\right)\f$ and - * \f$\sigma_N = \sqrt{\log\left(1 + \frac{\sigma^2}{\mu^2}\right)}\f$. + * with \f$\displaystyle p(x) = \frac{1}{x s \sqrt{2\pi}} e^{\frac{-\left(\log(x)-m\right)^2}{2s^2}}\f$ + * for x > 0. + * + * @xmlwarning + * This distribution has been updated to match the C++ standard. + * Its behavior has changed from the original + * boost::lognormal_distribution. A backwards compatible + * version is provided in namespace boost. + * @endxmlwarning */ template class lognormal_distribution { public: - typedef typename normal_distribution::input_type input_type; - typedef RealType result_type; - -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits::is_integer); -#endif - - /** - * Constructs a lognormal_distribution. @c mean and @c sigma are the - * mean and standard deviation of the lognormal distribution. - */ - explicit lognormal_distribution(result_type mean_arg = result_type(1), - result_type sigma_arg = result_type(1)) - : _mean(mean_arg), _sigma(sigma_arg) - { - assert(_mean > result_type(0)); - init(); - } - - // compiler-generated copy ctor and assignment operator are fine - - RealType mean() const { return _mean; } - RealType sigma() const { return _sigma; } - void reset() { _normal.reset(); } - - template - result_type operator()(Engine& eng) - { -#ifndef BOOST_NO_STDC_NAMESPACE - // allow for Koenig lookup - using std::exp; -#endif - return exp(_normal(eng) * _nsigma + _nmean); - } - -#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS - template - friend std::basic_ostream& - operator<<(std::basic_ostream& os, const lognormal_distribution& ld) - { - os << ld._normal << " " << ld._mean << " " << ld._sigma; - return os; - } - - template - friend std::basic_istream& - operator>>(std::basic_istream& is, lognormal_distribution& ld) - { - is >> std::ws >> ld._normal >> std::ws >> ld._mean >> std::ws >> ld._sigma; - ld.init(); - return is; - } -#endif + typedef typename normal_distribution::input_type input_type; + typedef RealType result_type; + + class param_type + { + public: + + typedef lognormal_distribution distribution_type; + + /** Constructs the parameters of a lognormal_distribution. */ + explicit param_type(RealType m_arg = RealType(0.0), + RealType s_arg = RealType(1.0)) + : _m(m_arg), _s(s_arg) {} + + /** Returns the "m" parameter of the distribution. */ + RealType m() const { return _m; } + + /** Returns the "s" parameter of the distribution. */ + RealType s() const { return _s; } + + /** Writes the parameters to a std::ostream. */ + BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm) + { + os << parm._m << " " << parm._s; + return os; + } + + /** Reads the parameters from a std::istream. */ + BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm) + { + is >> parm._m >> std::ws >> parm._s; + return is; + } + + /** Returns true if the two sets of parameters are equal. */ + BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs) + { return lhs._m == rhs._m && lhs._s == rhs._s; } + + /** Returns true if the two sets of parameters are different. */ + BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type) + + private: + RealType _m; + RealType _s; + }; + + /** + * Constructs a lognormal_distribution. @c m and @c s are the + * parameters of the distribution. + */ + explicit lognormal_distribution(RealType m_arg = RealType(0.0), + RealType s_arg = RealType(1.0)) + : _normal(m_arg, s_arg) {} + + /** + * Constructs a lognormal_distribution from its parameters. + */ + explicit lognormal_distribution(const param_type& parm) + : _normal(parm.m(), parm.s()) {} + + // compiler-generated copy ctor and assignment operator are fine + + /** Returns the m parameter of the distribution. */ + RealType m() const { return _normal.mean(); } + /** Returns the s parameter of the distribution. */ + RealType s() const { return _normal.sigma(); } + + /** Returns the smallest value that the distribution can produce. */ + RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const + { return RealType(0); } + /** Returns the largest value that the distribution can produce. */ + RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const + { return (std::numeric_limits::infinity)(); } + + /** Returns the parameters of the distribution. */ + param_type param() const { return param_type(m(), s()); } + /** Sets the parameters of the distribution. */ + void param(const param_type& parm) + { + typedef normal_distribution normal_type; + typename normal_type::param_type normal_param(parm.m(), parm.s()); + _normal.param(normal_param); + } + + /** + * Effects: Subsequent uses of the distribution do not depend + * on values produced by any engine prior to invoking reset. + */ + void reset() { _normal.reset(); } + + /** + * Returns a random variate distributed according to the + * lognormal distribution. + */ + template + result_type operator()(Engine& eng) + { + using std::exp; + return exp(_normal(eng)); + } + + /** + * Returns a random variate distributed according to the + * lognormal distribution with parameters specified by param. + */ + template + result_type operator()(Engine& eng, const param_type& parm) + { return lognormal_distribution(parm)(eng); } + + /** Writes the distribution to a @c std::ostream. */ + BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lognormal_distribution, ld) + { + os << ld._normal; + return os; + } + + /** Reads the distribution from a @c std::istream. */ + BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lognormal_distribution, ld) + { + is >> ld._normal; + return is; + } + + /** + * Returns true if the two distributions will produce identical + * sequences of values given equal generators. + */ + BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lognormal_distribution, lhs, rhs) + { return lhs._normal == rhs._normal; } + + /** + * Returns true if the two distributions may produce different + * sequences of values given equal generators. + */ + BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lognormal_distribution) private: + normal_distribution _normal; +}; - /// \cond hide_private_members - void init() - { -#ifndef BOOST_NO_STDC_NAMESPACE - // allow for Koenig lookup - using std::exp; using std::log; using std::sqrt; -#endif - _nmean = log(_mean*_mean/sqrt(_sigma*_sigma + _mean*_mean)); - _nsigma = sqrt(log(_sigma*_sigma/_mean/_mean+result_type(1))); - } - /// \endcond - - RealType _mean, _sigma; - RealType _nmean, _nsigma; - normal_distribution _normal; +} // namespace random + +/// \cond show_deprecated + +/** + * Provided for backwards compatibility. This class is + * deprecated. It provides the old behavior of lognormal_distribution with + * \f$\displaystyle p(x) = \frac{1}{x \sigma_N \sqrt{2\pi}} e^{\frac{-\left(\log(x)-\mu_N\right)^2}{2\sigma_N^2}}\f$ + * for x > 0, where \f$\displaystyle \mu_N = \log\left(\frac{\mu^2}{\sqrt{\sigma^2 + \mu^2}}\right)\f$ and + * \f$\displaystyle \sigma_N = \sqrt{\log\left(1 + \frac{\sigma^2}{\mu^2}\right)}\f$. + */ +template +class lognormal_distribution +{ +public: + typedef typename normal_distribution::input_type input_type; + typedef RealType result_type; + + lognormal_distribution(RealType mean_arg = RealType(1.0), + RealType sigma_arg = RealType(1.0)) + : _mean(mean_arg), _sigma(sigma_arg) + { + init(); + } + RealType mean() const { return _mean; } + RealType sigma() const { return _sigma; } + void reset() { _normal.reset(); } + template + RealType operator()(Engine& eng) + { + using std::exp; + return exp(_normal(eng) * _nsigma + _nmean); + } + BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lognormal_distribution, ld) + { + os << ld._normal << " " << ld._mean << " " << ld._sigma; + return os; + } + BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lognormal_distribution, ld) + { + is >> ld._normal >> std::ws >> ld._mean >> std::ws >> ld._sigma; + ld.init(); + return is; + } +private: + /// \cond show_private + void init() + { + using std::log; + using std::sqrt; + _nmean = log(_mean*_mean/sqrt(_sigma*_sigma + _mean*_mean)); + _nsigma = sqrt(log(_sigma*_sigma/_mean/_mean+result_type(1))); + } + RealType _mean; + RealType _sigma; + RealType _nmean; + RealType _nsigma; + normal_distribution _normal; + /// \endcond }; +/// \endcond + } // namespace boost #endif // BOOST_RANDOM_LOGNORMAL_DISTRIBUTION_HPP