// random number generation -*- C++ -*-
-// Copyright (C) 2009-2012 Free Software Foundation, Inc.
+// Copyright (C) 2009-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
template<typename _Engine, typename _DInputType>
struct _Adaptor
{
+ static_assert(std::is_floating_point<_DInputType>::value,
+ "template argument not a floating point type");
public:
_Adaptor(_Engine& __g)
*
* The size of the state is @f$r@f$
* and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
- *
- * @var _M_x The state of the generator. This is a ring buffer.
- * @var _M_carry The carry.
- * @var _M_p Current index of x(i - r).
*/
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
class subtract_with_carry_engine
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>&,
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::subtract_with_carry_engine<_UIntType1, __w1,
- __s1, __r1>&);
+ __s1, __r1>& __x);
/**
* @brief Extracts the current state of a % subtract_with_carry_engine
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
- operator>>(std::basic_istream<_CharT, _Traits>&,
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::subtract_with_carry_engine<_UIntType1, __w1,
- __s1, __r1>&);
+ __s1, __r1>& __x);
private:
+ /// The state of the generator. This is a ring buffer.
_UIntType _M_x[long_lag];
- _UIntType _M_carry;
- size_t _M_p;
+ _UIntType _M_carry; ///< The carry
+ size_t _M_p; ///< Current index of x(i - r).
};
/**
union
{
- FILE* _M_file;
- mt19937 _M_mt;
- };
+ void* _M_file;
+ mt19937 _M_mt;
+ };
};
/* @} */ // group random_generators
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two uniform integer distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const uniform_int_distribution& __d1,
+ const uniform_int_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two uniform integer distributions have
- * the same parameters.
- */
- template<typename _IntType>
- inline bool
- operator==(const std::uniform_int_distribution<_IntType>& __d1,
- const std::uniform_int_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two uniform integer distributions have
* different parameters.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two uniform real distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const uniform_real_distribution& __d1,
+ const uniform_real_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two uniform real distributions have
- * the same parameters.
- */
- template<typename _IntType>
- inline bool
- operator==(const std::uniform_real_distribution<_IntType>& __d1,
- const std::uniform_real_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two uniform real distributions have
* different parameters.
*/
result_type
min() const
- { return std::numeric_limits<result_type>::min(); }
+ { return std::numeric_limits<result_type>::lowest(); }
/**
* @brief Returns the least upper bound value of the distribution.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
friend bool
operator==(const lognormal_distribution& __d1,
const lognormal_distribution& __d2)
- { return (__d1.param() == __d2.param()
+ { return (__d1._M_param == __d2._M_param
&& __d1._M_nd == __d2._M_nd); }
/**
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
friend bool
operator==(const gamma_distribution& __d1,
const gamma_distribution& __d2)
- { return (__d1.param() == __d2.param()
+ { return (__d1._M_param == __d2._M_param
&& __d1._M_nd == __d2._M_nd); }
/**
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate_impl(__f, __t, __urng, _M_gd.param()); }
+ { this->__generate_impl(__f, __t, __urng); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
- { typename std::gamma_distribution<result_type>::param_type
- __p2(_M_gd.param());
- this->__generate_impl(__f, __t, __urng, __p2); }
+ { this->__generate_impl(__f, __t, __urng); }
template<typename _UniformRandomNumberGenerator>
void
friend bool
operator==(const chi_squared_distribution& __d1,
const chi_squared_distribution& __d2)
- { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
+ { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
/**
* @brief Inserts a %chi_squared_distribution random number distribution
std::chi_squared_distribution<_RealType1>& __x);
private:
+ template<typename _ForwardIterator,
+ typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+ _UniformRandomNumberGenerator& __urng);
+
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
- typename std::gamma_distribution<result_type>::param_type&
- __p);
+ const typename
+ std::gamma_distribution<result_type>::param_type& __p);
param_type _M_param;
*/
result_type
min() const
- { return std::numeric_limits<result_type>::min(); }
+ { return std::numeric_limits<result_type>::lowest(); }
/**
* @brief Returns the least upper bound value of the distribution.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two Cauchy distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const cauchy_distribution& __d1,
+ const cauchy_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two Cauchy distributions have
- * the same parameters.
- */
- template<typename _RealType>
- inline bool
- operator==(const std::cauchy_distribution<_RealType>& __d1,
- const std::cauchy_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two Cauchy distributions have
* different parameters.
friend bool
operator==(const fisher_f_distribution& __d1,
const fisher_f_distribution& __d2)
- { return (__d1.param() == __d2.param()
+ { return (__d1._M_param == __d2._M_param
&& __d1._M_gd_x == __d2._M_gd_x
&& __d1._M_gd_y == __d2._M_gd_y); }
};
/**
- * @brief Return true if two Fisher f distributions are diferent.
+ * @brief Return true if two Fisher f distributions are different.
*/
template<typename _RealType>
inline bool
*/
result_type
min() const
- { return std::numeric_limits<result_type>::min(); }
+ { return std::numeric_limits<result_type>::lowest(); }
/**
* @brief Returns the least upper bound value of the distribution.
friend bool
operator==(const student_t_distribution& __d1,
const student_t_distribution& __d2)
- { return (__d1.param() == __d2.param()
+ { return (__d1._M_param == __d2._M_param
&& __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
/**
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two Bernoulli distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const bernoulli_distribution& __d1,
+ const bernoulli_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two Bernoulli distributions have
- * the same parameters.
- */
- inline bool
- operator==(const std::bernoulli_distribution& __d1,
- const std::bernoulli_distribution& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two Bernoulli distributions have
* different parameters.
* @brief A discrete binomial random number distribution.
*
* The formula for the binomial probability density function is
- * @f$p(i|t,p) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
+ * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
* and @f$p@f$ are the parameters of the distribution.
*/
template<typename _IntType = int>
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
operator==(const binomial_distribution& __d1,
const binomial_distribution& __d2)
#ifdef _GLIBCXX_USE_C99_MATH_TR1
- { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
+ { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
#else
- { return __d1.param() == __d2.param(); }
+ { return __d1._M_param == __d2._M_param; }
#endif
/**
template<typename _UniformRandomNumberGenerator>
result_type
- _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
+ _M_waiting(_UniformRandomNumberGenerator& __urng,
+ _IntType __t, double __q);
param_type _M_param;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two geometric distributions have
+ * the same parameters.
+ */
+ friend bool
+ operator==(const geometric_distribution& __d1,
+ const geometric_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two geometric distributions have
- * the same parameters.
- */
- template<typename _IntType>
- inline bool
- operator==(const std::geometric_distribution<_IntType>& __d1,
- const std::geometric_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two geometric distributions have
* different parameters.
friend bool
operator==(const negative_binomial_distribution& __d1,
const negative_binomial_distribution& __d2)
- { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
+ { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
/**
* @brief Inserts a %negative_binomial_distribution random
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
operator==(const poisson_distribution& __d1,
const poisson_distribution& __d2)
#ifdef _GLIBCXX_USE_C99_MATH_TR1
- { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
+ { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
#else
- { return __d1.param() == __d2.param(); }
+ { return __d1._M_param == __d2._M_param; }
#endif
/**
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two exponential distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const exponential_distribution& __d1,
+ const exponential_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two exponential distributions have the same
- * parameters.
- */
- template<typename _RealType>
- inline bool
- operator==(const std::exponential_distribution<_RealType>& __d1,
- const std::exponential_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two exponential distributions have different
* parameters.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two Weibull distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const weibull_distribution& __d1,
+ const weibull_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two Weibull distributions have the same
- * parameters.
- */
- template<typename _RealType>
- inline bool
- operator==(const std::weibull_distribution<_RealType>& __d1,
- const std::weibull_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two Weibull distributions have different
* parameters.
*/
result_type
min() const
- { return std::numeric_limits<result_type>::min(); }
+ { return std::numeric_limits<result_type>::lowest(); }
/**
* @brief Returns the least upper bound value of the distribution.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two extreme value distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const extreme_value_distribution& __d1,
+ const extreme_value_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
param_type _M_param;
};
- /**
- * @brief Return true if two extreme value distributions have the same
- * parameters.
- */
- template<typename _RealType>
- inline bool
- operator==(const std::extreme_value_distribution<_RealType>& __d1,
- const std::extreme_value_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two extreme value distributions have different
* parameters.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two discrete distributions have the same
+ * parameters.
+ */
+ friend bool
+ operator==(const discrete_distribution& __d1,
+ const discrete_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
/**
* @brief Inserts a %discrete_distribution random number distribution
* @p __x into the output stream @p __os.
param_type _M_param;
};
- /**
- * @brief Return true if two discrete distributions have the same
- * parameters.
- */
- template<typename _IntType>
- inline bool
- operator==(const std::discrete_distribution<_IntType>& __d1,
- const std::discrete_distribution<_IntType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two discrete distributions have different
* parameters.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
{ this->__generate_impl(__f, __t, __urng, __p); }
/**
- * @brief Inserts a %piecewise_constan_distribution random
+ * @brief Return true if two piecewise constant distributions have the
+ * same parameters.
+ */
+ friend bool
+ operator==(const piecewise_constant_distribution& __d1,
+ const piecewise_constant_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
+ /**
+ * @brief Inserts a %piecewise_constant_distribution random
* number distribution @p __x into the output stream @p __os.
*
* @param __os An output stream.
- * @param __x A %piecewise_constan_distribution random number
+ * @param __x A %piecewise_constant_distribution random number
* distribution.
*
* @returns The output stream with the state of @p __x inserted or in
const std::piecewise_constant_distribution<_RealType1>& __x);
/**
- * @brief Extracts a %piecewise_constan_distribution random
+ * @brief Extracts a %piecewise_constant_distribution random
* number distribution @p __x from the input stream @p __is.
*
* @param __is An input stream.
- * @param __x A %piecewise_constan_distribution random number
+ * @param __x A %piecewise_constant_distribution random number
* generator engine.
*
* @returns The input stream with @p __x extracted or in an error
param_type _M_param;
};
- /**
- * @brief Return true if two piecewise constant distributions have the
- * same parameters.
- */
- template<typename _RealType>
- inline bool
- operator==(const std::piecewise_constant_distribution<_RealType>& __d1,
- const std::piecewise_constant_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two piecewise constant distributions have
* different parameters.
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
- { return this->operator()(__urng, this->param()); }
+ { return this->operator()(__urng, _M_param); }
template<typename _UniformRandomNumberGenerator>
result_type
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
- { this->__generate(__f, __t, __urng, this->param()); }
+ { this->__generate(__f, __t, __urng, _M_param); }
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
+ /**
+ * @brief Return true if two piecewise linear distributions have the
+ * same parameters.
+ */
+ friend bool
+ operator==(const piecewise_linear_distribution& __d1,
+ const piecewise_linear_distribution& __d2)
+ { return __d1._M_param == __d2._M_param; }
+
/**
* @brief Inserts a %piecewise_linear_distribution random number
* distribution @p __x into the output stream @p __os.
param_type _M_param;
};
- /**
- * @brief Return true if two piecewise linear distributions have the
- * same parameters.
- */
- template<typename _RealType>
- inline bool
- operator==(const std::piecewise_linear_distribution<_RealType>& __d1,
- const std::piecewise_linear_distribution<_RealType>& __d2)
- { return __d1.param() == __d2.param(); }
-
/**
* @brief Return true if two piecewise linear distributions have
* different parameters.
projects / gcc.git / blobdiff