From: Jonathan Wakely Date: Fri, 20 Jan 2017 15:28:48 +0000 (+0000) Subject: PR69240 Define inequality operators for param types X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=12905f106c1cc8c6757038e3c41df478077bb870;p=gcc.git PR69240 Define inequality operators for param types PR libstdc++/69240 * include/bits/random.h (uniform_real_distribution::param_type) (normal_distribution::param_type, lognormal_distribution::param_type) (gamma_distribution::param_type, chi_squared_distribution::param_type) (cauchy_distribution::param_type, fisher_f_distribution::param_type) (student_t_distribution::param_type) (bernoulli_distribution::param_type, binomial_distribution::param_type) (geometric_distribution::param_type) (negative_binomial_distribution::param_type) (poisson_distribution::param_type) (exponential_distribution::param_type) (weibull_distribution::param_type) (extreme_value_distribution::param_type) (discrete_distribution::param_type) (piecewise_constant_distribution::param_type) (piecewise_linear_distribution::param_type): Define operator!=. * include/bits/uniform_int_dist.h (uniform_int_distribution::param_type): Likewise. * include/ext/random (beta_distribution::param_type) (rice_distribution::param_type, nakagami_distribution::param_type) (pareto_distribution::param_type, k_distribution::param_type) (arcsine_distribution::param_type, hoyt_distribution::param_type) (triangular_distribution::param_type) (von_mises_distribution::param_type) (hypergeometric_distribution::param_type) (logistic_distribution::param_type) (uniform_on_sphere_distribution::param_type) (uniform_inside_sphere_distribution::param_type): Likewise. * testsuite/26_numerics/random/bernoulli_distribution/cons/parms.cc: Test construction with param_type. * testsuite/26_numerics/random/binomial_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/cauchy_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/chi_squared_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/exponential_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/extreme_value_distribution/cons/ parms.cc: Likewise. * testsuite/26_numerics/random/fisher_f_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/gamma_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/geometric_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/lognormal_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/negative_binomial_distribution/cons/ parms.cc: Likewise. * testsuite/26_numerics/random/normal_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/poisson_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/student_t_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/uniform_int_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/uniform_real_distribution/cons/parms.cc: Likewise. * testsuite/26_numerics/random/weibull_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/arcsine_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/beta_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/hoyt_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/hypergeometric_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/k_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/logistic_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/nakagami_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/normal_mv_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/pareto_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/rice_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/triangular_distribution/cons/parms.cc: Likewise. * testsuite/ext/random/uniform_inside_sphere_distribution/cons/ parms.cc: Likewise. * testsuite/ext/random/von_mises_distribution/cons/parms.cc: Likewise. From-SVN: r244722 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 5725179ac42..37edf6e080a 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,84 @@ 2017-01-20 Jonathan Wakely + PR libstdc++/69240 + * include/bits/random.h (uniform_real_distribution::param_type) + (normal_distribution::param_type, lognormal_distribution::param_type) + (gamma_distribution::param_type, chi_squared_distribution::param_type) + (cauchy_distribution::param_type, fisher_f_distribution::param_type) + (student_t_distribution::param_type) + (bernoulli_distribution::param_type, binomial_distribution::param_type) + (geometric_distribution::param_type) + (negative_binomial_distribution::param_type) + (poisson_distribution::param_type) + (exponential_distribution::param_type) + (weibull_distribution::param_type) + (extreme_value_distribution::param_type) + (discrete_distribution::param_type) + (piecewise_constant_distribution::param_type) + (piecewise_linear_distribution::param_type): Define operator!=. + * include/bits/uniform_int_dist.h + (uniform_int_distribution::param_type): Likewise. + * include/ext/random (beta_distribution::param_type) + (rice_distribution::param_type, nakagami_distribution::param_type) + (pareto_distribution::param_type, k_distribution::param_type) + (arcsine_distribution::param_type, hoyt_distribution::param_type) + (triangular_distribution::param_type) + (von_mises_distribution::param_type) + (hypergeometric_distribution::param_type) + (logistic_distribution::param_type) + (uniform_on_sphere_distribution::param_type) + (uniform_inside_sphere_distribution::param_type): Likewise. + * testsuite/26_numerics/random/bernoulli_distribution/cons/parms.cc: + Test construction with param_type. + * testsuite/26_numerics/random/binomial_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/cauchy_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/chi_squared_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/exponential_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/extreme_value_distribution/cons/ + parms.cc: Likewise. + * testsuite/26_numerics/random/fisher_f_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/gamma_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/geometric_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/lognormal_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/negative_binomial_distribution/cons/ + parms.cc: Likewise. + * testsuite/26_numerics/random/normal_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/poisson_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/student_t_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/uniform_int_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/uniform_real_distribution/cons/parms.cc: + Likewise. + * testsuite/26_numerics/random/weibull_distribution/cons/parms.cc: + Likewise. + * testsuite/ext/random/arcsine_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/beta_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/hoyt_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/hypergeometric_distribution/cons/parms.cc: + Likewise. + * testsuite/ext/random/k_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/logistic_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/nakagami_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/normal_mv_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/pareto_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/rice_distribution/cons/parms.cc: Likewise. + * testsuite/ext/random/triangular_distribution/cons/parms.cc: + Likewise. + * testsuite/ext/random/uniform_inside_sphere_distribution/cons/ + parms.cc: Likewise. + * testsuite/ext/random/von_mises_distribution/cons/parms.cc: Likewise. + PR libstdc++/72792 * include/bits/alloc_traits.h (__allocator_traits_base::__diff_type) (__allocator_traits_base::__size_type): Remove. diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h index 2586cbc5b3d..d39cc3e0666 100644 --- a/libstdc++-v3/include/bits/random.h +++ b/libstdc++-v3/include/bits/random.h @@ -1707,6 +1707,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -1732,6 +1733,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_a; _RealType _M_b; @@ -1925,6 +1930,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -1951,6 +1957,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return (__p1._M_mean == __p2._M_mean && __p1._M_stddev == __p2._M_stddev); } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_mean; _RealType _M_stddev; @@ -2138,6 +2148,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2161,6 +2172,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_m; _RealType _M_s; @@ -2342,6 +2357,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2370,6 +2386,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return (__p1._M_alpha == __p2._M_alpha && __p1._M_beta == __p2._M_beta); } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -2559,6 +2579,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2577,6 +2598,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_n == __p2._M_n; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_n; }; @@ -2769,6 +2794,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2792,6 +2818,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_a; _RealType _M_b; @@ -2970,6 +3000,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2993,6 +3024,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_m; _RealType _M_n; @@ -3194,6 +3229,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -3212,6 +3248,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_n == __p2._M_n; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_n; }; @@ -3409,6 +3449,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef bool result_type; + /** Parameter type. */ struct param_type { @@ -3429,6 +3470,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_p == __p2._M_p; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: double _M_p; }; @@ -3617,6 +3662,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _IntType result_type; + /** Parameter type. */ struct param_type { @@ -3645,6 +3691,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -3848,6 +3898,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _IntType result_type; + /** Parameter type. */ struct param_type { @@ -3870,6 +3921,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_p == __p2._M_p; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize() @@ -4048,6 +4103,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _IntType result_type; + /** Parameter type. */ struct param_type { @@ -4072,6 +4128,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _IntType _M_k; double _M_p; @@ -4270,6 +4330,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _IntType result_type; + /** Parameter type. */ struct param_type { @@ -4292,6 +4353,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_mean == __p2._M_mean; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: // Hosts either log(mean) or the threshold of the simple method. void @@ -4486,6 +4551,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -4506,6 +4572,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_lambda == __p2._M_lambda; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_lambda; }; @@ -4688,6 +4758,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -4711,6 +4782,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_a; _RealType _M_b; @@ -4891,6 +4966,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -4914,6 +4990,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_a; _RealType _M_b; @@ -5091,6 +5171,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _IntType result_type; + /** Parameter type. */ struct param_type { @@ -5127,6 +5208,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_prob == __p2._M_prob; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -5321,6 +5406,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -5368,6 +5454,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -5588,6 +5678,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -5633,8 +5724,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return (__p1._M_int == __p2._M_int - && __p1._M_den == __p2._M_den); } + { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: void diff --git a/libstdc++-v3/include/bits/uniform_int_dist.h b/libstdc++-v3/include/bits/uniform_int_dist.h index a226a9ec541..af7ac14bccf 100644 --- a/libstdc++-v3/include/bits/uniform_int_dist.h +++ b/libstdc++-v3/include/bits/uniform_int_dist.h @@ -91,6 +91,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _IntType _M_a; _IntType _M_b; @@ -363,6 +367,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION *__f++ = __uctype(__urng()) - __urngmin + __param.a(); } + // operator!= and operator<< and operator>> are defined in + _GLIBCXX_END_NAMESPACE_VERSION } // namespace std diff --git a/libstdc++-v3/include/ext/random b/libstdc++-v3/include/ext/random index 6a3aaaca33d..d93757b08dd 100644 --- a/libstdc++-v3/include/ext/random +++ b/libstdc++-v3/include/ext/random @@ -404,6 +404,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -432,6 +433,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return (__p1._M_alpha == __p2._M_alpha && __p1._M_beta == __p2._M_beta); } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -710,6 +715,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_mean == __p2._M_mean && __p1._M_t == __p2._M_t; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: template void _M_init_full(_InputIterator1 __meanbegin, @@ -942,6 +951,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -965,8 +975,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return __p1._M_nu == __p2._M_nu - && __p1._M_sigma == __p2._M_sigma; } + { return __p1._M_nu == __p2._M_nu && __p1._M_sigma == __p2._M_sigma; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: void _M_initialize(); @@ -1184,6 +1197,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -1207,8 +1221,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return __p1._M_mu == __p2._M_mu - && __p1._M_omega == __p2._M_omega; } + { return __p1._M_mu == __p2._M_mu && __p1._M_omega == __p2._M_omega; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: void _M_initialize(); @@ -1417,6 +1434,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -1442,6 +1460,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_alpha == __p2._M_alpha && __p1._M_mu == __p2._M_mu; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -1651,6 +1673,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -1680,9 +1703,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return __p1._M_lambda == __p2._M_lambda + { + return __p1._M_lambda == __p2._M_lambda && __p1._M_mu == __p2._M_mu - && __p1._M_nu == __p2._M_nu; } + && __p1._M_nu == __p2._M_nu; + } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: void _M_initialize(); @@ -1890,6 +1919,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -1914,6 +1944,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: void _M_initialize(); @@ -2126,6 +2160,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2149,8 +2184,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return __p1._M_q == __p2._M_q - && __p1._M_omega == __p2._M_omega; } + { return __p1._M_q == __p2._M_q && __p1._M_omega == __p2._M_omega; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: void _M_initialize(); @@ -2359,6 +2397,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -2393,8 +2432,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return (__p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b - && __p1._M_c == __p2._M_c); } + { + return (__p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b + && __p1._M_c == __p2._M_c); + } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: @@ -2646,8 +2691,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return (__p1._M_mu == __p2._M_mu - && __p1._M_kappa == __p2._M_kappa); } + { return __p1._M_mu == __p2._M_mu && __p1._M_kappa == __p2._M_kappa; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: _RealType _M_mu; @@ -2889,6 +2937,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION && (__p1._M_K == __p2._M_K) && (__p1._M_n == __p2._M_n); } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: result_type _M_N; @@ -3111,6 +3163,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef _RealType result_type; + /** Parameter type. */ struct param_type { @@ -3133,8 +3186,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const param_type& __p1, const param_type& __p2) - { return __p1._M_a == __p2._M_a - && __p1._M_b == __p2._M_b; } + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } private: void _M_initialize(); @@ -3317,6 +3373,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: /** The type of the range of the distribution. */ typedef std::array<_RealType, _Dimen> result_type; + /** Parameter type. */ struct param_type { @@ -3325,8 +3382,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } friend bool - operator==(const param_type& __p1, const param_type& __p2) + operator==(const param_type&, const param_type&) { return true; } + + friend bool + operator!=(const param_type&, const param_type&) + { return false; } }; /** @@ -3530,6 +3591,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_radius == __p2._M_radius; } + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + private: _RealType _M_radius; }; diff --git a/libstdc++-v3/testsuite/26_numerics/random/bernoulli_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/bernoulli_distribution/cons/parms.cc index b1b246d838e..34657e11491 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/bernoulli_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/bernoulli_distribution/cons/parms.cc @@ -35,8 +35,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::bernoulli_distribution::param_type; + const param_type p(0.75); + std::bernoulli_distribution u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == std::numeric_limits::min() ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/binomial_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/binomial_distribution/cons/parms.cc index 12747f23a69..74f0ea6e428 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/binomial_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/binomial_distribution/cons/parms.cc @@ -36,8 +36,20 @@ test01() VERIFY( u.max() == u.t() ); } +void +test02() +{ + using param_type = std::binomial_distribution<>::param_type; + const param_type p(3, 0.75); + std::binomial_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == 0 ); + VERIFY( u.max() == u.t() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/cauchy_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/cauchy_distribution/cons/parms.cc index 63e7efe2a8b..a28819d71a4 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/cauchy_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/cauchy_distribution/cons/parms.cc @@ -37,8 +37,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::cauchy_distribution<>::param_type; + const param_type p(5.0, 2.0); + std::cauchy_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::cauchy_distribution<>::result_type result_type; + VERIFY( u.min() == std::numeric_limits::lowest() ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/cons/parms.cc index b6d26e26570..ad1b079a8ea 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/cons/parms.cc @@ -36,8 +36,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::chi_squared_distribution<>::param_type; + const param_type p(1.5); + std::chi_squared_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::chi_squared_distribution<>::result_type result_type; + VERIFY( u.min() == 0.0 ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/exponential_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/exponential_distribution/cons/parms.cc index 94d61e1febe..38e6c8d4aaa 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/exponential_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/exponential_distribution/cons/parms.cc @@ -36,8 +36,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::exponential_distribution<>::param_type; + const param_type p(0.5); + std::exponential_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::exponential_distribution<>::result_type result_type; + VERIFY( u.min() == 0.0 ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/extreme_value_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/extreme_value_distribution/cons/parms.cc index 8dc1daf8920..019cb213cac 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/extreme_value_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/extreme_value_distribution/cons/parms.cc @@ -37,8 +37,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::extreme_value_distribution<>::param_type; + const param_type p(5.0, 2.0); + std::extreme_value_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::extreme_value_distribution<>::result_type result_type; + VERIFY( u.min() == std::numeric_limits::lowest() ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/fisher_f_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/fisher_f_distribution/cons/parms.cc index 2a0cf71703d..969b3d15045 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/fisher_f_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/fisher_f_distribution/cons/parms.cc @@ -37,8 +37,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::fisher_f_distribution<>::param_type; + const param_type p(0.75); + std::fisher_f_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::fisher_f_distribution<>::result_type result_type; + VERIFY( u.min() == 0.0 ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/gamma_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/gamma_distribution/cons/parms.cc index ec291cfba6d..589fd891c0d 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/gamma_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/gamma_distribution/cons/parms.cc @@ -37,8 +37,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::gamma_distribution<>::param_type; + const param_type p(1.5, 3.0); + std::gamma_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::gamma_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/geometric_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/geometric_distribution/cons/parms.cc index 618b2bf627a..f10c46f7e50 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/geometric_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/geometric_distribution/cons/parms.cc @@ -36,8 +36,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::geometric_distribution<>::param_type; + const param_type p(0.75); + std::geometric_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::geometric_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/lognormal_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/lognormal_distribution/cons/parms.cc index fed2756fb65..6548f60fce4 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/lognormal_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/lognormal_distribution/cons/parms.cc @@ -37,8 +37,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::lognormal_distribution<>::param_type; + const param_type p(5.0, 2.0); + std::lognormal_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::lognormal_distribution<>::result_type result_type; + VERIFY( u.min() == 0.0 ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/negative_binomial_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/negative_binomial_distribution/cons/parms.cc index c94d4216b26..46e45f0bd23 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/negative_binomial_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/negative_binomial_distribution/cons/parms.cc @@ -37,8 +37,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::negative_binomial_distribution<>::param_type; + const param_type p(3, 0.75); + std::negative_binomial_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::negative_binomial_distribution<>::result_type result_type; + VERIFY( u.min() == 0 ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/normal_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/normal_distribution/cons/parms.cc index 04a24f8c418..770b51f9e4f 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/normal_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/normal_distribution/cons/parms.cc @@ -37,8 +37,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::normal_distribution<>::param_type; + const param_type p(5.0, 2.0); + std::normal_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::normal_distribution<>::result_type result_type; + VERIFY( u.min() == std::numeric_limits::lowest() ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/poisson_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/poisson_distribution/cons/parms.cc index 0881956259c..e91e9f60514 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/poisson_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/poisson_distribution/cons/parms.cc @@ -36,8 +36,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::poisson_distribution<>::param_type; + const param_type p(5.0); + std::poisson_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::poisson_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/student_t_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/student_t_distribution/cons/parms.cc index 28e025cd4a3..5ff8b7d495e 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/student_t_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/student_t_distribution/cons/parms.cc @@ -36,8 +36,21 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::student_t_distribution<>::param_type; + const param_type p(1.5); + std::student_t_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::student_t_distribution<>::result_type result_type; + VERIFY( u.min() == std::numeric_limits::lowest() ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/cons/parms.cc index d31152f282e..1a33918a67f 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/cons/parms.cc @@ -36,8 +36,20 @@ test01() VERIFY( u.max() == 20 ); } +void +test02() +{ + using param_type = std::uniform_int_distribution::param_type; + const param_type p(1, 20); + std::uniform_int_distribution u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == 1 ); + VERIFY( u.max() == 20 ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/uniform_real_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/uniform_real_distribution/cons/parms.cc index 212978b45e6..428638912a6 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/uniform_real_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/uniform_real_distribution/cons/parms.cc @@ -36,8 +36,20 @@ test01() VERIFY( u.max() == 5.0 ); } +void +test02() +{ + using param_type = std::uniform_real_distribution::param_type; + const param_type p(-5.0, 5.0); + std::uniform_real_distribution u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == -5.0 ); + VERIFY( u.max() == 5.0 ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/26_numerics/random/weibull_distribution/cons/parms.cc b/libstdc++-v3/testsuite/26_numerics/random/weibull_distribution/cons/parms.cc index ba9d5c2efd0..c3638cb0e46 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/weibull_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/weibull_distribution/cons/parms.cc @@ -37,8 +37,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = std::weibull_distribution<>::param_type; + const param_type p(2.0, 3.5); + std::weibull_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef std::weibull_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/arcsine_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/arcsine_distribution/cons/parms.cc index 3f17deaee2a..9c5e8b6a5f1 100644 --- a/libstdc++-v3/testsuite/ext/random/arcsine_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/arcsine_distribution/cons/parms.cc @@ -33,9 +33,20 @@ test01() VERIFY( u.max() == 3.0 ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::arcsine_distribution<>::param_type; + const param_type p(-1.5, 3.0); + __gnu_cxx::arcsine_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == -1.5 ); + VERIFY( u.max() == 3.0 ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/beta_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/beta_distribution/cons/parms.cc index 70709a02c86..a9ea0332c61 100644 --- a/libstdc++-v3/testsuite/ext/random/beta_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/beta_distribution/cons/parms.cc @@ -34,8 +34,20 @@ test01() VERIFY( u.max() == 1.0 ); } +void +test02() +{ + using param_type = __gnu_cxx::beta_distribution<>::param_type; + const param_type p(1.5, 3.0); + __gnu_cxx::beta_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == 0.0 ); + VERIFY( u.max() == 1.0 ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/hoyt_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/hoyt_distribution/cons/parms.cc index 6ecc5f821de..61149ea5b6f 100644 --- a/libstdc++-v3/testsuite/ext/random/hoyt_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/hoyt_distribution/cons/parms.cc @@ -34,9 +34,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::hoyt_distribution<>::param_type; + const param_type p(0.05, 3.0); + __gnu_cxx::hoyt_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef __gnu_cxx::hoyt_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/hypergeometric_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/hypergeometric_distribution/cons/parms.cc index e8c12e647d1..d8cb70a8a91 100644 --- a/libstdc++-v3/testsuite/ext/random/hypergeometric_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/hypergeometric_distribution/cons/parms.cc @@ -37,9 +37,20 @@ test01() VERIFY( u.max() == 2 ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::hypergeometric_distribution<>::param_type; + const param_type p(15, 3, 2); + __gnu_cxx::hypergeometric_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == 0 ); + VERIFY( u.max() == 2 ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/k_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/k_distribution/cons/parms.cc index d73871167f7..19aa8ffe675 100644 --- a/libstdc++-v3/testsuite/ext/random/k_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/k_distribution/cons/parms.cc @@ -38,9 +38,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::k_distribution<>::param_type; + const param_type p(2.0, 1.5, 3.0); + __gnu_cxx::k_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef __gnu_cxx::k_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/logistic_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/logistic_distribution/cons/parms.cc index 35d602ff64e..1ec3bf3df23 100644 --- a/libstdc++-v3/testsuite/ext/random/logistic_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/logistic_distribution/cons/parms.cc @@ -38,9 +38,22 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::logistic_distribution<>::param_type; + const param_type p(1.5, 3.0); + __gnu_cxx::logistic_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + + typedef __gnu_cxx::logistic_distribution<>::result_type result_type; + VERIFY( u.min() == -std::numeric_limits::max() ); + VERIFY( u.max() == std::numeric_limits::max() ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/nakagami_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/nakagami_distribution/cons/parms.cc index adb7fc66d11..f2d187fa0ed 100644 --- a/libstdc++-v3/testsuite/ext/random/nakagami_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/nakagami_distribution/cons/parms.cc @@ -37,9 +37,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::nakagami_distribution<>::param_type; + const param_type p(1.5, 3.0); + __gnu_cxx::nakagami_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef __gnu_cxx::nakagami_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/normal_mv_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/normal_mv_distribution/cons/parms.cc index b4b0ff8725b..35ba4c46f59 100644 --- a/libstdc++-v3/testsuite/ext/random/normal_mv_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/normal_mv_distribution/cons/parms.cc @@ -40,8 +40,23 @@ test01() VERIFY( u.max()[1] == std::numeric_limits::max() ); } +void +test02() +{ + using param_type = __gnu_cxx::normal_mv_distribution<2>::param_type; + const param_type p({5.0, 4.0}, {4.0, 9.0}); + __gnu_cxx::normal_mv_distribution<2> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef __gnu_cxx::normal_mv_distribution<2>::result_type result_type; + VERIFY( u.min()[0] == std::numeric_limits::lowest() ); + VERIFY( u.max()[0] == std::numeric_limits::max() ); + VERIFY( u.min()[1] == std::numeric_limits::lowest() ); + VERIFY( u.max()[1] == std::numeric_limits::max() ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/pareto_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/pareto_distribution/cons/parms.cc index 5a24658eed6..7bbc2f0a86c 100644 --- a/libstdc++-v3/testsuite/ext/random/pareto_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/pareto_distribution/cons/parms.cc @@ -37,9 +37,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::pareto_distribution<>::param_type; + const param_type p(1.5, 3.0); + __gnu_cxx::pareto_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef __gnu_cxx::pareto_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/rice_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/rice_distribution/cons/parms.cc index 04e34f352e4..d8cbcda93f7 100644 --- a/libstdc++-v3/testsuite/ext/random/rice_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/rice_distribution/cons/parms.cc @@ -37,9 +37,20 @@ test01() VERIFY( u.max() == std::numeric_limits::max() ); } -int -main() +void +test02() +{ + using param_type = __gnu_cxx::rice_distribution<>::param_type; + const param_type p(1.5, 3.0); + __gnu_cxx::rice_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + typedef __gnu_cxx::rice_distribution<>::result_type result_type; + VERIFY( u.max() == std::numeric_limits::max() ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/triangular_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/triangular_distribution/cons/parms.cc index 1a6c2b04a22..1c71f6cbda1 100644 --- a/libstdc++-v3/testsuite/ext/random/triangular_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/triangular_distribution/cons/parms.cc @@ -35,8 +35,20 @@ test01() VERIFY( u.max() == 3.5 ); } +void +test02() +{ + using param_type = __gnu_cxx::triangular_distribution<>::param_type; + const param_type p(1.5, 3.0, 3.5); + __gnu_cxx::triangular_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == 1.5 ); + VERIFY( u.max() == 3.5 ); +} + int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/uniform_inside_sphere_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/uniform_inside_sphere_distribution/cons/parms.cc index f33626593ae..5752691e1f2 100644 --- a/libstdc++-v3/testsuite/ext/random/uniform_inside_sphere_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/uniform_inside_sphere_distribution/cons/parms.cc @@ -27,8 +27,6 @@ void test01() { - bool test [[gnu::unused]] = true; - __gnu_cxx::uniform_inside_sphere_distribution<2> u(1.5); VERIFY( u.radius() == 1.5 ); @@ -36,9 +34,19 @@ test01() VERIFY( v.radius() == 3.0 ); } -int -main() +void +test02() +{ + using param_type + = __gnu_cxx::uniform_inside_sphere_distribution<2>::param_type; + const param_type p(1.5); + __gnu_cxx::uniform_inside_sphere_distribution<2> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); +} + +int main() { test01(); - return 0; + test02(); } diff --git a/libstdc++-v3/testsuite/ext/random/von_mises_distribution/cons/parms.cc b/libstdc++-v3/testsuite/ext/random/von_mises_distribution/cons/parms.cc index 79e44331334..0cfe3ded700 100644 --- a/libstdc++-v3/testsuite/ext/random/von_mises_distribution/cons/parms.cc +++ b/libstdc++-v3/testsuite/ext/random/von_mises_distribution/cons/parms.cc @@ -34,8 +34,20 @@ test01() VERIFY( u.max() == __gnu_cxx::__math_constants::__pi ); } +void +test02() +{ + using param_type = __gnu_cxx::von_mises_distribution<>::param_type; + const param_type p(1.5, 3.0); + __gnu_cxx::von_mises_distribution<> u(p); + VERIFY( u.param() == p ); + VERIFY( u.param() != param_type{} ); + VERIFY( u.min() == -__gnu_cxx::__math_constants::__pi ); + VERIFY( u.max() == __gnu_cxx::__math_constants::__pi ); +} + int main() { test01(); - return 0; + test02(); }