*
* 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
#define BOOST_RANDOM_CAUCHY_DISTRIBUTION_HPP
#include <boost/config/no_tr1/cmath.hpp>
-#include <iostream>
+#include <iosfwd>
+#include <istream>
#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/uniform_01.hpp>
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 RealType = double>
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<RealType>::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<class Engine>
- 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<class CharT, class Traits>
- friend std::basic_ostream<CharT,Traits>&
- operator<<(std::basic_ostream<CharT,Traits>& os, const cauchy_distribution& cd)
- {
- os << cd._median << " " << cd._sigma;
- return os;
- }
-
- /**
- * Reads the parameters of the distribution from a @c std::istream.
- */
- template<class CharT, class Traits>
- friend std::basic_istream<CharT,Traits>&
- operator>>(std::basic_istream<CharT,Traits>& 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<RealType>::infinity)(); }
+
+ /** Returns the largest value that the distribution can produce. */
+ RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+ { return (std::numeric_limits<RealType>::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<class Engine>
+ 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<RealType>()(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<class Engine>
+ 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
projects / rsem.git / blobdiff