STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Classes | Macros | Typedefs | Functions | Variables
random File Reference
#include <istream>
#include <vector>

Classes

struct  _Is_RealType< _Ty >
 
struct  _Is_UIntType< _Ty >
 
struct  _Is_IntType< _Ty >
 
struct  _Enable_if_seed_seq< _Seed_seq, _Self, _Engine >
 
class  _Wrap_istream< _Elem, _Traits, _Ty >
 
class  seed_seq
 
struct  _Mul_mod< _Ity, _Ty, _Ax, _Cx, _Mx >
 
class  _Mult_prec< _Ty, _Ax, _Cx, _Mx >
 
struct  _Select_ulonglong< _Ty, _Ax, _Cx, _Mx, bool >
 
struct  _Select_ulonglong< _Ty, _Ax, _Cx, _Mx, true >
 
struct  _Select_ulong< _Ty, _Ax, _Cx, _Mx, bool >
 
struct  _Select_ulong< _Ty, _Ax, _Cx, _Mx, true >
 
struct  _Select_uint< _Ty, _Ax, _Cx, _Mx, bool >
 
struct  _Select_uint< _Ty, _Ax, _Cx, _Mx, true >
 
struct  _Select< _Ty, _Ax, _Cx, _Mx >
 
class  linear_congruential< _Uint, _Ax, _Cx, _Mx >
 
class  linear_congruential_engine< _Uint, _Ax, _Cx, _Mx >
 
struct  _Circ_buf< _Ty, _Nw >
 
class  _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits >
 
struct  _Swc_traits< _Ty, _Mx, _Nw >
 
class  subtract_with_carry< _Ty, _Mx, _Sx, _Rx >
 
class  subtract_with_carry_engine< _Ty, _Wx, _Sx, _Rx >
 
class  mersenne_twister< _Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx >
 
class  mersenne_twister_engine< _Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Dx, _Sx, _Bx, _Tx, _Cx, _Lx, _Fx >
 
class  discard_block< _Engine, _Px, _Rx >
 
class  discard_block_engine< _Engine, _Px, _Rx >
 
class  independent_bits_engine< _Engine, _Wx, _UIntType >
 
class  shuffle_order_engine< _Engine, _Kx >
 
class  uniform_int< _Ty >
 
struct  uniform_int< _Ty >::param_type
 
class  uniform_int_distribution< _Ty >
 
struct  uniform_int_distribution< _Ty >::param_type
 
class  bernoulli_distribution
 
struct  bernoulli_distribution::param_type
 
class  geometric_distribution< _Ty >
 
struct  geometric_distribution< _Ty >::param_type
 
class  _Small_poisson_distribution< _Ty >
 
class  poisson_distribution< _Ty >
 
struct  poisson_distribution< _Ty >::param_type
 
class  binomial_distribution< _Ty >
 
struct  binomial_distribution< _Ty >::param_type
 
class  uniform_real< _Ty >
 
struct  uniform_real< _Ty >::param_type
 
class  uniform_real_distribution< _Ty >
 
struct  uniform_real_distribution< _Ty >::param_type
 
class  exponential_distribution< _Ty >
 
struct  exponential_distribution< _Ty >::param_type
 
class  normal_distribution< _Ty >
 
struct  normal_distribution< _Ty >::param_type
 
class  gamma_distribution< _Ty >
 
struct  gamma_distribution< _Ty >::param_type
 
class  weibull_distribution< _Ty >
 
struct  weibull_distribution< _Ty >::param_type
 
class  extreme_value_distribution< _Ty >
 
struct  extreme_value_distribution< _Ty >::param_type
 
class  lognormal_distribution< _Ty >
 
struct  lognormal_distribution< _Ty >::param_type
 
class  chi_squared_distribution< _Ty >
 
struct  chi_squared_distribution< _Ty >::param_type
 
class  cauchy_distribution< _Ty >
 
struct  cauchy_distribution< _Ty >::param_type
 
class  _Beta_distribution< _Ty >
 
class  fisher_f_distribution< _Ty >
 
struct  fisher_f_distribution< _Ty >::param_type
 
class  student_t_distribution< _Ty >
 
struct  student_t_distribution< _Ty >::param_type
 
class  negative_binomial_distribution< _Ty >
 
struct  negative_binomial_distribution< _Ty >::param_type
 
class  discrete_distribution< _Ty >
 
struct  discrete_distribution< _Ty >::param_type
 
struct  discrete_distribution< _Ty >::param_type::_Noinit
 
class  piecewise_constant_distribution< _Ty >
 
struct  piecewise_constant_distribution< _Ty >::param_type
 
class  piecewise_linear_distribution< _Ty >
 
struct  piecewise_linear_distribution< _Ty >::param_type
 
class  random_device
 

Macros

#define _RANDOM_
 
#define _BITS_BYTE   8
 
#define _RNG_ASSERT(_Ex, _Msg)   ((void)0)
 
#define _RNG_PROHIBIT_CHAR(_CheckedType)
 
#define _RNG_REQUIRE_REALTYPE(_RandType, _CheckedType)
 
#define _RNG_REQUIRE_INTTYPE(_RandType, _CheckedType)
 
#define _RNG_REQUIRE_UINTTYPE(_RandType, _CheckedType)
 
#define _NRAND(eng, resty)   (_STD generate_canonical<resty, static_cast<size_t>(-1)>(eng))
 

Typedefs

typedef unsigned long long _Max_type
 
typedef _Max_type _MP_arr[_MP_len]
 
typedef linear_congruential_engine< unsigned int, 16807, 0, 2147483647 > minstd_rand0
 
typedef linear_congruential_engine< unsigned int, 48271, 0, 2147483647 > minstd_rand
 
typedef mersenne_twister_engine< unsigned int, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253 > mt19937
 
typedef subtract_with_carry< unsigned int, 1<< 24, 10, 24 > _Ranbase
 
typedef discard_block< _Ranbase, 223, 24 > ranlux3
 
typedef discard_block< _Ranbase, 389, 24 > ranlux4
 
typedef mersenne_twister_engine< unsigned long long, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL > mt19937_64
 
typedef subtract_with_carry_engine< unsigned int, 24, 10, 24 > ranlux24_base
 
typedef subtract_with_carry_engine< unsigned long long, 48, 5, 12 > ranlux48_base
 
typedef discard_block_engine< ranlux24_base, 223, 23 > ranlux24
 
typedef discard_block_engine< ranlux48_base, 389, 11 > ranlux48
 
typedef shuffle_order_engine< minstd_rand0, 256 > knuth_b
 
typedef mt19937 default_random_engine
 

Functions

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Rng_abort (_In_z_ const char *_Msg)
 
_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _XLgamma (float)
 
_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _XLgamma (double)
 
_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _XLgamma (long double)
 
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > & _Write (basic_ostream< _Elem, _Traits > &_Os, long double _Dx)
 
template<class _Elem , class _Traits >
basic_istream< _Elem, _Traits > & _Read (basic_istream< _Elem, _Traits > &_Is, long double &_Dx)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & _In (basic_istream< _Elem, _Traits > &_Is, _Ty &_Dx)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & _Out (basic_ostream< _Elem, _Traits > &_Os, _Ty _Dx)
 
template<class _Real , size_t _Bits, class _Gen >
_Real generate_canonical (_Gen &_Gx)
 
_CRTIMP2_PURE _Max_type __CLRCALL_PURE_OR_CDECL _MP_Get (_MP_arr)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Add (_MP_arr, _Max_type)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Mul (_MP_arr, _Max_type, _Max_type)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Rem (_MP_arr, _Max_type)
 
template<class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
bool operator== (const linear_congruential< _Uint, _Ax, _Cx, _Mx > &_Left, const linear_congruential< _Uint, _Ax, _Cx, _Mx > &_Right)
 
template<class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
bool operator!= (const linear_congruential< _Uint, _Ax, _Cx, _Mx > &_Left, const linear_congruential< _Uint, _Ax, _Cx, _Mx > &_Right)
 
template<class _Elem , class _Traits , class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, linear_congruential< _Uint, _Ax, _Cx, _Mx > &_Eng)
 
template<class _Elem , class _Traits , class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const linear_congruential< _Uint, _Ax, _Cx, _Mx > &_Eng)
 
template<class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
bool operator== (const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &_Left, const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &_Right)
 
template<class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
bool operator!= (const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &_Left, const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &_Right)
 
template<class _Elem , class _Traits , class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &_Eng)
 
template<class _Elem , class _Traits , class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &_Eng)
 
template<class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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)
 
template<class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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)
 
template<class _Elem , class _S_Traits , class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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)
 
template<class _Elem , class _S_Traits , class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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)
 
template<class _Engine , int _Px, int _Rx>
bool operator== (const discard_block< _Engine, _Px, _Rx > &_Left, const discard_block< _Engine, _Px, _Rx > &_Right)
 
template<class _Engine , int _Px, int _Rx>
bool operator!= (const discard_block< _Engine, _Px, _Rx > &_Left, const discard_block< _Engine, _Px, _Rx > &_Right)
 
template<class _Elem , class _Traits , class _Engine , int _Px, int _Rx>
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, discard_block< _Engine, _Px, _Rx > &_Eng)
 
template<class _Elem , class _Traits , class _Engine , int _Px, int _Rx>
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const discard_block< _Engine, _Px, _Rx > &_Eng)
 
template<class _Engine , size_t _Wx, class _UIntType >
bool operator== (const independent_bits_engine< _Engine, _Wx, _UIntType > &_Left, const independent_bits_engine< _Engine, _Wx, _UIntType > &_Right)
 
template<class _Engine , size_t _Wx, class _UIntType >
bool operator!= (const independent_bits_engine< _Engine, _Wx, _UIntType > &_Left, const independent_bits_engine< _Engine, _Wx, _UIntType > &_Right)
 
template<class _Elem , class _Traits , class _Engine , size_t _Wx, class _UIntType >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, independent_bits_engine< _Engine, _Wx, _UIntType > &_Eng)
 
template<class _Elem , class _Traits , class _Engine , size_t _Wx, class _UIntType >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const independent_bits_engine< _Engine, _Wx, _UIntType > &_Eng)
 
template<class _Engine , size_t _Kx>
bool operator== (const shuffle_order_engine< _Engine, _Kx > &_Left, const shuffle_order_engine< _Engine, _Kx > &_Right)
 
template<class _Engine , size_t _Kx>
bool operator!= (const shuffle_order_engine< _Engine, _Kx > &_Left, const shuffle_order_engine< _Engine, _Kx > &_Right)
 
template<class _Elem , class _Traits , class _Engine , size_t _Kx>
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, shuffle_order_engine< _Engine, _Kx > &_Eng)
 
template<class _Elem , class _Traits , class _Engine , size_t _Kx>
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const shuffle_order_engine< _Engine, _Kx > &_Eng)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, uniform_int< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const uniform_int< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const uniform_int_distribution< _Ty > &_Left, const uniform_int_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const uniform_int_distribution< _Ty > &_Left, const uniform_int_distribution< _Ty > &_Right)
 
bool operator== (const bernoulli_distribution &_Left, const bernoulli_distribution &_Right)
 
bool operator!= (const bernoulli_distribution &_Left, const bernoulli_distribution &_Right)
 
template<class _Elem , class _Traits >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, bernoulli_distribution &_Dist)
 
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const bernoulli_distribution &_Dist)
 
template<class _Ty >
bool operator== (const geometric_distribution< _Ty > &_Left, const geometric_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const geometric_distribution< _Ty > &_Left, const geometric_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, geometric_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const geometric_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const poisson_distribution< _Ty > &_Left, const poisson_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const poisson_distribution< _Ty > &_Left, const poisson_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, poisson_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const poisson_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const binomial_distribution< _Ty > &_Left, const binomial_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const binomial_distribution< _Ty > &_Left, const binomial_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, binomial_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const binomial_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, uniform_real< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const uniform_real< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const uniform_real_distribution< _Ty > &_Left, const uniform_real_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const uniform_real_distribution< _Ty > &_Left, const uniform_real_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator== (const exponential_distribution< _Ty > &_Left, const exponential_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const exponential_distribution< _Ty > &_Left, const exponential_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, exponential_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const exponential_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const normal_distribution< _Ty > &_Left, const normal_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const normal_distribution< _Ty > &_Left, const normal_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, normal_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const normal_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const gamma_distribution< _Ty > &_Left, const gamma_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const gamma_distribution< _Ty > &_Left, const gamma_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, gamma_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const gamma_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const weibull_distribution< _Ty > &_Left, const weibull_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const weibull_distribution< _Ty > &_Left, const weibull_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, weibull_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const weibull_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const extreme_value_distribution< _Ty > &_Left, const extreme_value_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const extreme_value_distribution< _Ty > &_Left, const extreme_value_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, extreme_value_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const extreme_value_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const lognormal_distribution< _Ty > &_Left, const lognormal_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const lognormal_distribution< _Ty > &_Left, const lognormal_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, lognormal_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const lognormal_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const chi_squared_distribution< _Ty > &_Left, const chi_squared_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const chi_squared_distribution< _Ty > &_Left, const chi_squared_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, chi_squared_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const chi_squared_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const cauchy_distribution< _Ty > &_Left, const cauchy_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const cauchy_distribution< _Ty > &_Left, const cauchy_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, cauchy_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const cauchy_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const fisher_f_distribution< _Ty > &_Left, const fisher_f_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const fisher_f_distribution< _Ty > &_Left, const fisher_f_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, fisher_f_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const fisher_f_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const student_t_distribution< _Ty > &_Left, const student_t_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const student_t_distribution< _Ty > &_Left, const student_t_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, student_t_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const student_t_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const negative_binomial_distribution< _Ty > &_Left, const negative_binomial_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const negative_binomial_distribution< _Ty > &_Left, const negative_binomial_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, negative_binomial_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const negative_binomial_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const discrete_distribution< _Ty > &_Left, const discrete_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const discrete_distribution< _Ty > &_Left, const discrete_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, discrete_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const discrete_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const piecewise_constant_distribution< _Ty > &_Left, const piecewise_constant_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const piecewise_constant_distribution< _Ty > &_Left, const piecewise_constant_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, piecewise_constant_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const piecewise_constant_distribution< _Ty > &_Dist)
 
template<class _Ty >
bool operator== (const piecewise_linear_distribution< _Ty > &_Left, const piecewise_linear_distribution< _Ty > &_Right)
 
template<class _Ty >
bool operator!= (const piecewise_linear_distribution< _Ty > &_Left, const piecewise_linear_distribution< _Ty > &_Right)
 
template<class _Elem , class _Traits , class _Ty >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, piecewise_linear_distribution< _Ty > &_Dist)
 
template<class _Elem , class _Traits , class _Ty >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const piecewise_linear_distribution< _Ty > &_Dist)
 
_CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device ()
 

Variables

constexpr long double _Pi = 3.14159265358979323846264338327950288L
 
constexpr long double _Exp1 = 2.71828182845904523536028747135266250L
 
constexpr long double _Two32 = 4294967296.0L
 
constexpr long double _Two31 = 2147483648.0L
 
constexpr int _Nwords = 4
 
constexpr int _MP_len = 5
 

Macro Definition Documentation

#define _BITS_BYTE   8
#define _NRAND (   eng,
  resty 
)    (_STD generate_canonical<resty, static_cast<size_t>(-1)>(eng))
#define _RANDOM_
#define _RNG_ASSERT (   _Ex,
  _Msg 
)    ((void)0)
#define _RNG_PROHIBIT_CHAR (   _CheckedType)
Value:
static_assert(!_Is_character<_CheckedType>::value, \
"note: char, signed char, unsigned char, int8_t, and uint8_t are not allowed")
_Is_character
Definition: xutility:2637
#define _RNG_REQUIRE_INTTYPE (   _RandType,
  _CheckedType 
)
Value:
static_assert(_Is_IntType<_CheckedType>::value, \
"invalid template argument for " #_RandType ": N4606 26.6.1.1 [rand.req.genl]/1e requires one of " \
"short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); \
_RNG_PROHIBIT_CHAR(_CheckedType)
_RNG_PROHIBIT_CHAR
#define _RNG_PROHIBIT_CHAR(_CheckedType)
Definition: random:62
_Is_IntType
Definition: random:52
#define _RNG_REQUIRE_REALTYPE (   _RandType,
  _CheckedType 
)
Value:
static_assert(_Is_RealType<_CheckedType>::value, \
"invalid template argument for " #_RandType ": N4606 26.6.1.1 [rand.req.genl]/1d requires one of " \
"float, double, or long double")
_Is_RealType
Definition: random:33
#define _RNG_REQUIRE_UINTTYPE (   _RandType,
  _CheckedType 
)
Value:
static_assert(_Is_UIntType<_CheckedType>::value, \
"invalid template argument for " #_RandType ": N4606 26.6.1.1 [rand.req.genl]/1f requires one of " \
"unsigned short, unsigned int, unsigned long, or unsigned long long"); \
_RNG_PROHIBIT_CHAR(_CheckedType)
_Is_UIntType
Definition: random:42
_RNG_PROHIBIT_CHAR
#define _RNG_PROHIBIT_CHAR(_CheckedType)
Definition: random:62

Typedef Documentation

typedef unsigned long long _Max_type
typedef _Max_type _MP_arr[_MP_len]
typedef subtract_with_carry<unsigned int, 1 << 24, 10, 24> _Ranbase
typedef mt19937 default_random_engine
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b
typedef linear_congruential_engine<unsigned int, 48271, 0, 2147483647> minstd_rand
typedef linear_congruential_engine<unsigned int, 16807, 0, 2147483647> minstd_rand0
typedef mersenne_twister_engine<unsigned int, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253> mt19937
typedef mersenne_twister_engine<unsigned long long, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL> mt19937_64
typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24
typedef subtract_with_carry_engine<unsigned int, 24, 10, 24> ranlux24_base
typedef discard_block<_Ranbase, 223, 24> ranlux3
typedef discard_block<_Ranbase, 389, 24> ranlux4
typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48
typedef subtract_with_carry_engine<unsigned long long, 48, 5, 12> ranlux48_base

Function Documentation

template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& _In ( basic_istream< _Elem, _Traits > &  _Is,
_Ty &  _Dx 
)
157  { // read from stream
158  long double _Vx;
159  _Ty _Max = (numeric_limits<_Ty>::max)();
160  _Read(_Is, _Vx);
161  if (_CSTD fabsl(_Vx) <= _Max)
162  _Dx = (_Ty)_Vx;
163  else if (_Vx < 0)
164  _Dx = -_Max;
165  else
166  _Dx = _Max;
167  return (_Is);
168  }
fabsl
_Check_return_ __inline long double __CRTDECL fabsl(_In_ long double _X)
Definition: corecrt_math.h:840
_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Is, long double &_Dx)
Definition: random:135
_CSTD
#define _CSTD
Definition: yvals.h:570
numeric_limits
Definition: limits:102
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Add ( _MP_arr  ,
_Max_type   
)
_CRTIMP2_PURE _Max_type __CLRCALL_PURE_OR_CDECL _MP_Get ( _MP_arr  )
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Mul ( _MP_arr  ,
_Max_type  ,
_Max_type   
)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Rem ( _MP_arr  ,
_Max_type   
)
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& _Out ( basic_ostream< _Elem, _Traits > &  _Os,
_Ty  _Dx 
)
175  { // write to stream
176  return (_Write(_Os, _Dx));
177  }
_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Os, long double _Dx)
Definition: random:116
_CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device ( )
template<class _Elem , class _Traits >
basic_istream<_Elem, _Traits>& _Read ( basic_istream< _Elem, _Traits > &  _Is,
long double &  _Dx 
)
136  { // read long double from stream
137  long double _Frac = 0.0;
138  long _Digits;
139  for (int _Nw = 0; _Nw < _Nwords; ++_Nw)
140  { // accumulate 31-bit words
141  _Is >> _Digits;
142  long double _Temp = _Digits / _Two31;
143  for (int _Idx = 0; _Idx < _Nw; ++_Idx)
144  _Temp /= _Two31;
145  _Frac += _Temp;
146  }
147  _Is >> _Digits;
148  _Dx = _CSTD ldexpl(_Frac, _Digits);
149  return (_Is);
150  }
_Two31
constexpr long double _Two31
Definition: random:103
ldexpl
_Check_return_ __inline long double __CRTDECL ldexpl(_In_ long double _X, _In_ int _Y)
Definition: corecrt_math.h:878
_Nwords
constexpr int _Nwords
Definition: random:112
_CSTD
#define _CSTD
Definition: yvals.h:570
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Rng_abort ( _In_z_ const char *  _Msg)
template<class _Elem , class _Traits >
basic_ostream<_Elem, _Traits>& _Write ( basic_ostream< _Elem, _Traits > &  _Os,
long double  _Dx 
)
118  { // write long double to stream
119  int _Ex;
120  long double _Frac = _CSTD frexpl(_Dx, &_Ex);
121  for (int _Nw = 0; _Nw < _Nwords; ++_Nw)
122  { // break into 31-bit words
123  _Frac *= _Two31;
124  long _Digits = (long)_Frac;
125  _Frac -= _Digits;
126  _Os << ' ' << _Digits;
127  }
128  _Os << ' ' << _Ex;
129  return (_Os);
130  }
long
_In_ long
Definition: corecrt_wstdlib.h:88
frexpl
_Check_return_ __inline long double __CRTDECL frexpl(_In_ long double _X, _Out_ int *_Y)
Definition: corecrt_math.h:861
_Two31
constexpr long double _Two31
Definition: random:103
_Nwords
constexpr int _Nwords
Definition: random:112
_CSTD
#define _CSTD
Definition: yvals.h:570
_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _XLgamma ( float  )
_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _XLgamma ( double  )
_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _XLgamma ( long  double)
template<class _Real , size_t _Bits, class _Gen >
_Real generate_canonical ( _Gen &  _Gx)
319  { // build a floating-point value from random sequence
320  _RNG_REQUIRE_REALTYPE(generate_canonical, _Real);
321 
322  const size_t _Digits = static_cast<size_t>(numeric_limits<_Real>::digits);
323  const size_t _Minbits = _Digits < _Bits ? _Digits : _Bits;
324 
325  const _Real _Gxmin = static_cast<_Real>((_Gx.min)());
326  const _Real _Gxmax = static_cast<_Real>((_Gx.max)());
327  const _Real _Rx = (_Gxmax - _Gxmin) + static_cast<_Real>(1);
328 
329  const int _Ceil = static_cast<int>(_STD ceil(
330  static_cast<_Real>(_Minbits) / _STD log2(_Rx)));
331  const int _Kx = _Ceil < 1 ? 1 : _Ceil;
332 
333  _Real _Ans = static_cast<_Real>(0);
334  _Real _Factor = static_cast<_Real>(1);
335 
336  for (int _Idx = 0; _Idx < _Kx; ++_Idx)
337  { // add in another set of bits
338  _Ans += (static_cast<_Real>(_Gx()) - _Gxmin) * _Factor;
339  _Factor *= _Rx;
340  }
341 
342  return (_Ans / _Factor);
343  }
Concurrency::fast_math::log2
float log2(float _X) __GPU_ONLY
Calculates the base-2 logarithm of the argument
Definition: amp_math.h:830
chrono::_Ceil
constexpr _To_integral _Ceil(const duration< _Rep, _Period > &_Dur, const _To_integral &_Dur_integral)
Definition: chrono:605
generate_canonical
_Real generate_canonical(_Gen &_Gx)
Definition: random:318
_RNG_REQUIRE_REALTYPE
#define _RNG_REQUIRE_REALTYPE(_RandType, _CheckedType)
Definition: random:66
_STD
Concurrency::fast_math::ceil
float ceil(float _X) __GPU_ONLY
Calculates the ceiling of the argument
Definition: amp_math.h:387
numeric_limits
Definition: limits:102
template<class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
bool operator!= ( const linear_congruential< _Uint, _Ax, _Cx, _Mx > &  _Left,
const linear_congruential< _Uint, _Ax, _Cx, _Mx > &  _Right 
)
600  { // return true if *this will not generate same sequence as _Right
601  return (!_Left._Equals(_Right));
602  }
linear_congruential::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:543
template<class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
bool operator!= ( const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &  _Left,
const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &  _Right 
)
911  { // return true if _Left will not generate same sequence as _Right
912  return (!_Left._Equals(_Right));
913  }
_Swc_base::_Equals
bool _Equals(const _Swc_base &_Right) const
Definition: random:835
template<class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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 
)
1463  { // return true if _Left will not generate same sequence as _Right
1464  return (!_Left._Equals(_Right));
1465  }
_Circ_buf< _Ty, _Nx >::_Equals
bool _Equals(const _Circ_buf &_Right) const
Definition: random:705
template<class _Engine , int _Px, int _Rx>
bool operator!= ( const discard_block< _Engine, _Px, _Rx > &  _Left,
const discard_block< _Engine, _Px, _Rx > &  _Right 
)
1748  { // return true if _Left will not generate same sequence as _Right
1749  return (!(_Left == _Right));
1750  }
template<class _Engine , size_t _Wx, class _UIntType >
bool operator!= ( const independent_bits_engine< _Engine, _Wx, _UIntType > &  _Left,
const independent_bits_engine< _Engine, _Wx, _UIntType > &  _Right 
)
2016  { // return true if _Left will not generate same sequence as _Right
2017  return (!(_Left == _Right));
2018  }
template<class _Engine , size_t _Kx>
bool operator!= ( const shuffle_order_engine< _Engine, _Kx > &  _Left,
const shuffle_order_engine< _Engine, _Kx > &  _Right 
)
2192  { // return true if _Left will not generate same sequence as _Right
2193  return (!(_Left == _Right));
2194  }
template<class _Ty >
bool operator!= ( const uniform_int_distribution< _Ty > &  _Left,
const uniform_int_distribution< _Ty > &  _Right 
)
2466  { // test for inequality
2467  return (!(_Left == _Right));
2468  }
bool operator!= ( const bernoulli_distribution &  _Left,
const bernoulli_distribution &  _Right 
)
inline
2601  { // test for inequality
2602  return (!(_Left == _Right));
2603  }
template<class _Ty >
bool operator!= ( const geometric_distribution< _Ty > &  _Left,
const geometric_distribution< _Ty > &  _Right 
)
2764  { // test for inequality
2765  return (!(_Left == _Right));
2766  }
template<class _Ty >
bool operator!= ( const poisson_distribution< _Ty > &  _Left,
const poisson_distribution< _Ty > &  _Right 
)
2984  { // test for inequality
2985  return (!(_Left == _Right));
2986  }
template<class _Ty >
bool operator!= ( const binomial_distribution< _Ty > &  _Left,
const binomial_distribution< _Ty > &  _Right 
)
3214  { // test for inequality
3215  return (!(_Left == _Right));
3216  }
template<class _Ty >
bool operator!= ( const uniform_real_distribution< _Ty > &  _Left,
const uniform_real_distribution< _Ty > &  _Right 
)
3452  { // test for inequality
3453  return (!(_Left == _Right));
3454  }
template<class _Ty >
bool operator!= ( const exponential_distribution< _Ty > &  _Left,
const exponential_distribution< _Ty > &  _Right 
)
3591  { // test for inequality
3592  return (!(_Left == _Right));
3593  }
template<class _Ty >
bool operator!= ( const normal_distribution< _Ty > &  _Left,
const normal_distribution< _Ty > &  _Right 
)
3813  { // test for inequality
3814  return (!(_Left == _Right));
3815  }
template<class _Ty >
bool operator!= ( const gamma_distribution< _Ty > &  _Left,
const gamma_distribution< _Ty > &  _Right 
)
4046  { // test for inequality
4047  return (!(_Left == _Right));
4048  }
template<class _Ty >
bool operator!= ( const weibull_distribution< _Ty > &  _Left,
const weibull_distribution< _Ty > &  _Right 
)
4225  { // test for inequality
4226  return (!(_Left == _Right));
4227  }
template<class _Ty >
bool operator!= ( const extreme_value_distribution< _Ty > &  _Left,
const extreme_value_distribution< _Ty > &  _Right 
)
4402  { // test for inequality
4403  return (!(_Left == _Right));
4404  }
template<class _Ty >
bool operator!= ( const lognormal_distribution< _Ty > &  _Left,
const lognormal_distribution< _Ty > &  _Right 
)
4579  { // test for inequality
4580  return (!(_Left == _Right));
4581  }
template<class _Ty >
bool operator!= ( const chi_squared_distribution< _Ty > &  _Left,
const chi_squared_distribution< _Ty > &  _Right 
)
4738  { // test for inequality
4739  return (!(_Left == _Right));
4740  }
template<class _Ty >
bool operator!= ( const cauchy_distribution< _Ty > &  _Left,
const cauchy_distribution< _Ty > &  _Right 
)
4916  { // test for inequality
4917  return (!(_Left == _Right));
4918  }
template<class _Ty >
bool operator!= ( const fisher_f_distribution< _Ty > &  _Left,
const fisher_f_distribution< _Ty > &  _Right 
)
5154  { // test for inequality
5155  return (!(_Left == _Right));
5156  }
template<class _Ty >
bool operator!= ( const student_t_distribution< _Ty > &  _Left,
const student_t_distribution< _Ty > &  _Right 
)
5326  { // test for inequality
5327  return (!(_Left == _Right));
5328  }
template<class _Ty >
bool operator!= ( const negative_binomial_distribution< _Ty > &  _Left,
const negative_binomial_distribution< _Ty > &  _Right 
)
5512  { // test for inequality
5513  return (!(_Left == _Right));
5514  }
template<class _Ty >
bool operator!= ( const discrete_distribution< _Ty > &  _Left,
const discrete_distribution< _Ty > &  _Right 
)
5783  { // test for inequality
5784  return (!(_Left == _Right));
5785  }
template<class _Ty >
bool operator!= ( const piecewise_constant_distribution< _Ty > &  _Left,
const piecewise_constant_distribution< _Ty > &  _Right 
)
6043  { // test for inequality
6044  return (!(_Left == _Right));
6045  }
template<class _Ty >
bool operator!= ( const piecewise_linear_distribution< _Ty > &  _Left,
const piecewise_linear_distribution< _Ty > &  _Right 
)
6356  { // test for inequality
6357  return (!(_Left == _Right));
6358  }
template<class _Elem , class _Traits , class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const linear_congruential< _Uint, _Ax, _Cx, _Mx > &  _Eng 
)
628  { // write state to _Ostr
629  return (_Eng._Write(_Ostr));
630  }
linear_congruential::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:551
template<class _Elem , class _Traits , class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &  _Eng 
)
940  { // write state to _Ostr
941  return (_Eng._Write(_Ostr));
942  }
_Swc_base::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:844
template<class _Elem , class _S_Traits , class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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 
)
1489  { // write state to _Ostr
1490  return (_Eng._Write(_Ostr));
1491  }
mersenne_twister::_Write
basic_ostream< _Elem, _S_Traits > & _Write(basic_ostream< _Elem, _S_Traits > &_Ostr) const
Definition: random:1359
template<class _Elem , class _Traits , class _Engine , int _Px, int _Rx>
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const discard_block< _Engine, _Px, _Rx > &  _Eng 
)
1772  { // write state to _Ostr
1773  return (_Eng._Write(_Ostr));
1774  }
discard_block::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:1711
template<class _Elem , class _Traits , class _Engine , size_t _Wx, class _UIntType >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const independent_bits_engine< _Engine, _Wx, _UIntType > &  _Eng 
)
2040  { // write state to _Ostr
2041  return (_Eng._Write(_Ostr));
2042  }
independent_bits_engine::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:1957
template<class _Elem , class _Traits , class _Engine , size_t _Kx>
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const shuffle_order_engine< _Engine, _Kx > &  _Eng 
)
2214  { // write state to _Ostr
2215  return (_Eng._Write(_Ostr));
2216  }
shuffle_order_engine::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2153
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const uniform_int< _Ty > &  _Dist 
)
2410  { // write state to _Ostr
2411  return (_Dist._Write(_Ostr));
2412  }
uniform_int::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2344
template<class _Elem , class _Traits >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const bernoulli_distribution &  _Dist 
)
2619  { // write state to _Ostr
2620  return (_Dist._Write(_Ostr));
2621  }
bernoulli_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2576
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const geometric_distribution< _Ty > &  _Dist 
)
2784  { // write state to _Ostr
2785  return (_Dist._Write(_Ostr));
2786  }
geometric_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2736
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const poisson_distribution< _Ty > &  _Dist 
)
3004  { // write state to _Ostr
3005  return (_Dist._Write(_Ostr));
3006  }
poisson_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2940
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const binomial_distribution< _Ty > &  _Dist 
)
3234  { // write state to _Ostr
3235  return (_Dist._Write(_Ostr));
3236  }
binomial_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3153
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const uniform_real< _Ty > &  _Dist 
)
3396  { // write state to _Ostr
3397  return (_Dist._Write(_Ostr));
3398  }
uniform_real::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3362
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const exponential_distribution< _Ty > &  _Dist 
)
3611  { // write state to _Ostr
3612  return (_Dist._Write(_Ostr));
3613  }
exponential_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3564
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const normal_distribution< _Ty > &  _Dist 
)
3833  { // write state to _Ostr
3834  return (_Dist._Write(_Ostr));
3835  }
normal_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3753
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const gamma_distribution< _Ty > &  _Dist 
)
4066  { // write state to _Ostr
4067  return (_Dist._Write(_Ostr));
4068  }
gamma_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3966
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const weibull_distribution< _Ty > &  _Dist 
)
4245  { // write state to _Ostr
4246  return (_Dist._Write(_Ostr));
4247  }
weibull_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4196
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const extreme_value_distribution< _Ty > &  _Dist 
)
4422  { // write state to _Ostr
4423  return (_Dist._Write(_Ostr));
4424  }
extreme_value_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4373
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const lognormal_distribution< _Ty > &  _Dist 
)
4599  { // write state to _Ostr
4600  return (_Dist._Write(_Ostr));
4601  }
lognormal_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4550
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const chi_squared_distribution< _Ty > &  _Dist 
)
4758  { // write state to _Ostr
4759  return (_Dist._Write(_Ostr));
4760  }
chi_squared_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4711
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const cauchy_distribution< _Ty > &  _Dist 
)
4936  { // write state to _Ostr
4937  return (_Dist._Write(_Ostr));
4938  }
cauchy_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4886
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const fisher_f_distribution< _Ty > &  _Dist 
)
5174  { // write state to _Ostr
5175  return (_Dist._Write(_Ostr));
5176  }
fisher_f_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5121
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const student_t_distribution< _Ty > &  _Dist 
)
5346  { // write state to _Ostr
5347  return (_Dist._Write(_Ostr));
5348  }
student_t_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5286
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const negative_binomial_distribution< _Ty > &  _Dist 
)
5532  { // write state to _Ostr
5533  return (_Dist._Write(_Ostr));
5534  }
negative_binomial_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5478
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const discrete_distribution< _Ty > &  _Dist 
)
5803  { // write state to _Ostr
5804  return (_Dist._Write(_Ostr, _Dist._Par));
5805  }
discrete_distribution::_Par
param_type _Par
Definition: random:5770
discrete_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr, const param_type &_Par0) const
Definition: random:5733
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const piecewise_constant_distribution< _Ty > &  _Dist 
)
6063  { // write state to _Ostr
6064  return (_Dist._Write(_Ostr));
6065  }
piecewise_constant_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:6012
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const piecewise_linear_distribution< _Ty > &  _Dist 
)
6376  { // write state to _Ostr
6377  return (_Dist._Write(_Ostr));
6378  }
piecewise_linear_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:6317
template<class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
bool operator== ( const linear_congruential< _Uint, _Ax, _Cx, _Mx > &  _Left,
const linear_congruential< _Uint, _Ax, _Cx, _Mx > &  _Right 
)
589  { // return true if _Left will generate same sequence as _Right
590  return (_Left._Equals(_Right));
591  }
linear_congruential::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:543
template<class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
bool operator== ( const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &  _Left,
const _Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &  _Right 
)
901  { // return true if _Left will generate same sequence as _Right
902  return (_Left._Equals(_Right));
903  }
_Swc_base::_Equals
bool _Equals(const _Swc_base &_Right) const
Definition: random:835
template<class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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 
)
1452  { // return true if _Left will generate same sequence as _Right
1453  return (_Left._Equals(_Right));
1454  }
_Circ_buf< _Ty, _Nx >::_Equals
bool _Equals(const _Circ_buf &_Right) const
Definition: random:705
template<class _Engine , int _Px, int _Rx>
bool operator== ( const discard_block< _Engine, _Px, _Rx > &  _Left,
const discard_block< _Engine, _Px, _Rx > &  _Right 
)
1738  { // return true if _Left will generate same sequence as _Right
1739  return (_Left._Equals(_Right));
1740  }
discard_block::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:1696
template<class _Engine , size_t _Wx, class _UIntType >
bool operator== ( const independent_bits_engine< _Engine, _Wx, _UIntType > &  _Left,
const independent_bits_engine< _Engine, _Wx, _UIntType > &  _Right 
)
2006  { // return true if _Left will generate same sequence as _Right
2007  return (_Left.base() == _Right.base());
2008  }
independent_bits_engine::base
const _Engine & base() const _NOEXCEPT
Definition: random:1894
template<class _Engine , size_t _Kx>
bool operator== ( const shuffle_order_engine< _Engine, _Kx > &  _Left,
const shuffle_order_engine< _Engine, _Kx > &  _Right 
)
2183  { // return true if _Left will generate same sequence as _Right
2184  return (_Left.base() == _Right.base());
2185  }
shuffle_order_engine::base
const _Engine & base() const _NOEXCEPT
Definition: random:2110
template<class _Ty >
bool operator== ( const uniform_int_distribution< _Ty > &  _Left,
const uniform_int_distribution< _Ty > &  _Right 
)
2459  { // test for equality
2460  return (_Left.param() == _Right.param());
2461  }
uniform_int::param
param_type param() const
Definition: random:2288
bool operator== ( const bernoulli_distribution &  _Left,
const bernoulli_distribution &  _Right 
)
inline
2595  { // test for equality
2596  return (_Left.param() == _Right.param());
2597  }
bernoulli_distribution::param
param_type param() const
Definition: random:2527
template<class _Ty >
bool operator== ( const geometric_distribution< _Ty > &  _Left,
const geometric_distribution< _Ty > &  _Right 
)
2757  { // test for equality
2758  return (_Left.param() == _Right.param());
2759  }
geometric_distribution::param
param_type param() const
Definition: random:2687
template<class _Ty >
bool operator== ( const poisson_distribution< _Ty > &  _Left,
const poisson_distribution< _Ty > &  _Right 
)
2977  { // test for equality
2978  return (_Left.param() == _Right.param());
2979  }
poisson_distribution::param
param_type param() const
Definition: random:2891
template<class _Ty >
bool operator== ( const binomial_distribution< _Ty > &  _Left,
const binomial_distribution< _Ty > &  _Right 
)
3207  { // test for equality
3208  return (_Left.param() == _Right.param());
3209  }
binomial_distribution::param
param_type param() const
Definition: random:3102
template<class _Ty >
bool operator== ( const uniform_real_distribution< _Ty > &  _Left,
const uniform_real_distribution< _Ty > &  _Right 
)
3445  { // test for equality
3446  return (_Left.param() == _Right.param());
3447  }
uniform_real::param
param_type param() const
Definition: random:3311
template<class _Ty >
bool operator== ( const exponential_distribution< _Ty > &  _Left,
const exponential_distribution< _Ty > &  _Right 
)
3584  { // test for equality
3585  return (_Left.param() == _Right.param());
3586  }
exponential_distribution::param
param_type param() const
Definition: random:3515
template<class _Ty >
bool operator== ( const normal_distribution< _Ty > &  _Left,
const normal_distribution< _Ty > &  _Right 
)
3806  { // test for equality
3807  return (_Left.param() == _Right.param());
3808  }
normal_distribution::param
param_type param() const
Definition: random:3696
template<class _Ty >
bool operator== ( const gamma_distribution< _Ty > &  _Left,
const gamma_distribution< _Ty > &  _Right 
)
4039  { // test for equality
4040  return (_Left.param() == _Right.param());
4041  }
gamma_distribution::param
param_type param() const
Definition: random:3915
template<class _Ty >
bool operator== ( const weibull_distribution< _Ty > &  _Left,
const weibull_distribution< _Ty > &  _Right 
)
4218  { // test for equality
4219  return (_Left.param() == _Right.param());
4220  }
weibull_distribution::param
param_type param() const
Definition: random:4145
template<class _Ty >
bool operator== ( const extreme_value_distribution< _Ty > &  _Left,
const extreme_value_distribution< _Ty > &  _Right 
)
4395  { // test for equality
4396  return (_Left.param() == _Right.param());
4397  }
extreme_value_distribution::param
param_type param() const
Definition: random:4322
template<class _Ty >
bool operator== ( const lognormal_distribution< _Ty > &  _Left,
const lognormal_distribution< _Ty > &  _Right 
)
4572  { // test for equality
4573  return (_Left.param() == _Right.param());
4574  }
lognormal_distribution::param
param_type param() const
Definition: random:4499
template<class _Ty >
bool operator== ( const chi_squared_distribution< _Ty > &  _Left,
const chi_squared_distribution< _Ty > &  _Right 
)
4731  { // test for equality
4732  return (_Left.param() == _Right.param());
4733  }
chi_squared_distribution::param
param_type param() const
Definition: random:4662
template<class _Ty >
bool operator== ( const cauchy_distribution< _Ty > &  _Left,
const cauchy_distribution< _Ty > &  _Right 
)
4909  { // test for equality
4910  return (_Left.param() == _Right.param());
4911  }
cauchy_distribution::param
param_type param() const
Definition: random:4835
template<class _Ty >
bool operator== ( const fisher_f_distribution< _Ty > &  _Left,
const fisher_f_distribution< _Ty > &  _Right 
)
5147  { // test for equality
5148  return (_Left.param() == _Right.param());
5149  }
fisher_f_distribution::param
param_type param() const
Definition: random:5071
template<class _Ty >
bool operator== ( const student_t_distribution< _Ty > &  _Left,
const student_t_distribution< _Ty > &  _Right 
)
5319  { // test for equality
5320  return (_Left.param() == _Right.param());
5321  }
student_t_distribution::param
param_type param() const
Definition: random:5237
template<class _Ty >
bool operator== ( const negative_binomial_distribution< _Ty > &  _Left,
const negative_binomial_distribution< _Ty > &  _Right 
)
5505  { // test for equality
5506  return (_Left.param() == _Right.param());
5507  }
negative_binomial_distribution::param
param_type param() const
Definition: random:5427
template<class _Ty >
bool operator== ( const discrete_distribution< _Ty > &  _Left,
const discrete_distribution< _Ty > &  _Right 
)
5776  { // test for equality
5777  return (_Left.param() == _Right.param());
5778  }
discrete_distribution::param
param_type param() const
Definition: random:5676
template<class _Ty >
bool operator== ( const piecewise_constant_distribution< _Ty > &  _Left,
const piecewise_constant_distribution< _Ty > &  _Right 
)
6036  { // test for equality
6037  return (_Left.param() == _Right.param());
6038  }
piecewise_constant_distribution::param
param_type param() const
Definition: random:5957
template<class _Ty >
bool operator== ( const piecewise_linear_distribution< _Ty > &  _Left,
const piecewise_linear_distribution< _Ty > &  _Right 
)
6349  { // test for equality
6350  return (_Left.param() == _Right.param());
6351  }
piecewise_linear_distribution::param
param_type param() const
Definition: random:6252
template<class _Elem , class _Traits , class _Uint , _Uint _Ax, _Uint _Cx, _Uint _Mx>
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
linear_congruential< _Uint, _Ax, _Cx, _Mx > &  _Eng 
)
613  { // read state from _Istr
614  _Wrap_istream<_Elem, _Traits, _Uint> _In(_Istr);
615  _Eng.seed(_In);
616  return (_Istr);
617  }
linear_congruential::seed
void seed(_Uint _X0=default_seed)
Definition: random:511
_Wrap_istream
Definition: random:182
_In
basic_istream< _Elem, _Traits > & _In(basic_istream< _Elem, _Traits > &_Is, _Ty &_Dx)
Definition: random:156
template<class _Elem , class _Traits , class _Ty , size_t _Sx, size_t _Rx, class _Swc_Traits >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
_Swc_base< _Ty, _Sx, _Rx, _Swc_Traits > &  _Eng 
)
924  { // read state from _Istr
925  _Wrap_istream<_Elem, _Traits, typename _Swc_Traits::_Seed_t>
926  _Gen(_Istr);
927  _Eng.seed(_Gen, true);
928  return (_Istr);
929  }
_Wrap_istream
Definition: random:182
_Swc_base::seed
void seed(_Seed_t _Value=default_seed)
Definition: random:794
template<class _Elem , class _S_Traits , class _Ty , int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
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 
)
1475  { // read state from _Istr
1476  _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr);
1477  _Eng.seed(_Gen);
1478  return (_Istr);
1479  }
_Wrap_istream
Definition: random:182
mersenne_twister::seed
void seed(_Ty _X0=default_seed, _Ty _Fx=(_Ty) 1812433253)
Definition: random:1337
template<class _Elem , class _Traits , class _Engine , int _Px, int _Rx>
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
discard_block< _Engine, _Px, _Rx > &  _Eng 
)
1760  { // read state from _Istr
1761  return (_Eng._Read(_Istr));
1762  }
discard_block::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:1703
template<class _Elem , class _Traits , class _Engine , size_t _Wx, class _UIntType >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
independent_bits_engine< _Engine, _Wx, _UIntType > &  _Eng 
)
2028  { // read state from _Istr
2029  return (_Eng._Read(_Istr));
2030  }
independent_bits_engine::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:1949
template<class _Elem , class _Traits , class _Engine , size_t _Kx>
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
shuffle_order_engine< _Engine, _Kx > &  _Eng 
)
2203  { // read state from _Istr
2204  return (_Eng._Read(_Istr));
2205  }
shuffle_order_engine::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2142
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
uniform_int< _Ty > &  _Dist 
)
2400  { // read state from _Istr
2401  return (_Dist._Read(_Istr));
2402  }
uniform_int::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2332
template<class _Elem , class _Traits >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
bernoulli_distribution &  _Dist 
)
2610  { // read state from _Istr
2611  return (_Dist._Read(_Istr));
2612  }
bernoulli_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2565
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
geometric_distribution< _Ty > &  _Dist 
)
2774  { // read state from _Istr
2775  return (_Dist._Read(_Istr));
2776  }
geometric_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2725
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
poisson_distribution< _Ty > &  _Dist 
)
2994  { // read state from _Istr
2995  return (_Dist._Read(_Istr));
2996  }
poisson_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2929
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
binomial_distribution< _Ty > &  _Dist 
)
3224  { // read state from _Istr
3225  return (_Dist._Read(_Istr));
3226  }
binomial_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3140
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
uniform_real< _Ty > &  _Dist 
)
3386  { // read state from _Istr
3387  return (_Dist._Read(_Istr));
3388  }
uniform_real::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3349
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
exponential_distribution< _Ty > &  _Dist 
)
3601  { // read state from _Istr
3602  return (_Dist._Read(_Istr));
3603  }
exponential_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3553
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
normal_distribution< _Ty > &  _Dist 
)
3823  { // read state from _Istr
3824  return (_Dist._Read(_Istr));
3825  }
normal_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3737
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
gamma_distribution< _Ty > &  _Dist 
)
4056  { // read state from _Istr
4057  return (_Dist._Read(_Istr));
4058  }
gamma_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3953
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
weibull_distribution< _Ty > &  _Dist 
)
4235  { // read state from _Istr
4236  return (_Dist._Read(_Istr));
4237  }
weibull_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4183
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
extreme_value_distribution< _Ty > &  _Dist 
)
4412  { // read state from _Istr
4413  return (_Dist._Read(_Istr));
4414  }
extreme_value_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4360
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
lognormal_distribution< _Ty > &  _Dist 
)
4589  { // read state from _Istr
4590  return (_Dist._Read(_Istr));
4591  }
lognormal_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4537
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
chi_squared_distribution< _Ty > &  _Dist 
)
4748  { // read state from _Istr
4749  return (_Dist._Read(_Istr));
4750  }
chi_squared_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4700
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
cauchy_distribution< _Ty > &  _Dist 
)
4926  { // read state from _Istr
4927  return (_Dist._Read(_Istr));
4928  }
cauchy_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4873
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
fisher_f_distribution< _Ty > &  _Dist 
)
5164  { // read state from _Istr
5165  return (_Dist._Read(_Istr));
5166  }
fisher_f_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5109
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
student_t_distribution< _Ty > &  _Dist 
)
5336  { // read state from _Istr
5337  return (_Dist._Read(_Istr));
5338  }
student_t_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5275
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
negative_binomial_distribution< _Ty > &  _Dist 
)
5522  { // read state from _Istr
5523  return (_Dist._Read(_Istr));
5524  }
negative_binomial_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5465
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
discrete_distribution< _Ty > &  _Dist 
)
5793  { // read state from _Istr
5794  return (_Dist._Read(_Istr, _Dist._Par));
5795  }
discrete_distribution::_Par
param_type _Par
Definition: random:5770
discrete_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
Definition: random:5714
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
piecewise_constant_distribution< _Ty > &  _Dist 
)
6053  { // read state from _Istr
6054  return (_Dist._Read(_Istr));
6055  }
piecewise_constant_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5995
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
piecewise_linear_distribution< _Ty > &  _Dist 
)
6366  { // read state from _Istr
6367  return (_Dist._Read(_Istr, _Dist._Par));
6368  }
piecewise_linear_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
Definition: random:6290
piecewise_linear_distribution::_Par
param_type _Par
Definition: random:6343

Variable Documentation

constexpr long double _Exp1 = 2.71828182845904523536028747135266250L
constexpr int _MP_len = 5
constexpr int _Nwords = 4
constexpr long double _Pi = 3.14159265358979323846264338327950288L
constexpr long double _Two31 = 2147483648.0L
constexpr long double _Two32 = 4294967296.0L
Generated on Sat Jul 22 2017 14:35:49 for STLdoc by   doxygen 1.8.8