- typedef RealType input_type;
- typedef IntType result_type;
-
- /**
- * Contructs a new geometric_distribution with the paramter @c p.
- *
- * Requires: 0 < p < 1
- */
- explicit geometric_distribution(const RealType& p = RealType(0.5))
- : _p(p)
- {
- assert(RealType(0) < _p && _p < RealType(1));
- init();
- }
-
- // compiler-generated copy ctor and assignment operator are fine
-
- /**
- * Returns: the distribution parameter @c p
- */
- RealType p() const { return _p; }
- void reset() { }
-
- template<class Engine>
- result_type operator()(Engine& eng)
- {
-#ifndef BOOST_NO_STDC_NAMESPACE
- using std::log;
- using std::floor;
-#endif
- return IntType(floor(log(RealType(1)-eng()) / _log_p)) + IntType(1);
- }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
- template<class CharT, class Traits>
- friend std::basic_ostream<CharT,Traits>&
- operator<<(std::basic_ostream<CharT,Traits>& os, const geometric_distribution& gd)
- {
- os << gd._p;
- return os;
- }
-
- template<class CharT, class Traits>
- friend std::basic_istream<CharT,Traits>&
- operator>>(std::basic_istream<CharT,Traits>& is, geometric_distribution& gd)
- {
- is >> std::ws >> gd._p;
- gd.init();
- return is;
- }
-#endif
+ typedef RealType input_type;
+ typedef IntType result_type;
+
+ class param_type
+ {
+ public:
+
+ typedef geometric_distribution distribution_type;
+
+ /** Constructs the parameters with p. */
+ explicit param_type(RealType p_arg = RealType(0.5))
+ : _p(p_arg)
+ {
+ BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
+ }
+
+ /** Returns the p parameter of the distribution. */
+ RealType p() const { return _p; }
+
+ /** Writes the parameters to a std::ostream. */
+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+ {
+ os << parm._p;
+ return os;
+ }
+
+ /** Reads the parameters from a std::istream. */
+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+ {
+ double p_in;
+ if(is >> p_in) {
+ if(p_in > RealType(0) && p_in < RealType(1)) {
+ parm._p = p_in;
+ } else {
+ is.setstate(std::ios_base::failbit);
+ }
+ }
+ return is;
+ }
+
+ /** Returns true if the two sets of parameters are equal. */
+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+ { return lhs._p == rhs._p; }
+
+ /** Returns true if the two sets of parameters are different. */
+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+
+ private:
+ RealType _p;
+ };
+
+ /**
+ * Contructs a new geometric_distribution with the paramter @c p.
+ *
+ * Requires: 0 < p < 1
+ */
+ explicit geometric_distribution(const RealType& p = RealType(0.5))
+ : _p(p)
+ {
+ BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
+ init();
+ }
+
+ /** Constructs a new geometric_distribution from its parameters. */
+ explicit geometric_distribution(const param_type& parm)
+ : _p(parm.p())
+ {
+ init();
+ }
+
+ // compiler-generated copy ctor and assignment operator are fine
+
+ /** Returns: the distribution parameter @c p */
+ RealType p() const { return _p; }
+
+ /** Returns the smallest value that the distribution can produce. */
+ IntType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return IntType(0); }
+
+ /** Returns the largest value that the distribution can produce. */
+ IntType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+ { return (std::numeric_limits<IntType>::max)(); }
+
+ /** Returns the parameters of the distribution. */
+ param_type param() const { return param_type(_p); }
+
+ /** Sets the parameters of the distribution. */
+ void param(const param_type& parm)
+ {
+ _p = parm.p();
+ init();
+ }
+
+ /**
+ * 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
+ * geometric_distribution.
+ */
+ template<class Engine>
+ result_type operator()(Engine& eng) const
+ {
+ using std::log;
+ using std::floor;
+ RealType x = RealType(1) - boost::uniform_01<RealType>()(eng);
+ return IntType(floor(log(x) / _log_1mp));
+ }
+
+ /**
+ * Returns a random variate distributed according to the
+ * geometric distribution with parameters specified by param.
+ */
+ template<class Engine>
+ result_type operator()(Engine& eng, const param_type& parm) const
+ { return geometric_distribution(parm)(eng); }
+
+ /** Writes the distribution to a @c std::ostream. */
+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, geometric_distribution, gd)
+ {
+ os << gd._p;
+ return os;
+ }
+
+ /** Reads the distribution from a @c std::istream. */
+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, geometric_distribution, gd)
+ {
+ param_type parm;
+ if(is >> parm) {
+ gd.param(parm);
+ }
+ return is;
+ }
+
+ /**
+ * Returns true if the two distributions will produce identical
+ * sequences of values given equal generators.
+ */
+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(geometric_distribution, lhs, rhs)
+ { return lhs._p == rhs._p; }
+
+ /**
+ * Returns true if the two distributions may produce different
+ * sequences of values given equal generators.
+ */
+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(geometric_distribution)