* @param __rhs Another linear congruential random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const linear_congruential_engine& __lhs,
_UIntType _M_x;
};
+ /**
+ * @brief Compares two linear congruential random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A linear congruential random number generator object.
+ * @param __rhs Another linear congruential random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ inline bool
+ operator!=(const std::linear_congruential_engine<_UIntType, __a,
+ __c, __m>& __lhs,
+ const std::linear_congruential_engine<_UIntType, __a,
+ __c, __m>& __rhs)
+ { return !(__lhs == __rhs); }
+
/**
* A generalized feedback shift register discrete random number generator.
* @param __rhs Another % mersenne_twister_engine random number
* generator object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const mersenne_twister_engine& __lhs,
};
/**
+ * @brief Compares two % mersenne_twister_engine random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A % mersenne_twister_engine random number generator
+ * object.
+ * @param __rhs Another % mersenne_twister_engine random number
+ * generator object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _UIntType, size_t __w,
+ size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t,
+ _UIntType __c, size_t __l, _UIntType __f>
+ inline bool
+ operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+ __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
+ const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+ __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* @brief The Marsaglia-Zaman generator.
*
* This is a model of a Generalized Fibonacci discrete random number
* @param __rhs Another % subtract_with_carry_engine random number
* generator object.
*
- * @returns true if the two objects are equal, false otherwise.
- */
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
+ */
friend bool
operator==(const subtract_with_carry_engine& __lhs,
const subtract_with_carry_engine& __rhs)
};
/**
+ * @brief Compares two % subtract_with_carry_engine random number
+ * generator objects of the same type for inequality.
+ *
+ * @param __lhs A % subtract_with_carry_engine random number generator
+ * object.
+ * @param __rhs Another % subtract_with_carry_engine random number
+ * generator object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+ inline bool
+ operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
+ __s, __r>& __lhs,
+ const std::subtract_with_carry_engine<_UIntType, __w,
+ __s, __r>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* Produces random numbers from some base engine by discarding blocks of
* data.
*
* @param __rhs Another %discard_block_engine random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const discard_block_engine& __lhs,
const discard_block_engine& __rhs)
- { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); }
+ { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
/**
* @brief Inserts the current state of a %discard_block_engine random
};
/**
+ * @brief Compares two %discard_block_engine random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A %discard_block_engine random number generator object.
+ * @param __rhs Another %discard_block_engine random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _RandomNumberEngine, size_t __p, size_t __r>
+ inline bool
+ operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
+ __r>& __lhs,
+ const std::discard_block_engine<_RandomNumberEngine, __p,
+ __r>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* Produces random numbers by combining random numbers from some base
* engine to produce random numbers with a specifies number of bits @p __w.
*/
* @param __rhs Another %independent_bits_engine random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
*/
friend bool
operator==(const independent_bits_engine& __lhs,
};
/**
+ * @brief Compares two %independent_bits_engine random number generator
+ * objects of the same type for inequality.
+ *
+ * @param __lhs A %independent_bits_engine random number generator
+ * object.
+ * @param __rhs Another %independent_bits_engine random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+ inline bool
+ operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
+ _UIntType>& __lhs,
+ const std::independent_bits_engine<_RandomNumberEngine, __w,
+ _UIntType>& __rhs)
+ { return !(__lhs == __rhs); }
+
+ /**
* @brief Inserts the current state of a %independent_bits_engine random
* number generator engine @p __x into the output stream @p __os.
*
return __os;
}
+
/**
* @brief Produces random numbers by combining random numbers from some
* base engine to produce random numbers with a specifies number of bits
* @param __rhs Another %shuffle_order_engine random number generator
* object.
*
- * @returns true if the two objects are equal, false otherwise.
- */
+ * @returns true if the infinite sequences of generated values
+ * would be equal, false otherwise.
+ */
friend bool
operator==(const shuffle_order_engine& __lhs,
const shuffle_order_engine& __rhs)
};
/**
+ * Compares two %shuffle_order_engine random number generator objects
+ * of the same type for inequality.
+ *
+ * @param __lhs A %shuffle_order_engine random number generator object.
+ * @param __rhs Another %shuffle_order_engine random number generator
+ * object.
+ *
+ * @returns true if the infinite sequences of generated values
+ * would be different, false otherwise.
+ */
+ template<typename _RandomNumberEngine, size_t __k>
+ inline bool
+ operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
+ __k>& __lhs,
+ const std::shuffle_order_engine<_RandomNumberEngine,
+ __k>& __rhs)
+ { return !(__lhs == __rhs); }
+
+
+ /**
* The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
*/
typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
b() const
{ return _M_b; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
private:
_IntType _M_a;
_IntType _M_b;
};
/**
+ * @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 _IntType>
+ inline bool
+ operator!=(const std::uniform_int_distribution<_IntType>& __d1,
+ const std::uniform_int_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %uniform_int_distribution random number
* distribution @p __x into the output stream @p os.
*
b() const
{ return _M_b; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
private:
_RealType _M_a;
_RealType _M_b;
};
/**
+ * @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.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::uniform_real_distribution<_IntType>& __d1,
+ const std::uniform_real_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %uniform_real_distribution random number
* distribution @p __x into the output stream @p __os.
*
stddev() const
{ return _M_stddev; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return (__p1._M_mean == __p2._M_mean
+ && __p1._M_stddev == __p2._M_stddev); }
+
private:
_RealType _M_mean;
_RealType _M_stddev;
const param_type& __p);
/**
+ * @brief Return true if two normal distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ template<typename _RealType1>
+ friend bool
+ operator==(const std::normal_distribution<_RealType1>& __d1,
+ const std::normal_distribution<_RealType1>& __d2);
+
+ /**
* @brief Inserts a %normal_distribution random number distribution
* @p __x into the output stream @p __os.
*
bool _M_saved_available;
};
+ /**
+ * @brief Return true if two normal distributions are different.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::normal_distribution<_RealType>& __d1,
+ const std::normal_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A lognormal_distribution random number distribution.
s() const
{ return _M_s; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
+
private:
_RealType _M_m;
_RealType _M_s;
{ return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
/**
+ * @brief Return true if two lognormal distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ template<typename _RealType1>
+ friend bool
+ operator==(const std::lognormal_distribution<_RealType1>& __d1,
+ const std::lognormal_distribution<_RealType1>& __d2)
+ { return (__d1.param() == __d2.param()
+ && __d1._M_nd == __d2._M_nd); }
+
+ /**
* @brief Inserts a %lognormal_distribution random number distribution
* @p __x into the output stream @p __os.
*
std::normal_distribution<result_type> _M_nd;
};
-
+ /**
+ * @brief Return true if two lognormal distributions are different.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::lognormal_distribution<_RealType>& __d1,
+ const std::lognormal_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
+
/**
* @brief A gamma continuous distribution for random numbers.
*
beta() const
{ return _M_beta; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return (__p1._M_alpha == __p2._M_alpha
+ && __p1._M_beta == __p2._M_beta); }
+
private:
void
_M_initialize();
const param_type& __p);
/**
+ * @brief Return true if two gamma distributions have the same
+ * parameters and the sequences that would be generated
+ * are equal.
+ */
+ template<typename _RealType1>
+ friend bool
+ operator==(const std::gamma_distribution<_RealType1>& __d1,
+ const std::gamma_distribution<_RealType1>& __d2)
+ { return (__d1.param() == __d2.param()
+ && __d1._M_nd == __d2._M_nd); }
+
+ /**
* @brief Inserts a %gamma_distribution random number distribution
* @p __x into the output stream @p __os.
*
std::normal_distribution<result_type> _M_nd;
};
+ /**
+ * @brief Return true if two gamma distributions are different.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::gamma_distribution<_RealType>& __d1,
+ const std::gamma_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A chi_squared_distribution random number distribution.
n() const
{ return _M_n; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_n == __p2._M_n; }
+
private:
_RealType _M_n;
};
}
/**
+ * @brief Return true if two Chi-squared distributions have
+ * the same parameters and the sequences that would be
+ * generated are equal.
+ */
+ template<typename _RealType1>
+ friend bool
+ operator==(const std::chi_squared_distribution<_RealType1>& __d1,
+ const std::chi_squared_distribution<_RealType1>& __d2)
+ { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
+
+ /**
* @brief Inserts a %chi_squared_distribution random number distribution
* @p __x into the output stream @p __os.
*
std::gamma_distribution<result_type> _M_gd;
};
+ /**
+ * @brief Return true if two Chi-squared distributions are different.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::chi_squared_distribution<_RealType>& __d1,
+ const std::chi_squared_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A cauchy_distribution random number distribution.
b() const
{ return _M_b; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
private:
_RealType _M_a;
_RealType _M_b;
};
/**
+ * @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.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::cauchy_distribution<_RealType>& __d1,
+ const std::cauchy_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %cauchy_distribution random number distribution
* @p __x into the output stream @p __os.
*
n() const
{ return _M_n; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
+
private:
_RealType _M_m;
_RealType _M_n;
}
/**
+ * @brief Return true if two Fisher f distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ template<typename _RealType1>
+ friend bool
+ operator==(const std::fisher_f_distribution<_RealType1>& __d1,
+ const std::fisher_f_distribution<_RealType1>& __d2)
+ { return (__d1.param() == __d2.param()
+ && __d1._M_gd_x == __d2._M_gd_x
+ && __d1._M_gd_y == __d2._M_gd_y); }
+
+ /**
* @brief Inserts a %fisher_f_distribution random number distribution
* @p __x into the output stream @p __os.
*
std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
};
+ /**
+ * @brief Return true if two Fisher f distributions are diferent.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::fisher_f_distribution<_RealType>& __d1,
+ const std::fisher_f_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
/**
* @brief A student_t_distribution random number distribution.
n() const
{ return _M_n; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_n == __p2._M_n; }
+
private:
_RealType _M_n;
};
}
/**
+ * @brief Return true if two Student t distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ template<typename _RealType1>
+ friend bool
+ operator==(const std::student_t_distribution<_RealType1>& __d1,
+ const std::student_t_distribution<_RealType1>& __d2)
+ { return (__d1.param() == __d2.param()
+ && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
+
+ /**
* @brief Inserts a %student_t_distribution random number distribution
* @p __x into the output stream @p __os.
*
std::gamma_distribution<result_type> _M_gd;
};
+ /**
+ * @brief Return true if two Student t distributions are different.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::student_t_distribution<_RealType>& __d1,
+ const std::student_t_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
+
/* @} */ // group random_distributions_normal
/**
p() const
{ return _M_p; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_p == __p2._M_p; }
+
private:
double _M_p;
};
};
/**
+ * @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.
+ */
+ inline bool
+ operator!=(const std::bernoulli_distribution& __d1,
+ const std::bernoulli_distribution& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %bernoulli_distribution random number distribution
* @p __x into the output stream @p __os.
*
p() const
{ return _M_p; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
+
private:
void
_M_initialize();
max() const
{ return _M_param.t(); }
+ /**
+ * @brief Return true if two binomial distributions have
+ * the same parameters and the sequences that would
+ * be generated are equal.
+ */
+ template<typename _IntType1>
+ friend bool
+ operator==(const std::binomial_distribution<_IntType1>& __d1,
+ const std::binomial_distribution<_IntType1>& __d2)
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+ { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
+#else
+ { return __d1.param() == __d2.param(); }
+#endif
+
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
std::normal_distribution<double> _M_nd;
};
+ /**
+ * @brief Return true if two binomial distributions are different.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::binomial_distribution<_IntType>& __d1,
+ const std::binomial_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A discrete geometric random number distribution.
p() const
{ return _M_p; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_p == __p2._M_p; }
+
private:
void
_M_initialize()
};
/**
+ * @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.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::geometric_distribution<_IntType>& __d1,
+ const std::geometric_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %geometric_distribution random number distribution
* @p __x into the output stream @p __os.
*
p() const
{ return _M_p; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
+
private:
_IntType _M_k;
double _M_p;
const param_type& __p);
/**
+ * @brief Return true if two negative binomial distributions have
+ * the same parameters and the sequences that would be
+ * generated are equal.
+ */
+ template<typename _IntType1>
+ friend bool
+ operator==(const std::negative_binomial_distribution<_IntType1>& __d1,
+ const std::negative_binomial_distribution<_IntType1>& __d2)
+ { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
+
+ /**
* @brief Inserts a %negative_binomial_distribution random
* number distribution @p __x into the output stream @p __os.
*
std::gamma_distribution<double> _M_gd;
};
+ /**
+ * @brief Return true if two negative binomial distributions are different.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
+ const std::negative_binomial_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
+
/* @} */ // group random_distributions_bernoulli
/**
mean() const
{ return _M_mean; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_mean == __p2._M_mean; }
+
private:
// Hosts either log(mean) or the threshold of the simple method.
void
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
+ /**
+ * @brief Return true if two Poisson distributions have the same
+ * parameters and the sequences that would be generated
+ * are equal.
+ */
+ template<typename _IntType1>
+ friend bool
+ operator==(const std::poisson_distribution<_IntType1>& __d1,
+ const std::poisson_distribution<_IntType1>& __d2)
+#ifdef _GLIBCXX_USE_C99_MATH_TR1
+ { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
+#else
+ { return __d1.param() == __d2.param(); }
+#endif
+
/**
* @brief Inserts a %poisson_distribution random number distribution
* @p __x into the output stream @p __os.
};
/**
+ * @brief Return true if two Poisson distributions are different.
+ */
+ template<typename _IntType>
+ inline bool
+ operator!=(const std::poisson_distribution<_IntType>& __d1,
+ const std::poisson_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
+
+ /**
* @brief An exponential continuous distribution for random numbers.
*
* The formula for the exponential probability density function is
lambda() const
{ return _M_lambda; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_lambda == __p2._M_lambda; }
+
private:
_RealType _M_lambda;
};
};
/**
+ * @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 _RealType>
+ inline bool
+ operator!=(const std::exponential_distribution<_RealType>& __d1,
+ const std::exponential_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %exponential_distribution random number distribution
* @p __x into the output stream @p __os.
*
b() const
{ return _M_b; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
private:
_RealType _M_a;
_RealType _M_b;
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.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::weibull_distribution<_RealType>& __d1,
+ const std::weibull_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief Inserts a %weibull_distribution random number distribution
* @p __x into the output stream @p __os.
b() const
{ return _M_b; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
private:
_RealType _M_a;
_RealType _M_b;
};
/**
+ * @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 _RealType>
+ inline bool
+ operator!=(const std::extreme_value_distribution<_RealType>& __d1,
+ const std::extreme_value_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
+ /**
* @brief Inserts a %extreme_value_distribution random number distribution
* @p __x into the output stream @p __os.
*
probabilities() const
{ return _M_prob; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_prob == __p2._M_prob; }
+
private:
void
_M_initialize();
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 _IntType>
+ inline bool
+ operator!=(const std::discrete_distribution<_IntType>& __d1,
+ const std::discrete_distribution<_IntType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A piecewise_constant_distribution random number distribution.
densities() const
{ return _M_den; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
+
private:
void
_M_initialize();
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 _RealType>
+ inline bool
+ operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
+ const std::piecewise_constant_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/**
* @brief A piecewise_linear_distribution random number distribution.
densities() const
{ return _M_den; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return (__p1._M_int == __p2._M_int
+ && __p1._M_den == __p2._M_den); }
+
private:
void
_M_initialize();
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.
+ */
+ template<typename _RealType>
+ inline bool
+ operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
+ const std::piecewise_linear_distribution<_RealType>& __d2)
+ { return !(__d1 == __d2); }
+
/* @} */ // group random_distributions_poisson