summaryrefslogtreecommitdiff log msg author committer range
diff options
 context: 12345678910152025303540 space: includeignore mode: unifiedssdiffstat only
Diffstat (limited to 'boost/random/normal_distribution.hpp')
-rw-r--r--boost/random/normal_distribution.hpp223
1 files changed, 223 insertions, 0 deletions
 diff --git a/boost/random/normal_distribution.hpp b/boost/random/normal_distribution.hppnew file mode 100644index 0000000..9515fb3--- /dev/null+++ b/boost/random/normal_distribution.hpp@@ -0,0 +1,223 @@+/* boost random/normal_distribution.hpp header file+ *+ * Copyright Jens Maurer 2000-2001+ * Copyright Steven Watanabe 2010-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: normal_distribution.hpp 71018 2011-04-05 21:27:52Z steven_watanabe$+ *+ * Revision history+ * 2001-02-18 moved to individual header files+ */++#ifndef BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP+#define BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP++#include +#include +#include +#include +#include +#include +#include +#include +#include ++namespace boost {+namespace random {++// deterministic Box-Muller method, uses trigonometric functions++/**+ * Instantiations of class template normal_distribution model a+ * \random_distribution. Such a distribution produces random numbers+ * @c x distributed with probability density function+ * \f$\displaystyle p(x) =+ * \frac{1}{\sqrt{2\pi\sigma}} e^{-\frac{(x-\mu)^2}{2\sigma^2}}+ * \f$,+ * where mean and sigma are the parameters of the distribution.+ */+template+class normal_distribution+{+public:+ typedef RealType input_type;+ typedef RealType result_type;++ class param_type {+ public:+ typedef normal_distribution distribution_type;++ /**+ * Constructs a @c param_type with a given mean and+ * standard deviation.+ *+ * Requires: sigma >= 0+ */+ explicit param_type(RealType mean_arg = RealType(0.0),+ RealType sigma_arg = RealType(1.0))+ : _mean(mean_arg),+ _sigma(sigma_arg)+ {}++ /** Returns the mean of the distribution. */+ RealType mean() const { return _mean; }++ /** Returns the standand deviation of the distribution. */+ RealType sigma() const { return _sigma; }++ /** Writes a @c param_type to a @c std::ostream. */+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)+ { os << parm._mean << " " << parm._sigma ; return os; }++ /** Reads a @c param_type from a @c std::istream. */+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)+ { is >> parm._mean >> std::ws >> parm._sigma; return is; }++ /** Returns true if the two sets of parameters are the same. */+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)+ { return lhs._mean == rhs._mean && lhs._sigma == rhs._sigma; }+ + /** Returns true if the two sets of parameters are the different. */+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)++ private:+ RealType _mean;+ RealType _sigma;+ };++ /**+ * Constructs a @c normal_distribution object. @c mean and @c sigma are+ * the parameters for the distribution.+ *+ * Requires: sigma >= 0+ */+ explicit normal_distribution(const RealType& mean_arg = RealType(0.0),+ const RealType& sigma_arg = RealType(1.0))+ : _mean(mean_arg), _sigma(sigma_arg),+ _r1(0), _r2(0), _cached_rho(0), _valid(false)+ {+ BOOST_ASSERT(_sigma >= RealType(0));+ }++ /**+ * Constructs a @c normal_distribution object from its parameters.+ */+ explicit normal_distribution(const param_type& parm)+ : _mean(parm.mean()), _sigma(parm.sigma()),+ _r1(0), _r2(0), _cached_rho(0), _valid(false)+ {}++ /** Returns the mean of the distribution. */+ RealType mean() const { return _mean; }+ /** Returns the standard deviation of the distribution. */+ RealType sigma() const { return _sigma; }++ /** Returns the smallest value that the distribution can produce. */+ RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const+ { return -std::numeric_limits::infinity(); }+ /** 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(_mean, _sigma); }+ /** Sets the parameters of the distribution. */+ void param(const param_type& parm)+ {+ _mean = parm.mean();+ _sigma = parm.sigma();+ _valid = false;+ }++ /**+ * Effects: Subsequent uses of the distribution do not depend+ * on values produced by any engine prior to invoking reset.+ */+ void reset() { _valid = false; }++ /** Returns a normal variate. */+ template+ result_type operator()(Engine& eng)+ {+ using std::sqrt;+ using std::log;+ using std::sin;+ using std::cos;++ if(!_valid) {+ _r1 = boost::uniform_01()(eng);+ _r2 = boost::uniform_01()(eng);+ _cached_rho = sqrt(-result_type(2) * log(result_type(1)-_r2));+ _valid = true;+ } else {+ _valid = false;+ }+ // Can we have a boost::mathconst please?+ const result_type pi = result_type(3.14159265358979323846);++ return _cached_rho * (_valid ?+ cos(result_type(2)*pi*_r1) :+ sin(result_type(2)*pi*_r1))+ * _sigma + _mean;+ }++ /** Returns a normal variate with parameters specified by @c param. */+ template+ result_type operator()(URNG& urng, const param_type& parm)+ {+ return normal_distribution(parm)(urng);+ }++ /** Writes a @c normal_distribution to a @c std::ostream. */+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, normal_distribution, nd)+ {+ os << nd._mean << " " << nd._sigma << " "+ << nd._valid << " " << nd._cached_rho << " " << nd._r1;+ return os;+ }++ /** Reads a @c normal_distribution from a @c std::istream. */+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, normal_distribution, nd)+ {+ is >> std::ws >> nd._mean >> std::ws >> nd._sigma+ >> std::ws >> nd._valid >> std::ws >> nd._cached_rho+ >> std::ws >> nd._r1;+ return is;+ }++ /**+ * Returns true if the two instances of @c normal_distribution will+ * return identical sequences of values given equal generators.+ */+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(normal_distribution, lhs, rhs)+ {+ return lhs._mean == rhs._mean && lhs._sigma == rhs._sigma+ && lhs._valid == rhs._valid+ && (!lhs._valid || (lhs._r1 == rhs._r1 && lhs._r2 == rhs._r2));+ }++ /**+ * Returns true if the two instances of @c normal_distribution will+ * return different sequences of values given equal generators.+ */+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(normal_distribution)++private:+ RealType _mean, _sigma;+ RealType _r1, _r2, _cached_rho;+ bool _valid;++};++} // namespace random++using random::normal_distribution;++} // namespace boost++#endif // BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP