From 8934fd1b9fcfc577e5e88fd23b4e631874229af7 Mon Sep 17 00:00:00 2001 From: Matt Stephanson Date: Tue, 14 Sep 2021 19:30:50 -0700 Subject: [PATCH 1/7] Dedicated macro for [[nodiscard]] hidden friends --- stl/inc/iterator | 10 ++-------- stl/inc/random | 22 ++++++---------------- stl/inc/xhash | 10 ++-------- stl/inc/yvals_core.h | 6 ++++++ 4 files changed, 16 insertions(+), 32 deletions(-) diff --git a/stl/inc/iterator b/stl/inc/iterator index 95baaec830e..101862d028e 100644 --- a/stl/inc/iterator +++ b/stl/inc/iterator @@ -1451,10 +1451,7 @@ public: return _Tmp; } -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend constexpr checked_array_iterator operator+( + _NODISCARD_FRIEND constexpr checked_array_iterator operator+( const difference_type _Off, const checked_array_iterator<_Ptr>& _Next) noexcept { return _Next + _Off; } @@ -1630,10 +1627,7 @@ public: return _Tmp; } -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend constexpr unchecked_array_iterator operator+( + _NODISCARD_FRIEND constexpr unchecked_array_iterator operator+( const difference_type _Off, const unchecked_array_iterator& _Next) noexcept { return _Next + _Off; } diff --git a/stl/inc/random b/stl/inc/random index 2ed8c68bb06..53a76d7bfb9 100644 --- a/stl/inc/random +++ b/stl/inc/random @@ -422,18 +422,14 @@ public: _Prev = _Temp; } -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend bool operator==(const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept + _NODISCARD_FRIEND bool operator==( + const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept /* strengthened */ { return _Lhs._Prev == _Rhs._Prev; } -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend bool operator!=(const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept + _NODISCARD_FRIEND bool operator!=( + const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept /* strengthened */ { return _Lhs._Prev != _Rhs._Prev; } @@ -515,18 +511,12 @@ public: _Prev = _Temp; } -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend bool operator==(const linear_congruential& _Lhs, const linear_congruential& _Rhs) noexcept + _NODISCARD_FRIEND bool operator==(const linear_congruential& _Lhs, const linear_congruential& _Rhs) noexcept /* strengthened */ { return _Lhs._Prev == _Rhs._Prev; } -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend bool operator!=(const linear_congruential& _Lhs, const linear_congruential& _Rhs) noexcept + _NODISCARD_FRIEND bool operator!=(const linear_congruential& _Lhs, const linear_congruential& _Rhs) noexcept /* strengthened */ { return _Lhs._Prev != _Rhs._Prev; } diff --git a/stl/inc/xhash b/stl/inc/xhash index 33df721894c..70e2956e833 100644 --- a/stl/inc/xhash +++ b/stl/inc/xhash @@ -185,18 +185,12 @@ struct _Reinterpret_move_iter { // post ++ intentionally omitted -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend bool operator==(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) { + _NODISCARD_FRIEND bool operator==(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) { return _Lhs._Base == _Rhs._Base; } #if !_HAS_CXX20 -#ifndef __CUDACC__ // TRANSITION, VSO-568006 - _NODISCARD -#endif // TRANSITION, VSO-568006 - friend bool operator!=(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) { + _NODISCARD_FRIEND bool operator!=(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) { return _Lhs._Base != _Rhs._Base; } #endif // !_HAS_CXX20 diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 4d245fd85a6..3abb37b8d3b 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -422,6 +422,12 @@ #define _NODISCARD_CTOR #endif +#ifndef __CUDACC__ // TRANSITION, VSO-568006 +#define _NODISCARD_FRIEND _NODISCARD friend +#else +#define _NODISCARD_FRIEND friend +#endif // TRANSITION, VSO-568006 + // Determine if we should use [[msvc::known_semantics]] to communicate to the compiler // that certain type trait specializations have the standard-mandated semantics #ifndef __has_cpp_attribute From 9ff7b4a31850b1f714c44a7116901aed573b3d6f Mon Sep 17 00:00:00 2001 From: Matt Stephanson Date: Tue, 14 Sep 2021 21:52:22 -0700 Subject: [PATCH 2/7] convert to hidden friends --- stl/inc/random | 1336 +++++++++++++++++++++++++----------------------- 1 file changed, 686 insertions(+), 650 deletions(-) diff --git a/stl/inc/random b/stl/inc/random index 53a76d7bfb9..866e5892032 100644 --- a/stl/inc/random +++ b/stl/inc/random @@ -428,11 +428,13 @@ public: return _Lhs._Prev == _Rhs._Prev; } +#if !_HAS_CXX20 _NODISCARD_FRIEND bool operator!=( const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept /* strengthened */ { return _Lhs._Prev != _Rhs._Prev; } +#endif // !_HAS_CXX20 template friend basic_istream<_Elem, _Traits>& operator>>( @@ -516,10 +518,12 @@ public: return _Lhs._Prev == _Rhs._Prev; } +#if !_HAS_CXX20 _NODISCARD_FRIEND bool operator!=(const linear_congruential& _Lhs, const linear_congruential& _Rhs) noexcept /* strengthened */ { return _Lhs._Prev != _Rhs._Prev; } +#endif // !_HAS_CXX20 template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, linear_congruential& _Eng) { @@ -654,6 +658,30 @@ public: } } + _NODISCARD_FRIEND bool operator==(const _Swc_base& _Left, const _Swc_base& _Right) { + return _Left._Equals(_Right); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const _Swc_base& _Left, const _Swc_base& _Right) { + return !_Left._Equals(_Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>( + basic_istream<_Elem, _Traits>& _Istr, _Swc_base& _Eng) { // read state from _Istr + _Wrap_istream<_Elem, _Traits, typename _Swc_Traits::_Seed_t> _Gen(_Istr); + _Eng.seed(_Gen, true); + return _Istr; + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const _Swc_base& _Eng) { // write state to _Ostr + return _Eng._Write(_Ostr); + } + bool _Equals(const _Swc_base& _Right) const { return _Mybase::_Equals(_Right) && _Carry == _Right._Carry; } @@ -708,32 +736,6 @@ protected: typename _Swc_Traits::_Cy_t _Carry; }; -template -_NODISCARD bool operator==( - const _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>& _Left, const _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>& _Right) { - return _Left._Equals(_Right); -} - -template -_NODISCARD bool operator!=( - const _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>& _Left, const _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>& _Right) { - return !_Left._Equals(_Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>( - basic_istream<_Elem, _Traits>& _Istr, _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>& _Eng) { // read state from _Istr - _Wrap_istream<_Elem, _Traits, typename _Swc_Traits::_Seed_t> _Gen(_Istr); - _Eng.seed(_Gen, true); - return _Istr; -} - -template -basic_ostream<_Elem, _Traits>& operator<<( - basic_ostream<_Elem, _Traits>& _Ostr, const _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); -} - template const size_t _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>::short_lag; @@ -1047,6 +1049,30 @@ public: this->_Idx = _Nx; } + _NODISCARD_FRIEND bool operator==(const mersenne_twister& _Left, const mersenne_twister& _Right) { + return _Left._Equals(_Right); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const mersenne_twister& _Left, const mersenne_twister& _Right) { + return !_Left._Equals(_Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _S_Traits>& operator>>(basic_istream<_Elem, _S_Traits>& _Istr, + mersenne_twister& _Eng) { // read state from _Istr + _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr); + _Eng.seed(_Gen); + return _Istr; + } + + template + friend basic_ostream<_Elem, _S_Traits>& operator<<(basic_ostream<_Elem, _S_Traits>& _Ostr, + const mersenne_twister& _Eng) { // write state to _Ostr + return _Eng._Write(_Ostr); + } + template basic_ostream<_Elem, _S_Traits>& _Write(basic_ostream<_Elem, _S_Traits>& _Ostr) const { // write state to _Ostr _Ostr << this->_At(0); @@ -1146,34 +1172,6 @@ protected: static constexpr int _M_mod_n = _Mx % _Nx; }; -template -_NODISCARD bool operator==(const mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>& _Left, - const mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>& _Right) { - return _Left._Equals(_Right); -} - -template -_NODISCARD bool operator!=(const mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>& _Left, - const mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>& _Right) { - return !_Left._Equals(_Right); -} - -template -basic_istream<_Elem, _S_Traits>& operator>>(basic_istream<_Elem, _S_Traits>& _Istr, - mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>& _Eng) { // read state from _Istr - _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr); - _Eng.seed(_Gen); - return _Istr; -} - -template -basic_ostream<_Elem, _S_Traits>& operator<<(basic_ostream<_Elem, _S_Traits>& _Ostr, - const mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); -} - template class mersenne_twister_engine : public mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx> { @@ -1322,6 +1320,28 @@ public: } } + _NODISCARD_FRIEND bool operator==(const discard_block& _Left, const discard_block& _Right) { + return _Left._Equals(_Right); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const discard_block& _Left, const discard_block& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>( + basic_istream<_Elem, _Traits>& _Istr, discard_block& _Eng) { // read state from _Istr + return _Eng._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<( + basic_ostream<_Elem, _Traits>& _Ostr, const discard_block& _Eng) { // write state to _Ostr + return _Eng._Write(_Ostr); + } + bool _Equals(const discard_block& _Right) const { return _Eng == _Right._Eng && _Nx == _Right._Nx; } @@ -1347,30 +1367,6 @@ const int discard_block<_Engine, _Px, _Rx>::block_size; template const int discard_block<_Engine, _Px, _Rx>::used_block; -template -_NODISCARD bool operator==( - const discard_block<_Engine, _Px, _Rx>& _Left, const discard_block<_Engine, _Px, _Rx>& _Right) { - return _Left._Equals(_Right); -} - -template -_NODISCARD bool operator!=( - const discard_block<_Engine, _Px, _Rx>& _Left, const discard_block<_Engine, _Px, _Rx>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>( - basic_istream<_Elem, _Traits>& _Istr, discard_block<_Engine, _Px, _Rx>& _Eng) { // read state from _Istr - return _Eng._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<( - basic_ostream<_Elem, _Traits>& _Ostr, const discard_block<_Engine, _Px, _Rx>& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); -} - template class discard_block_engine : public discard_block<_Engine, _Px, _Rx> { // discard_block_engine compound engine public: @@ -1492,6 +1488,28 @@ public: } } + _NODISCARD_FRIEND bool operator==(const independent_bits_engine& _Left, const independent_bits_engine& _Right) { + return _Left.base() == _Right.base(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const independent_bits_engine& _Left, const independent_bits_engine& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + independent_bits_engine& _Eng) { // read state from _Istr + return _Eng._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const independent_bits_engine& _Eng) { // write state to _Ostr + return _Eng._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr return _Istr >> _Eng; @@ -1538,30 +1556,6 @@ private: _Eres _Yx1; // max value for larger packing word }; -template -_NODISCARD bool operator==(const independent_bits_engine<_Engine, _Wx, _UIntType>& _Left, - const independent_bits_engine<_Engine, _Wx, _UIntType>& _Right) { - return _Left.base() == _Right.base(); -} - -template -_NODISCARD bool operator!=(const independent_bits_engine<_Engine, _Wx, _UIntType>& _Left, - const independent_bits_engine<_Engine, _Wx, _UIntType>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - independent_bits_engine<_Engine, _Wx, _UIntType>& _Eng) { // read state from _Istr - return _Eng._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const independent_bits_engine<_Engine, _Wx, _UIntType>& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); -} - template class shuffle_order_engine { // shuffle_order_engine compound engine public: @@ -1635,6 +1629,28 @@ public: } } + _NODISCARD_FRIEND bool operator==(const shuffle_order_engine& _Left, const shuffle_order_engine& _Right) { + return _Left.base() == _Right.base(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const shuffle_order_engine& _Left, const shuffle_order_engine& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>( + basic_istream<_Elem, _Traits>& _Istr, shuffle_order_engine& _Eng) { // read state from _Istr + return _Eng._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<( + basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine& _Eng) { // write state to _Ostr + return _Eng._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Istr >> _Eng; @@ -1672,30 +1688,6 @@ private: double _Scale; }; -template -_NODISCARD bool operator==( - const shuffle_order_engine<_Engine, _Kx>& _Left, const shuffle_order_engine<_Engine, _Kx>& _Right) { - return _Left.base() == _Right.base(); -} - -template -_NODISCARD bool operator!=( - const shuffle_order_engine<_Engine, _Kx>& _Left, const shuffle_order_engine<_Engine, _Kx>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>( - basic_istream<_Elem, _Traits>& _Istr, shuffle_order_engine<_Engine, _Kx>& _Eng) { // read state from _Istr - return _Eng._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<( - basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine<_Engine, _Kx>& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); -} - template class uniform_int { // uniform integer distribution public: @@ -1712,13 +1704,15 @@ public: _Init(_Min0, _Max0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Min == _Right._Min && _Max == _Right._Max; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Min == _Right._Min && _Left._Max == _Right._Max; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD result_type a() const { return _Min; @@ -1785,6 +1779,18 @@ public: return _Eval(_Eng, 0, _Nx - 1); } + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + uniform_int& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const uniform_int& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Min0; @@ -1837,18 +1843,6 @@ private: param_type _Par; }; -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - uniform_int<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const uniform_int<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class uniform_int_distribution : public uniform_int<_Ty> { // uniform integer distribution public: @@ -1874,17 +1868,17 @@ public: explicit uniform_int_distribution(_Ty _Min0, _Ty _Max0 = (numeric_limits<_Ty>::max) ()) : _Mybase(_Min0, _Max0) {} explicit uniform_int_distribution(const param_type& _Par0) : _Mybase(_Par0) {} -}; -template -_NODISCARD bool operator==(const uniform_int_distribution<_Ty>& _Left, const uniform_int_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} + _NODISCARD_FRIEND bool operator==(const uniform_int_distribution& _Left, const uniform_int_distribution& _Right) { + return _Left.param() == _Right.param(); + } -template -_NODISCARD bool operator!=(const uniform_int_distribution<_Ty>& _Left, const uniform_int_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const uniform_int_distribution& _Left, const uniform_int_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 +}; class bernoulli_distribution { // class for bernoulli distribution public: @@ -1901,13 +1895,15 @@ public: _Init(_Px0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Px == _Right._Px; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Px == _Right._Px; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD double p() const { return _Px; @@ -1960,6 +1956,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + bernoulli_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const bernoulli_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr double _Px0; @@ -1983,26 +2001,6 @@ private: param_type _Par; }; -_NODISCARD inline bool operator==(const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) { - return _Left.param() == _Right.param(); -} - -_NODISCARD inline bool operator!=(const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - bernoulli_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const bernoulli_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - // Returns smallest _Flt such that static_cast<_Ty>(_Result) > _Val. // First truncate to largest _Flt <= _Val, then add ceil(ulp). @@ -2061,13 +2059,15 @@ public: _Init(_Px0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Px == _Right._Px; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Px == _Right._Px; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty1 p() const { return _Px; @@ -2121,6 +2121,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const geometric_distribution& _Left, const geometric_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const geometric_distribution& _Left, const geometric_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + geometric_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const geometric_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty1 _Px0; @@ -2152,28 +2174,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const geometric_distribution<_Ty>& _Left, const geometric_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const geometric_distribution<_Ty>& _Left, const geometric_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - geometric_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const geometric_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class _Small_poisson_distribution { // poisson distribution with small mean public: @@ -2220,13 +2220,15 @@ public: _Init(_Mean0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Mean == _Right._Mean; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Mean == _Right._Mean; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty1 mean() const { return _Mean; @@ -2287,6 +2289,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const poisson_distribution& _Left, const poisson_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const poisson_distribution& _Left, const poisson_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + poisson_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const poisson_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty1 _Mean0; @@ -2334,28 +2358,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const poisson_distribution<_Ty>& _Left, const poisson_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const poisson_distribution<_Ty>& _Left, const poisson_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - poisson_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const poisson_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class binomial_distribution { // binomial distribution public: @@ -2376,13 +2378,15 @@ public: _Init(_Tx0, _Px0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Tx == _Right._Tx && _Px == _Right._Px; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Tx == _Right._Tx && _Left._Px == _Right._Px; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty t() const { return _Tx; @@ -2460,6 +2464,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const binomial_distribution& _Left, const binomial_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const binomial_distribution& _Left, const binomial_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + binomial_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const binomial_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Tx0; @@ -2540,28 +2566,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const binomial_distribution<_Ty>& _Left, const binomial_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const binomial_distribution<_Ty>& _Left, const binomial_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - binomial_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const binomial_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class uniform_real { // uniform real distribution public: @@ -2578,13 +2582,15 @@ public: _Init(_Min0, _Max0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Min == _Right._Min && _Max == _Right._Max; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Min == _Right._Min && _Left._Max == _Right._Max; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD result_type a() const { return _Min; @@ -2647,6 +2653,18 @@ public: return _Eval(_Eng, _Par0); } + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + uniform_real& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const uniform_real& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Min0; @@ -2673,18 +2691,6 @@ private: param_type _Par; }; -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - uniform_real<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const uniform_real<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class uniform_real_distribution : public uniform_real<_Ty> { // uniform real distribution public: @@ -2709,17 +2715,17 @@ public: explicit uniform_real_distribution(_Ty _Min0, _Ty _Max0 = _Ty{1}) : _Mybase(_Min0, _Max0) {} explicit uniform_real_distribution(const param_type& _Par0) : _Mybase(_Par0) {} -}; -template -_NODISCARD bool operator==(const uniform_real_distribution<_Ty>& _Left, const uniform_real_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} + _NODISCARD_FRIEND bool operator==(const uniform_real_distribution& _Left, const uniform_real_distribution& _Right) { + return _Left.param() == _Right.param(); + } -template -_NODISCARD bool operator!=(const uniform_real_distribution<_Ty>& _Left, const uniform_real_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const uniform_real_distribution& _Left, const uniform_real_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 +}; template class exponential_distribution { // exponential distribution @@ -2739,13 +2745,15 @@ public: _Init(_Lambda0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Lambda == _Right._Lambda; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Lambda == _Right._Lambda; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty lambda() const { return _Lambda; @@ -2797,6 +2805,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const exponential_distribution& _Left, const exponential_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const exponential_distribution& _Left, const exponential_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + exponential_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const exponential_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Lambda0; @@ -2820,28 +2850,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const exponential_distribution<_Ty>& _Left, const exponential_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const exponential_distribution<_Ty>& _Left, const exponential_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - exponential_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const exponential_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class normal_distribution { // normal distribution public: @@ -2860,13 +2868,15 @@ public: _Init(_Mean0, _Sigma0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Mean == _Right._Mean && _Sigma == _Right._Sigma; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Mean == _Right._Mean && _Left._Sigma == _Right._Sigma; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty mean() const { return _Mean; @@ -2940,6 +2950,28 @@ public: return _Eval(_Eng, _Par0, false); } + _NODISCARD_FRIEND bool operator==(const normal_distribution& _Left, const normal_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const normal_distribution& _Left, const normal_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + normal_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const normal_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Mean0; @@ -3016,28 +3048,6 @@ private: _Ty _Xx2; }; -template -_NODISCARD bool operator==(const normal_distribution<_Ty>& _Left, const normal_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const normal_distribution<_Ty>& _Left, const normal_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - normal_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const normal_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class gamma_distribution { // gamma distribution public: @@ -3056,13 +3066,15 @@ public: _Init(_Alpha0, _Beta0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Alpha == _Right._Alpha && _Beta == _Right._Beta; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Alpha == _Right._Alpha && _Left._Beta == _Right._Beta; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty alpha() const { return _Alpha; @@ -3130,6 +3142,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const gamma_distribution& _Left, const gamma_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const gamma_distribution& _Left, const gamma_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + gamma_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const gamma_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Alpha0; @@ -3211,28 +3245,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const gamma_distribution<_Ty>& _Left, const gamma_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const gamma_distribution<_Ty>& _Left, const gamma_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - gamma_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const gamma_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class weibull_distribution { // weibull distribution public: @@ -3251,13 +3263,15 @@ public: _Init(_Ax0, _Bx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Ax == _Right._Ax && _Bx == _Right._Bx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty a() const { return _Ax; @@ -3320,6 +3334,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const weibull_distribution& _Left, const weibull_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const weibull_distribution& _Left, const weibull_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + weibull_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const weibull_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Ax0; @@ -3347,28 +3383,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const weibull_distribution<_Ty>& _Left, const weibull_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const weibull_distribution<_Ty>& _Left, const weibull_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - weibull_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const weibull_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class extreme_value_distribution { // extreme value distribution public: @@ -3387,13 +3401,15 @@ public: _Init(_Ax0, _Bx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Ax == _Right._Ax && _Bx == _Right._Bx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty a() const { return _Ax; @@ -3455,6 +3471,30 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==( + const extreme_value_distribution& _Left, const extreme_value_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=( + const extreme_value_distribution& _Left, const extreme_value_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + extreme_value_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const extreme_value_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Ax0; @@ -3482,30 +3522,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==( - const extreme_value_distribution<_Ty>& _Left, const extreme_value_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=( - const extreme_value_distribution<_Ty>& _Left, const extreme_value_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - extreme_value_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const extreme_value_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class lognormal_distribution { // lognormal_distribution public: @@ -3524,13 +3540,15 @@ public: _Init(_Mx0, _Sx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Mx == _Right._Mx && _Sx == _Right._Sx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Mx == _Right._Mx && _Left._Sx == _Right._Sx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty m() const { return _Mx; @@ -3592,6 +3610,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const lognormal_distribution& _Left, const lognormal_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const lognormal_distribution& _Left, const lognormal_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + lognormal_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const lognormal_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Mx0; @@ -3619,28 +3659,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const lognormal_distribution<_Ty>& _Left, const lognormal_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const lognormal_distribution<_Ty>& _Left, const lognormal_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - lognormal_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const lognormal_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class chi_squared_distribution { // chi squared distribution public: @@ -3659,13 +3677,15 @@ public: _Init(_Nx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Nx == _Right._Nx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Nx == _Right._Nx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty n() const { return _Nx; @@ -3717,6 +3737,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const chi_squared_distribution& _Left, const chi_squared_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const chi_squared_distribution& _Left, const chi_squared_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + chi_squared_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const chi_squared_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Nx0; @@ -3740,28 +3782,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const chi_squared_distribution<_Ty>& _Left, const chi_squared_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const chi_squared_distribution<_Ty>& _Left, const chi_squared_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - chi_squared_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const chi_squared_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class cauchy_distribution { // Cauchy distribution public: @@ -3780,13 +3800,15 @@ public: _Init(_Ax0, _Bx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Ax == _Right._Ax && _Bx == _Right._Bx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty a() const { return _Ax; @@ -3848,6 +3870,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const cauchy_distribution& _Left, const cauchy_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const cauchy_distribution& _Left, const cauchy_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + cauchy_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const cauchy_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Ax0; @@ -3875,28 +3919,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const cauchy_distribution<_Ty>& _Left, const cauchy_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const cauchy_distribution<_Ty>& _Left, const cauchy_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - cauchy_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const cauchy_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class _Beta_distribution { // beta distribution public: @@ -3974,13 +3996,15 @@ public: _Init(_Mx0, _Nx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Mx == _Right._Mx && _Nx == _Right._Nx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Mx == _Right._Mx && _Left._Nx == _Right._Nx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty m() const { return _Mx; @@ -4043,6 +4067,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const fisher_f_distribution& _Left, const fisher_f_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const fisher_f_distribution& _Left, const fisher_f_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + fisher_f_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const fisher_f_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Mx0; @@ -4081,28 +4127,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const fisher_f_distribution<_Ty>& _Left, const fisher_f_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const fisher_f_distribution<_Ty>& _Left, const fisher_f_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - fisher_f_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const fisher_f_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class student_t_distribution { // student_t distribution public: @@ -4121,13 +4145,15 @@ public: _Init(_Nx0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Nx == _Right._Nx; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Nx == _Right._Nx; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty n() const { return _Nx; @@ -4179,6 +4205,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const student_t_distribution& _Left, const student_t_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const student_t_distribution& _Left, const student_t_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + student_t_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const student_t_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Nx0; @@ -4217,28 +4265,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==(const student_t_distribution<_Ty>& _Left, const student_t_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const student_t_distribution<_Ty>& _Left, const student_t_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - student_t_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const student_t_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class negative_binomial_distribution { // negative binomial distribution public: @@ -4257,13 +4283,15 @@ public: _Init(_Kx0, _Px0); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Kx == _Right._Kx && _Px == _Right._Px; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Kx == _Right._Kx && _Left._Px == _Right._Px; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Ty k() const { return _Kx; @@ -4328,6 +4356,30 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==( + const negative_binomial_distribution& _Left, const negative_binomial_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=( + const negative_binomial_distribution& _Left, const negative_binomial_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + negative_binomial_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const negative_binomial_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Ty _Kx0; @@ -4360,30 +4412,6 @@ private: param_type _Par; }; -template -_NODISCARD bool operator==( - const negative_binomial_distribution<_Ty>& _Left, const negative_binomial_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=( - const negative_binomial_distribution<_Ty>& _Left, const negative_binomial_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - negative_binomial_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const negative_binomial_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class discrete_distribution { // discrete integer distribution public: @@ -4427,13 +4455,15 @@ public: _Init(); } - _NODISCARD bool operator==(const param_type& _Right) const { - return _Pvec == _Right._Pvec; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return _Left._Pvec == _Right._Pvec; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD _Myvec probabilities() const { return _Pvec; @@ -4517,6 +4547,28 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==(const discrete_distribution& _Left, const discrete_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const discrete_distribution& _Left, const discrete_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + discrete_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr, _Dist._Par); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const discrete_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr, _Dist._Par); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr, param_type& _Par0) { // read state from _Istr @@ -4558,28 +4610,6 @@ public: param_type _Par; }; -template -_NODISCARD bool operator==(const discrete_distribution<_Ty>& _Left, const discrete_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=(const discrete_distribution<_Ty>& _Left, const discrete_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - discrete_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr, _Dist._Par); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const discrete_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr, _Dist._Par); -} - template class piecewise_constant_distribution : public discrete_distribution { // piecewise constant floating-point distribution @@ -4636,13 +4666,16 @@ public: } } - _NODISCARD bool operator==(const param_type& _Right) const { - return static_cast(*this) == static_cast(_Right) && _Bvec == _Right._Bvec; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return static_cast(_Left) == static_cast(_Right) + && _Left._Bvec == _Right._Bvec; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD vector<_Ty> intervals() const { return _Bvec; @@ -4714,6 +4747,30 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==( + const piecewise_constant_distribution& _Left, const piecewise_constant_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=( + const piecewise_constant_distribution& _Left, const piecewise_constant_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + piecewise_constant_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const piecewise_constant_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr _Mybase::_Read(_Istr, _Par); @@ -4748,30 +4805,6 @@ public: param_type _Par; }; -template -_NODISCARD bool operator==( - const piecewise_constant_distribution<_Ty>& _Left, const piecewise_constant_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=( - const piecewise_constant_distribution<_Ty>& _Left, const piecewise_constant_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - piecewise_constant_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const piecewise_constant_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - template class piecewise_linear_distribution : public discrete_distribution { // piecewise linear floating-point distribution @@ -4836,13 +4869,16 @@ public: _Init(); } - _NODISCARD bool operator==(const param_type& _Right) const { - return static_cast(*this) == static_cast(_Right) && _Bvec == _Right._Bvec; + _NODISCARD_FRIEND bool operator==(const param_type& _Left, const param_type& _Right) { + return static_cast(_Left) == static_cast(_Right) + && _Left._Bvec == _Right._Bvec; } - _NODISCARD bool operator!=(const param_type& _Right) const { - return !(*this == _Right); +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=(const param_type& _Left, const param_type& _Right) { + return !(_Left == _Right); } +#endif // !_HAS_CXX20 _NODISCARD vector<_Ty> intervals() const { return _Bvec; @@ -4944,6 +4980,30 @@ public: return _Eval(_Eng, _Par0); } + _NODISCARD_FRIEND bool operator==( + const piecewise_linear_distribution& _Left, const piecewise_linear_distribution& _Right) { + return _Left.param() == _Right.param(); + } + +#if !_HAS_CXX20 + _NODISCARD_FRIEND bool operator!=( + const piecewise_linear_distribution& _Left, const piecewise_linear_distribution& _Right) { + return !(_Left == _Right); + } +#endif // !_HAS_CXX20 + + template + friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, + piecewise_linear_distribution& _Dist) { // read state from _Istr + return _Dist._Read(_Istr, _Dist._Par); + } + + template + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const piecewise_linear_distribution& _Dist) { // write state to _Ostr + return _Dist._Write(_Ostr); + } + template basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr, param_type& _Par0) { // read state from _Istr @@ -4996,30 +5056,6 @@ public: param_type _Par; }; -template -_NODISCARD bool operator==( - const piecewise_linear_distribution<_Ty>& _Left, const piecewise_linear_distribution<_Ty>& _Right) { - return _Left.param() == _Right.param(); -} - -template -_NODISCARD bool operator!=( - const piecewise_linear_distribution<_Ty>& _Left, const piecewise_linear_distribution<_Ty>& _Right) { - return !(_Left == _Right); -} - -template -basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, - piecewise_linear_distribution<_Ty>& _Dist) { // read state from _Istr - return _Dist._Read(_Istr, _Dist._Par); -} - -template -basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const piecewise_linear_distribution<_Ty>& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); -} - using minstd_rand0 = linear_congruential_engine; using minstd_rand = linear_congruential_engine; From 89b4676dc3c559df44577f724e6e2e6e1daa9c2a Mon Sep 17 00:00:00 2001 From: Matt Stephanson Date: Wed, 15 Sep 2021 23:39:45 -0700 Subject: [PATCH 3/7] inline various functions --- stl/inc/random | 575 +++++++++++++++---------------------------------- 1 file changed, 170 insertions(+), 405 deletions(-) diff --git a/stl/inc/random b/stl/inc/random index 866e5892032..a086ad73abc 100644 --- a/stl/inc/random +++ b/stl/inc/random @@ -659,12 +659,12 @@ public: } _NODISCARD_FRIEND bool operator==(const _Swc_base& _Left, const _Swc_base& _Right) { - return _Left._Equals(_Right); + return static_cast(_Left)._Equals(_Right) && _Left._Carry == _Right._Carry; } #if !_HAS_CXX20 _NODISCARD_FRIEND bool operator!=(const _Swc_base& _Left, const _Swc_base& _Right) { - return !_Left._Equals(_Right); + return !(_Left == _Right); } #endif // !_HAS_CXX20 @@ -679,16 +679,7 @@ public: template friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Swc_base& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); - } - - bool _Equals(const _Swc_base& _Right) const { - return _Mybase::_Equals(_Right) && _Carry == _Right._Carry; - } - - template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Swc_Traits::_Write(_Ostr, *this, _Carry); + static_cast(_Eng)._Write(_Ostr, _Eng, _Eng._Carry); return _Ostr; } @@ -1070,15 +1061,10 @@ public: template friend basic_ostream<_Elem, _S_Traits>& operator<<(basic_ostream<_Elem, _S_Traits>& _Ostr, const mersenne_twister& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); - } + _Ostr << _Eng._At(0); - template - basic_ostream<_Elem, _S_Traits>& _Write(basic_ostream<_Elem, _S_Traits>& _Ostr) const { // write state to _Ostr - _Ostr << this->_At(0); - - for (size_t _Ix = 1; _Ix < _Nx; ++_Ix) { - _Ostr << ' ' << this->_At(_Ix); + for (size_t _Ix = 1; _Ix < mersenne_twister::state_size; ++_Ix) { + _Ostr << ' ' << _Eng._At(_Ix); } return _Ostr; @@ -1321,7 +1307,7 @@ public: } _NODISCARD_FRIEND bool operator==(const discard_block& _Left, const discard_block& _Right) { - return _Left._Equals(_Right); + return _Left._Eng == _Right._Eng && _Left._Nx == _Right._Nx; } #if !_HAS_CXX20 @@ -1333,27 +1319,13 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>( basic_istream<_Elem, _Traits>& _Istr, discard_block& _Eng) { // read state from _Istr - return _Eng._Read(_Istr); + return _Istr >> _Eng._Eng >> _Eng._Nx; } template friend basic_ostream<_Elem, _Traits>& operator<<( basic_ostream<_Elem, _Traits>& _Ostr, const discard_block& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); - } - - bool _Equals(const discard_block& _Right) const { - return _Eng == _Right._Eng && _Nx == _Right._Nx; - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - return _Istr >> _Eng >> _Nx; - } - - template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - return _Ostr << _Eng << ' ' << _Nx; + return _Ostr << _Eng._Eng << ' ' << _Eng._Nx; } private: @@ -1501,23 +1473,13 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, independent_bits_engine& _Eng) { // read state from _Istr - return _Eng._Read(_Istr); + return _Istr >> _Eng._Eng; } template friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const independent_bits_engine& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - return _Istr >> _Eng; - } - - template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - return _Ostr << _Eng; + return _Ostr << _Eng._Eng; } private: @@ -1642,33 +1604,23 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>( basic_istream<_Elem, _Traits>& _Istr, shuffle_order_engine& _Eng) { // read state from _Istr - return _Eng._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<( - basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine& _Eng) { // write state to _Ostr - return _Eng._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Istr >> _Eng; - for (size_t _Idx = 0; _Idx < _Kx; ++_Idx) { - _Istr >> _Arr[_Idx]; + _Istr >> _Eng._Eng; + for (size_t _Idx = 0; _Idx < shuffle_order_engine::table_size; ++_Idx) { + _Istr >> _Eng._Arr[_Idx]; } - return _Istr >> _Yx; + return _Istr >> _Eng._Yx; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Ostr << _Eng; - for (size_t _Idx = 0; _Idx < _Kx; ++_Idx) { - _Ostr << ' ' << _Arr[_Idx]; + friend basic_ostream<_Elem, _Traits>& operator<<( + basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine& _Eng) { // write state to _Ostr + _Ostr << _Eng._Eng; + for (size_t _Idx = 0; _Idx < shuffle_order_engine::table_size; ++_Idx) { + _Ostr << ' ' << _Eng._Arr[_Idx]; } - return _Ostr << ' ' << _Yx; + return _Ostr << ' ' << _Eng._Yx; } private: @@ -1782,27 +1734,17 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, uniform_int& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const uniform_int& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Min0; - _Ty _Max0; + uniform_int::result_type _Min0; + uniform_int::result_type _Max0; _Istr >> _Min0 >> _Max0; - _Par._Init(_Min0, _Max0); + _Dist._Par._Init(_Min0, _Max0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - return _Ostr << _Par._Min << ' ' << _Par._Max; + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const uniform_int& _Dist) { // write state to _Ostr + return _Ostr << _Dist._Par._Min << ' ' << _Dist._Par._Max; } private: @@ -1969,26 +1911,16 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, bernoulli_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const bernoulli_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr double _Px0; _In(_Istr, _Px0); - _Par._Init(_Px0); + _Dist._Par._Init(_Px0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Px); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const bernoulli_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Px); return _Ostr; } @@ -2134,26 +2066,16 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, geometric_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const geometric_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty1 _Px0; + geometric_distribution::_Ty1 _Px0; _In(_Istr, _Px0); - _Par._Init(_Px0); + _Dist._Par._Init(_Px0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Px); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const geometric_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Px); return _Ostr; } @@ -2302,26 +2224,16 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, poisson_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const poisson_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty1 _Mean0; + poisson_distribution::_Ty1 _Mean0; _In(_Istr, _Mean0); - _Par._Init(_Mean0); + _Dist._Par._Init(_Mean0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Mean); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const poisson_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Mean); return _Ostr; } @@ -2477,29 +2389,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, binomial_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const binomial_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Tx0; - _Ty1 _Px0; + binomial_distribution::result_type _Tx0; + binomial_distribution::_Ty1 _Px0; _In(_Istr, _Px0); _In(_Istr, _Tx0); - _Par._Init(_Tx0, _Px0); + _Dist._Par._Init(_Tx0, _Px0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Px); - _Out(_Ostr, _Par._Tx); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const binomial_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Px); + _Out(_Ostr, _Dist._Par._Tx); return _Ostr; } @@ -2818,26 +2720,16 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, exponential_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const exponential_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Lambda0; + exponential_distribution::result_type _Lambda0; _In(_Istr, _Lambda0); - _Par._Init(_Lambda0); + _Dist._Par._Init(_Lambda0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Lambda); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const exponential_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Lambda); return _Ostr; } @@ -2963,35 +2855,25 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, normal_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const normal_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Mean0; - _Ty _Sigma0; + normal_distribution::result_type _Mean0; + normal_distribution::result_type _Sigma0; _In(_Istr, _Mean0); _In(_Istr, _Sigma0); - _Par._Init(_Mean0, _Sigma0); + _Dist._Par._Init(_Mean0, _Sigma0); - _Istr >> _Valid; - _In(_Istr, _Xx2); + _Istr >> _Dist._Valid; + _In(_Istr, _Dist._Xx2); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Mean); - _Out(_Ostr, _Par._Sigma); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const normal_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Mean); + _Out(_Ostr, _Dist._Par._Sigma); - _Ostr << ' ' << _Valid; - _Out(_Ostr, _Xx2); + _Ostr << ' ' << _Dist._Valid; + _Out(_Ostr, _Dist._Xx2); return _Ostr; } @@ -3155,29 +3037,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, gamma_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const gamma_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Alpha0; - _Ty _Beta0; + gamma_distribution::result_type _Alpha0; + gamma_distribution::result_type _Beta0; _In(_Istr, _Alpha0); _In(_Istr, _Beta0); - _Par._Init(_Alpha0, _Beta0); + _Dist._Par._Init(_Alpha0, _Beta0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Alpha); - _Out(_Ostr, _Par._Beta); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const gamma_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Alpha); + _Out(_Ostr, _Dist._Par._Beta); return _Ostr; } @@ -3347,29 +3219,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, weibull_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const weibull_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Ax0; - _Ty _Bx0; + weibull_distribution::result_type _Ax0; + weibull_distribution::result_type _Bx0; _In(_Istr, _Ax0); _In(_Istr, _Bx0); - _Par._Init(_Ax0, _Bx0); + _Dist._Par._Init(_Ax0, _Bx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Ax); - _Out(_Ostr, _Par._Bx); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const weibull_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Ax); + _Out(_Ostr, _Dist._Par._Bx); return _Ostr; } @@ -3486,29 +3348,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, extreme_value_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const extreme_value_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Ax0; - _Ty _Bx0; + extreme_value_distribution::result_type _Ax0; + extreme_value_distribution::result_type _Bx0; _In(_Istr, _Ax0); _In(_Istr, _Bx0); - _Par._Init(_Ax0, _Bx0); + _Dist._Par._Init(_Ax0, _Bx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Ax); - _Out(_Ostr, _Par._Bx); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const extreme_value_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Ax); + _Out(_Ostr, _Dist._Par._Bx); return _Ostr; } @@ -3623,29 +3475,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, lognormal_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const lognormal_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Mx0; - _Ty _Sx0; + lognormal_distribution::result_type _Mx0; + lognormal_distribution::result_type _Sx0; _In(_Istr, _Mx0); _In(_Istr, _Sx0); - _Par._Init(_Mx0, _Sx0); + _Dist._Par._Init(_Mx0, _Sx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Mx); - _Out(_Ostr, _Par._Sx); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const lognormal_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Mx); + _Out(_Ostr, _Dist._Par._Sx); return _Ostr; } @@ -3750,26 +3592,16 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, chi_squared_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const chi_squared_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Nx0; + chi_squared_distribution::result_type _Nx0; _Istr >> _Nx0; - _Par._Init(_Nx0); + _Dist._Par._Init(_Nx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - return _Ostr << ' ' << _Par._Nx; + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const chi_squared_distribution& _Dist) { // write state to _Ostr + return _Ostr << ' ' << _Dist._Par._Nx; } private: @@ -3883,29 +3715,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, cauchy_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const cauchy_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Ax0; - _Ty _Bx0; + cauchy_distribution::result_type _Ax0; + cauchy_distribution::result_type _Bx0; _In(_Istr, _Ax0); _In(_Istr, _Bx0); - _Par._Init(_Ax0, _Bx0); + _Dist._Par._Init(_Ax0, _Bx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Ax); - _Out(_Ostr, _Par._Bx); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const cauchy_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Ax); + _Out(_Ostr, _Dist._Par._Bx); return _Ostr; } @@ -4080,27 +3902,17 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, fisher_f_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const fisher_f_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Mx0; - _Ty _Nx0; + fisher_f_distribution::result_type _Mx0; + fisher_f_distribution::result_type _Nx0; _Istr >> _Mx0 >> _Nx0; - _Par._Init(_Mx0, _Nx0); + _Dist._Par._Init(_Mx0, _Nx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Ostr << ' ' << _Par._Mx << ' ' << _Par._Nx; + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const fisher_f_distribution& _Dist) { // write state to _Ostr + _Ostr << ' ' << _Dist._Par._Mx << ' ' << _Dist._Par._Nx; return _Ostr; } @@ -4218,26 +4030,16 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, student_t_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const student_t_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Nx0; + student_t_distribution::result_type _Nx0; _Istr >> _Nx0; - _Par._Init(_Nx0); + _Dist._Par._Init(_Nx0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - return _Ostr << ' ' << _Par._Nx; + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const student_t_distribution& _Dist) { // write state to _Ostr + return _Ostr << ' ' << _Dist._Par._Nx; } private: @@ -4371,29 +4173,19 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, negative_binomial_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const negative_binomial_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Ty _Kx0; + negative_binomial_distribution::result_type _Kx0; double _Px0; _In(_Istr, _Px0); _In(_Istr, _Kx0); - _Par._Init(_Kx0, _Px0); + _Dist._Par._Init(_Kx0, _Px0); return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Out(_Ostr, _Par._Px); - _Out(_Ostr, _Par._Kx); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const negative_binomial_distribution& _Dist) { // write state to _Ostr + _Out(_Ostr, _Dist._Par._Px); + _Out(_Ostr, _Dist._Par._Kx); return _Ostr; } @@ -4499,6 +4291,32 @@ public: } } + template + basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr + size_t _Nvals; + _Istr >> _Nvals; + _Pvec.clear(); + for (; 0 < _Nvals; --_Nvals) { // get a value and add to vector + double _Val; + _In(_Istr, _Val); + _Pvec.push_back(_Val); + } + _Init(false); // don't renormalize, just compute CDF + return _Istr; + } + + template + basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr + const size_t _Nvals = _Pvec.size(); + _Ostr << ' ' << _Nvals; + + for (size_t _Idx = 0; _Idx < _Nvals; ++_Idx) { + _Out(_Ostr, _Pvec[_Idx]); + } + + return _Ostr; + } + _Myvec _Pvec; _Myvec _Pcdf; }; @@ -4560,41 +4378,13 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, discrete_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr, _Dist._Par); + return _Dist._Par._Read(_Istr); } template friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const discrete_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr, _Dist._Par); - } - - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr, - param_type& _Par0) { // read state from _Istr - size_t _Nvals; - _Istr >> _Nvals; - _Par0._Pvec.clear(); - for (; 0 < _Nvals; --_Nvals) { // get a value and add to vector - double _Val; - _In(_Istr, _Val); - _Par0._Pvec.push_back(_Val); - } - _Par0._Init(false); // don't renormalize, just compute CDF - return _Istr; - } - - template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr, - const param_type& _Par0) const { // write state to _Ostr - size_t _Nvals = _Par0._Pvec.size(); - _Ostr << ' ' << _Nvals; - - for (size_t _Idx = 0; _Idx < _Par0._Pvec.size(); ++_Idx) { - _Out(_Ostr, _Par0._Pvec[_Idx]); - } - - return _Ostr; + return _Dist._Par._Write(_Ostr); } private: @@ -4613,6 +4403,7 @@ public: template class piecewise_constant_distribution : public discrete_distribution { // piecewise constant floating-point distribution + // TRANSITION: unused _Mypbase subobject from base class public: _RNG_REQUIRE_REALTYPE(piecewise_constant_distribution, _Ty); @@ -4762,34 +4553,24 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, piecewise_constant_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const piecewise_constant_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } + static_cast(_Dist._Par)._Read(_Istr); - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr - _Mybase::_Read(_Istr, _Par); - - _Par._Bvec.clear(); - for (size_t _Idx = _Par._Pvec.size() + 1; 0 < _Idx; --_Idx) { // get a value and add to intervals vector + _Dist._Par._Bvec.clear(); + for (size_t _Idx = _Dist._Par._Pvec.size() + 1; 0 < _Idx; --_Idx) { // get a value and add to intervals vector double _Val; _In(_Istr, _Val); - _Par._Bvec.push_back(_Val); + _Dist._Par._Bvec.push_back(_Val); } return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Mybase::_Write(_Ostr, _Par); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const piecewise_constant_distribution& _Dist) { // write state to _Ostr + static_cast(_Dist._Par)._Write(_Ostr); - for (size_t _Idx = 0; _Idx < _Par._Bvec.size(); ++_Idx) { - _Out(_Ostr, _Par._Bvec[_Idx]); + for (size_t _Idx = 0; _Idx < _Dist._Par._Bvec.size(); ++_Idx) { + _Out(_Ostr, _Dist._Par._Bvec[_Idx]); } return _Ostr; @@ -4808,6 +4589,7 @@ public: template class piecewise_linear_distribution : public discrete_distribution { // piecewise linear floating-point distribution + // TRANSITION: unused _Mypbase subobject from base class public: _RNG_REQUIRE_REALTYPE(piecewise_linear_distribution, _Ty); @@ -4995,43 +4777,26 @@ public: template friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, piecewise_linear_distribution& _Dist) { // read state from _Istr - return _Dist._Read(_Istr, _Dist._Par); - } - - template - friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, - const piecewise_linear_distribution& _Dist) { // write state to _Ostr - return _Dist._Write(_Ostr); - } + static_cast(_Dist._Par)._Read(_Istr); - template - basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr, - param_type& _Par0) { // read state from _Istr - size_t _Nvals; - _Istr >> _Nvals; - _Par0._Pvec.clear(); - for (; 0 < _Nvals; --_Nvals) { // get a value and add to vector - double _Val; - _In(_Istr, _Val); - _Par0._Pvec.push_back(_Val); - } - _Par0._Bvec.clear(); - for (size_t _Idx = _Par0._Pvec.size(); 0 < _Idx; --_Idx) { // get a value and add to intervals vector + _Dist._Par._Bvec.clear(); + for (size_t _Idx = _Dist._Par._Pvec.size(); 0 < _Idx; --_Idx) { // get a value and add to intervals vector double _Val; _In(_Istr, _Val); - _Par0._Bvec.push_back(_Val); + _Dist._Par._Bvec.push_back(_Val); } - _Par0._Init(false); // don't renormalize, just compute CDF + _Dist._Par._Init(false); // don't renormalize, just compute CDF return _Istr; } template - basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr - _Mybase::_Write(_Ostr, _Par); + friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, + const piecewise_linear_distribution& _Dist) { // write state to _Ostr + static_cast(_Dist._Par)._Write(_Ostr); - for (size_t _Idx = 0; _Idx < _Par._Bvec.size(); ++_Idx) { - _Out(_Ostr, _Par._Bvec[_Idx]); + for (size_t _Idx = 0; _Idx < _Dist._Par._Bvec.size(); ++_Idx) { + _Out(_Ostr, _Dist._Par._Bvec[_Idx]); } return _Ostr; From 36e2650ca5ffff2ba122a7763786bf88b12cb16a Mon Sep 17 00:00:00 2001 From: Matt Stephanson Date: Thu, 16 Sep 2021 23:35:17 -0700 Subject: [PATCH 4/7] test failures --- stl/inc/random | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/random b/stl/inc/random index a086ad73abc..97d44441f9b 100644 --- a/stl/inc/random +++ b/stl/inc/random @@ -679,7 +679,7 @@ public: template friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Swc_base& _Eng) { // write state to _Ostr - static_cast(_Eng)._Write(_Ostr, _Eng, _Eng._Carry); + _Swc_base::_Traits::_Write(_Ostr, _Eng, _Eng._Carry); return _Ostr; } From 0492039c7740a77dafda0a685a8bde1ab5895281 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Mon, 22 Nov 2021 21:36:58 -0800 Subject: [PATCH 5/7] Prefer positive preprocessor. Purr! --- stl/inc/yvals_core.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index f35ee3d789a..15cce744093 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -421,10 +421,10 @@ #define _NODISCARD_CTOR #endif -#ifndef __CUDACC__ // TRANSITION, VSO-568006 -#define _NODISCARD_FRIEND _NODISCARD friend -#else +#ifdef __CUDACC__ // TRANSITION, VSO-568006 #define _NODISCARD_FRIEND friend +#else // ^^^ workaround ^^^ / vvv no workaround vvv +#define _NODISCARD_FRIEND _NODISCARD friend #endif // TRANSITION, VSO-568006 // Determine if we should use [[msvc::known_semantics]] to communicate to the compiler From 5c7bbdf357ad9fa65fc9cd7287c00134885993e9 Mon Sep 17 00:00:00 2001 From: Casey Carter Date: Wed, 15 Dec 2021 20:44:06 -0800 Subject: [PATCH 6/7] Don't apply `[[nodiscard]] friend` workaround for clang-CUDA --- stl/inc/yvals_core.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 15cce744093..39a2a3b8d70 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -421,7 +421,7 @@ #define _NODISCARD_CTOR #endif -#ifdef __CUDACC__ // TRANSITION, VSO-568006 +#if defined(__CUDACC__) and !defined(__clang__) // TRANSITION, VSO-568006 #define _NODISCARD_FRIEND friend #else // ^^^ workaround ^^^ / vvv no workaround vvv #define _NODISCARD_FRIEND _NODISCARD friend From 8deb17921a0d71e1d29dcf555c09a838cdf01407 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 16 Dec 2021 02:12:53 -0800 Subject: [PATCH 7/7] `and` is super ultra forbidden in this codebase. --- stl/inc/yvals_core.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 39a2a3b8d70..bc98f550a62 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -421,7 +421,7 @@ #define _NODISCARD_CTOR #endif -#if defined(__CUDACC__) and !defined(__clang__) // TRANSITION, VSO-568006 +#if defined(__CUDACC__) && !defined(__clang__) // TRANSITION, VSO-568006 #define _NODISCARD_FRIEND friend #else // ^^^ workaround ^^^ / vvv no workaround vvv #define _NODISCARD_FRIEND _NODISCARD friend