X-Git-Url: https://git.donarmstrong.com/?p=rsem.git;a=blobdiff_plain;f=boost%2Frandom%2Fcauchy_distribution.hpp;fp=boost%2Frandom%2Fcauchy_distribution.hpp;h=ed673bc9336edc9dd394093ba1beffc93169c8e2;hp=c11ba2bf7773f523a23e5d46a39b68fd6fa3b681;hb=2d71eb92104693ca9baa5a2e1c23eeca776d8fd3;hpb=da57529b92adbb7ae74a89861cb39fb35ac7c62d diff --git a/boost/random/cauchy_distribution.hpp b/boost/random/cauchy_distribution.hpp index c11ba2b..ed673bc 100644 --- a/boost/random/cauchy_distribution.hpp +++ b/boost/random/cauchy_distribution.hpp @@ -7,7 +7,7 @@ * * See http://www.boost.org for most recent version including documentation. * - * $Id: cauchy_distribution.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $ + * $Id: cauchy_distribution.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $ * * Revision history * 2001-02-18 moved to individual header files @@ -17,105 +17,198 @@ #define BOOST_RANDOM_CAUCHY_DISTRIBUTION_HPP #include -#include +#include +#include #include -#include #include +#include +#include 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::tan; -#endif +namespace random { // Cauchy distribution: /** * The cauchy distribution is a continuous distribution with two - * parameters, sigma and median. + * parameters, median and sigma. * - * It has \f$p(x) = \frac{\sigma}{\pi(\sigma^2 + (x-m)^2)}\f$ + * It has \f$\displaystyle p(x) = \frac{\sigma}{\pi(\sigma^2 + (x-m)^2)}\f$ */ template class cauchy_distribution { public: - typedef RealType input_type; - typedef RealType result_type; - -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits::is_integer); -#endif - - /** - * Constructs a \cauchy_distribution with the paramters @c median - * and @c sigma. - */ - explicit cauchy_distribution(result_type median_arg = result_type(0), - result_type sigma_arg = result_type(1)) - : _median(median_arg), _sigma(sigma_arg) { } - - // compiler-generated copy ctor and assignment operator are fine - - /** - * Returns: the "median" parameter of the distribution - */ - result_type median() const { return _median; } - /** - * Returns: the "sigma" parameter of the distribution - */ - result_type sigma() const { return _sigma; } - /** - * 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 - * cauchy distribution. - */ - template - result_type operator()(Engine& eng) - { - // Can we have a boost::mathconst please? - const result_type pi = result_type(3.14159265358979323846); -#ifndef BOOST_NO_STDC_NAMESPACE - using std::tan; -#endif - return _median + _sigma * tan(pi*(eng()-result_type(0.5))); - } - -#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS - /** - * Writes the parameters of the distribution to a @c std::ostream. - */ - template - friend std::basic_ostream& - operator<<(std::basic_ostream& os, const cauchy_distribution& cd) - { - os << cd._median << " " << cd._sigma; - return os; - } - - /** - * Reads the parameters of the distribution from a @c std::istream. - */ - template - friend std::basic_istream& - operator>>(std::basic_istream& is, cauchy_distribution& cd) - { - is >> std::ws >> cd._median >> std::ws >> cd._sigma; - return is; - } -#endif + typedef RealType input_type; + typedef RealType result_type; + + class param_type + { + public: + + typedef cauchy_distribution distribution_type; + + /** Constructs the parameters of the cauchy distribution. */ + explicit param_type(RealType median_arg = RealType(0.0), + RealType sigma_arg = RealType(1.0)) + : _median(median_arg), _sigma(sigma_arg) {} + + // backwards compatibility for Boost.Random + + /** Returns the median of the distribution. */ + RealType median() const { return _median; } + /** Returns the sigma parameter of the distribution. */ + RealType sigma() const { return _sigma; } + + // The new names in C++0x. + + /** Returns the median of the distribution. */ + RealType a() const { return _median; } + /** Returns the sigma parameter of the distribution. */ + RealType b() const { return _sigma; } + + /** Writes the parameters to a std::ostream. */ + BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm) + { + os << parm._median << " " << parm._sigma; + return os; + } + + /** Reads the parameters from a std::istream. */ + BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm) + { + is >> parm._median >> std::ws >> parm._sigma; + return is; + } + + /** Returns true if the two sets of parameters are equal. */ + BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs) + { return lhs._median == rhs._median && lhs._sigma == rhs._sigma; } + + /** Returns true if the two sets of parameters are different. */ + BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type) + + private: + RealType _median; + RealType _sigma; + }; + + /** + * Constructs a \cauchy_distribution with the paramters @c median + * and @c sigma. + */ + explicit cauchy_distribution(RealType median_arg = RealType(0.0), + RealType sigma_arg = RealType(1.0)) + : _median(median_arg), _sigma(sigma_arg) { } + + /** + * Constructs a \cauchy_distribution from it's parameters. + */ + explicit cauchy_distribution(const param_type& parm) + : _median(parm.median()), _sigma(parm.sigma()) { } + + // compiler-generated copy ctor and assignment operator are fine + + // backwards compatibility for Boost.Random + + /** Returns: the "median" parameter of the distribution */ + RealType median() const { return _median; } + /** Returns: the "sigma" parameter of the distribution */ + RealType sigma() const { return _sigma; } + + // The new names in C++0x + + /** Returns: the "median" parameter of the distribution */ + RealType a() const { return _median; } + /** Returns: the "sigma" parameter of the distribution */ + RealType b() 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)(); } + + param_type param() const { return param_type(_median, _sigma); } + + void param(const param_type& parm) + { + _median = parm.median(); + _sigma = parm.sigma(); + } + + /** + * 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 + * cauchy distribution. + */ + template + result_type operator()(Engine& eng) + { + // Can we have a boost::mathconst please? + const result_type pi = result_type(3.14159265358979323846); + using std::tan; + RealType val = uniform_01()(eng)-result_type(0.5); + return _median + _sigma * tan(pi*val); + } + + /** + * Returns: A random variate distributed according to the + * cauchy distribution with parameters specified by param. + */ + template + result_type operator()(Engine& eng, const param_type& parm) + { + return cauchy_distribution(parm)(eng); + } + + /** + * Writes the distribution to a @c std::ostream. + */ + BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, cauchy_distribution, cd) + { + os << cd._median << " " << cd._sigma; + return os; + } + + /** + * Reads the distribution from a @c std::istream. + */ + BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, cauchy_distribution, cd) + { + is >> cd._median >> std::ws >> cd._sigma; + return is; + } + + /** + * Returns true if the two distributions will produce + * identical sequences of values, given equal generators. + */ + BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(cauchy_distribution, lhs, rhs) + { return lhs._median == rhs._median && lhs._sigma == rhs._sigma; } + + /** + * Returns true if the two distributions may produce + * different sequences of values, given equal generators. + */ + BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(cauchy_distribution) private: - result_type _median, _sigma; + RealType _median; + RealType _sigma; }; +} // namespace random + +using random::cauchy_distribution; + } // namespace boost #endif // BOOST_RANDOM_CAUCHY_DISTRIBUTION_HPP