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 _NRAND(eng, resty)   (_STD generate_canonical<resty, static_cast<size_t>(-1)>(eng))
 

Typedefs

typedef _ULONGLONG _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< _ULonglong, 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< _ULonglong, 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

static constexpr long double _Pi = 3.14159265358979323846264338327950288L
 
static constexpr long double _Exp1 = 2.71828182845904523536028747135266250L
 
static constexpr long double _Two32 = 4294967296.0L
 
static constexpr long double _Two31 = 2147483648.0L
 
static constexpr int _Nwords = 4
 
static 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)

Typedef Documentation

typedef _ULONGLONG _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<_ULonglong, 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<_ULonglong, 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 
)
134  { // read from stream
135  long double _Vx;
136  _Ty _Max = (numeric_limits<_Ty>::max)();
137  _Read(_Is, _Vx);
138  if (_CSTD fabsl(_Vx) <= _Max)
139  _Dx = (_Ty)_Vx;
140  else if (_Vx < 0)
141  _Dx = -_Max;
142  else
143  _Dx = _Max;
144  return (_Is);
145  }
_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Is, long double &_Dx)
Definition: random:112
_CSTD
#define _CSTD
Definition: yvals.h:570
numeric_limits
Definition: limits:101
_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 
)
152  { // write to stream
153  return (_Write(_Os, _Dx));
154  }
_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Os, long double _Dx)
Definition: random:93
_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 
)
113  { // read long double from stream
114  long double _Frac = 0.0;
115  long _Digits;
116  for (int _Nw = 0; _Nw < _Nwords; ++_Nw)
117  { // accumulate 31-bit words
118  _Is >> _Digits;
119  long double _Temp = _Digits / _Two31;
120  for (int _Idx = 0; _Idx < _Nw; ++_Idx)
121  _Temp /= _Two31;
122  _Frac += _Temp;
123  }
124  _Is >> _Digits;
125  _Dx = _CSTD ldexpl(_Frac, _Digits);
126  return (_Is);
127  }
_Two31
static constexpr long double _Two31
Definition: random:80
_Nwords
static constexpr int _Nwords
Definition: random:89
_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 
)
95  { // write long double to stream
96  int _Ex;
97  long double _Frac = _CSTD frexpl(_Dx, &_Ex);
98  for (int _Nw = 0; _Nw < _Nwords; ++_Nw)
99  { // break into 31-bit words
100  _Frac *= _Two31;
101  long _Digits = (long)_Frac;
102  _Frac -= _Digits;
103  _Os << ' ' << _Digits;
104  }
105  _Os << ' ' << _Ex;
106  return (_Os);
107  }
_Two31
static constexpr long double _Two31
Definition: random:80
_Nwords
static constexpr int _Nwords
Definition: random:89
_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)
296  { // build a floating-point value from random sequence
297  static_assert(_Is_RealType<_Real>::value,
298  "invalid template argument for generate_canonical");
299 
300  const size_t _Digits = static_cast<size_t>(numeric_limits<_Real>::digits);
301  const size_t _Minbits = _Digits < _Bits ? _Digits : _Bits;
302 
303  const _Real _Gxmin = static_cast<_Real>((_Gx.min)());
304  const _Real _Gxmax = static_cast<_Real>((_Gx.max)());
305  const _Real _Rx = (_Gxmax - _Gxmin) + static_cast<_Real>(1);
306 
307  const int _Ceil = static_cast<int>(_STD ceil(
308  static_cast<_Real>(_Minbits) / _STD log2(_Rx)));
309  const int _Kx = _Ceil < 1 ? 1 : _Ceil;
310 
311  _Real _Ans = static_cast<_Real>(0);
312  _Real _Factor = static_cast<_Real>(1);
313 
314  for (int _Idx = 0; _Idx < _Kx; ++_Idx)
315  { // add in another set of bits
316  _Ans += (static_cast<_Real>(_Gx()) - _Gxmin) * _Factor;
317  _Factor *= _Rx;
318  }
319 
320  return (_Ans / _Factor);
321  }
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
_Is_RealType
Definition: random:33
_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:101
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 
)
578  { // return true if *this will not generate same sequence as _Right
579  return (!_Left._Equals(_Right));
580  }
linear_congruential::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:521
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 
)
888  { // return true if _Left will not generate same sequence as _Right
889  return (!_Left._Equals(_Right));
890  }
_Swc_base::_Equals
bool _Equals(const _Swc_base &_Right) const
Definition: random:812
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 
)
1430  { // return true if _Left will not generate same sequence as _Right
1431  return (!_Left._Equals(_Right));
1432  }
_Circ_buf< _Ty, _Nx >::_Equals
bool _Equals(const _Circ_buf &_Right) const
Definition: random:682
template<class _Engine , int _Px, int _Rx>
bool operator!= ( const discard_block< _Engine, _Px, _Rx > &  _Left,
const discard_block< _Engine, _Px, _Rx > &  _Right 
)
1715  { // return true if _Left will not generate same sequence as _Right
1716  return (!(_Left == _Right));
1717  }
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 
)
1982  { // return true if _Left will not generate same sequence as _Right
1983  return (!(_Left == _Right));
1984  }
template<class _Engine , size_t _Kx>
bool operator!= ( const shuffle_order_engine< _Engine, _Kx > &  _Left,
const shuffle_order_engine< _Engine, _Kx > &  _Right 
)
2158  { // return true if _Left will not generate same sequence as _Right
2159  return (!(_Left == _Right));
2160  }
template<class _Ty >
bool operator!= ( const uniform_int_distribution< _Ty > &  _Left,
const uniform_int_distribution< _Ty > &  _Right 
)
2433  { // test for inequality
2434  return (!(_Left == _Right));
2435  }
bool operator!= ( const bernoulli_distribution &  _Left,
const bernoulli_distribution &  _Right 
)
inline
2568  { // test for inequality
2569  return (!(_Left == _Right));
2570  }
template<class _Ty >
bool operator!= ( const geometric_distribution< _Ty > &  _Left,
const geometric_distribution< _Ty > &  _Right 
)
2732  { // test for inequality
2733  return (!(_Left == _Right));
2734  }
template<class _Ty >
bool operator!= ( const poisson_distribution< _Ty > &  _Left,
const poisson_distribution< _Ty > &  _Right 
)
2953  { // test for inequality
2954  return (!(_Left == _Right));
2955  }
template<class _Ty >
bool operator!= ( const binomial_distribution< _Ty > &  _Left,
const binomial_distribution< _Ty > &  _Right 
)
3184  { // test for inequality
3185  return (!(_Left == _Right));
3186  }
template<class _Ty >
bool operator!= ( const uniform_real_distribution< _Ty > &  _Left,
const uniform_real_distribution< _Ty > &  _Right 
)
3423  { // test for inequality
3424  return (!(_Left == _Right));
3425  }
template<class _Ty >
bool operator!= ( const exponential_distribution< _Ty > &  _Left,
const exponential_distribution< _Ty > &  _Right 
)
3563  { // test for inequality
3564  return (!(_Left == _Right));
3565  }
template<class _Ty >
bool operator!= ( const normal_distribution< _Ty > &  _Left,
const normal_distribution< _Ty > &  _Right 
)
3786  { // test for inequality
3787  return (!(_Left == _Right));
3788  }
template<class _Ty >
bool operator!= ( const gamma_distribution< _Ty > &  _Left,
const gamma_distribution< _Ty > &  _Right 
)
4020  { // test for inequality
4021  return (!(_Left == _Right));
4022  }
template<class _Ty >
bool operator!= ( const weibull_distribution< _Ty > &  _Left,
const weibull_distribution< _Ty > &  _Right 
)
4200  { // test for inequality
4201  return (!(_Left == _Right));
4202  }
template<class _Ty >
bool operator!= ( const extreme_value_distribution< _Ty > &  _Left,
const extreme_value_distribution< _Ty > &  _Right 
)
4378  { // test for inequality
4379  return (!(_Left == _Right));
4380  }
template<class _Ty >
bool operator!= ( const lognormal_distribution< _Ty > &  _Left,
const lognormal_distribution< _Ty > &  _Right 
)
4556  { // test for inequality
4557  return (!(_Left == _Right));
4558  }
template<class _Ty >
bool operator!= ( const chi_squared_distribution< _Ty > &  _Left,
const chi_squared_distribution< _Ty > &  _Right 
)
4716  { // test for inequality
4717  return (!(_Left == _Right));
4718  }
template<class _Ty >
bool operator!= ( const cauchy_distribution< _Ty > &  _Left,
const cauchy_distribution< _Ty > &  _Right 
)
4895  { // test for inequality
4896  return (!(_Left == _Right));
4897  }
template<class _Ty >
bool operator!= ( const fisher_f_distribution< _Ty > &  _Left,
const fisher_f_distribution< _Ty > &  _Right 
)
5134  { // test for inequality
5135  return (!(_Left == _Right));
5136  }
template<class _Ty >
bool operator!= ( const student_t_distribution< _Ty > &  _Left,
const student_t_distribution< _Ty > &  _Right 
)
5307  { // test for inequality
5308  return (!(_Left == _Right));
5309  }
template<class _Ty >
bool operator!= ( const negative_binomial_distribution< _Ty > &  _Left,
const negative_binomial_distribution< _Ty > &  _Right 
)
5494  { // test for inequality
5495  return (!(_Left == _Right));
5496  }
template<class _Ty >
bool operator!= ( const discrete_distribution< _Ty > &  _Left,
const discrete_distribution< _Ty > &  _Right 
)
5766  { // test for inequality
5767  return (!(_Left == _Right));
5768  }
template<class _Ty >
bool operator!= ( const piecewise_constant_distribution< _Ty > &  _Left,
const piecewise_constant_distribution< _Ty > &  _Right 
)
6027  { // test for inequality
6028  return (!(_Left == _Right));
6029  }
template<class _Ty >
bool operator!= ( const piecewise_linear_distribution< _Ty > &  _Left,
const piecewise_linear_distribution< _Ty > &  _Right 
)
6341  { // test for inequality
6342  return (!(_Left == _Right));
6343  }
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 
)
606  { // write state to _Ostr
607  return (_Eng._Write(_Ostr));
608  }
linear_congruential::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:529
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 
)
917  { // write state to _Ostr
918  return (_Eng._Write(_Ostr));
919  }
_Swc_base::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:821
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 
)
1456  { // write state to _Ostr
1457  return (_Eng._Write(_Ostr));
1458  }
mersenne_twister::_Write
basic_ostream< _Elem, _S_Traits > & _Write(basic_ostream< _Elem, _S_Traits > &_Ostr) const
Definition: random:1326
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 
)
1739  { // write state to _Ostr
1740  return (_Eng._Write(_Ostr));
1741  }
discard_block::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:1678
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 
)
2006  { // write state to _Ostr
2007  return (_Eng._Write(_Ostr));
2008  }
independent_bits_engine::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:1923
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 
)
2180  { // write state to _Ostr
2181  return (_Eng._Write(_Ostr));
2182  }
shuffle_order_engine::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2119
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const uniform_int< _Ty > &  _Dist 
)
2376  { // write state to _Ostr
2377  return (_Dist._Write(_Ostr));
2378  }
uniform_int::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2310
template<class _Elem , class _Traits >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const bernoulli_distribution &  _Dist 
)
2586  { // write state to _Ostr
2587  return (_Dist._Write(_Ostr));
2588  }
bernoulli_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2543
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const geometric_distribution< _Ty > &  _Dist 
)
2752  { // write state to _Ostr
2753  return (_Dist._Write(_Ostr));
2754  }
geometric_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2704
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const poisson_distribution< _Ty > &  _Dist 
)
2973  { // write state to _Ostr
2974  return (_Dist._Write(_Ostr));
2975  }
poisson_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2909
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const binomial_distribution< _Ty > &  _Dist 
)
3204  { // write state to _Ostr
3205  return (_Dist._Write(_Ostr));
3206  }
binomial_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3123
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const uniform_real< _Ty > &  _Dist 
)
3366  { // write state to _Ostr
3367  return (_Dist._Write(_Ostr));
3368  }
uniform_real::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3332
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const exponential_distribution< _Ty > &  _Dist 
)
3583  { // write state to _Ostr
3584  return (_Dist._Write(_Ostr));
3585  }
exponential_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3536
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const normal_distribution< _Ty > &  _Dist 
)
3806  { // write state to _Ostr
3807  return (_Dist._Write(_Ostr));
3808  }
normal_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3726
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const gamma_distribution< _Ty > &  _Dist 
)
4040  { // write state to _Ostr
4041  return (_Dist._Write(_Ostr));
4042  }
gamma_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3940
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const weibull_distribution< _Ty > &  _Dist 
)
4220  { // write state to _Ostr
4221  return (_Dist._Write(_Ostr));
4222  }
weibull_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4171
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const extreme_value_distribution< _Ty > &  _Dist 
)
4398  { // write state to _Ostr
4399  return (_Dist._Write(_Ostr));
4400  }
extreme_value_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4349
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const lognormal_distribution< _Ty > &  _Dist 
)
4576  { // write state to _Ostr
4577  return (_Dist._Write(_Ostr));
4578  }
lognormal_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4527
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const chi_squared_distribution< _Ty > &  _Dist 
)
4736  { // write state to _Ostr
4737  return (_Dist._Write(_Ostr));
4738  }
chi_squared_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4689
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const cauchy_distribution< _Ty > &  _Dist 
)
4915  { // write state to _Ostr
4916  return (_Dist._Write(_Ostr));
4917  }
cauchy_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4865
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const fisher_f_distribution< _Ty > &  _Dist 
)
5154  { // write state to _Ostr
5155  return (_Dist._Write(_Ostr));
5156  }
fisher_f_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5101
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const student_t_distribution< _Ty > &  _Dist 
)
5327  { // write state to _Ostr
5328  return (_Dist._Write(_Ostr));
5329  }
student_t_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5267
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const negative_binomial_distribution< _Ty > &  _Dist 
)
5514  { // write state to _Ostr
5515  return (_Dist._Write(_Ostr));
5516  }
negative_binomial_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5460
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const discrete_distribution< _Ty > &  _Dist 
)
5786  { // write state to _Ostr
5787  return (_Dist._Write(_Ostr, _Dist._Par));
5788  }
discrete_distribution::_Par
param_type _Par
Definition: random:5753
discrete_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr, const param_type &_Par0) const
Definition: random:5716
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const piecewise_constant_distribution< _Ty > &  _Dist 
)
6047  { // write state to _Ostr
6048  return (_Dist._Write(_Ostr));
6049  }
piecewise_constant_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5996
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const piecewise_linear_distribution< _Ty > &  _Dist 
)
6361  { // write state to _Ostr
6362  return (_Dist._Write(_Ostr));
6363  }
piecewise_linear_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:6302
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 
)
567  { // return true if _Left will generate same sequence as _Right
568  return (_Left._Equals(_Right));
569  }
linear_congruential::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:521
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 
)
878  { // return true if _Left will generate same sequence as _Right
879  return (_Left._Equals(_Right));
880  }
_Swc_base::_Equals
bool _Equals(const _Swc_base &_Right) const
Definition: random:812
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 
)
1419  { // return true if _Left will generate same sequence as _Right
1420  return (_Left._Equals(_Right));
1421  }
_Circ_buf< _Ty, _Nx >::_Equals
bool _Equals(const _Circ_buf &_Right) const
Definition: random:682
template<class _Engine , int _Px, int _Rx>
bool operator== ( const discard_block< _Engine, _Px, _Rx > &  _Left,
const discard_block< _Engine, _Px, _Rx > &  _Right 
)
1705  { // return true if _Left will generate same sequence as _Right
1706  return (_Left._Equals(_Right));
1707  }
discard_block::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:1663
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 
)
1972  { // return true if _Left will generate same sequence as _Right
1973  return (_Left.base() == _Right.base());
1974  }
independent_bits_engine::base
const _Engine & base() const _NOEXCEPT
Definition: random:1860
template<class _Engine , size_t _Kx>
bool operator== ( const shuffle_order_engine< _Engine, _Kx > &  _Left,
const shuffle_order_engine< _Engine, _Kx > &  _Right 
)
2149  { // return true if _Left will generate same sequence as _Right
2150  return (_Left.base() == _Right.base());
2151  }
shuffle_order_engine::base
const _Engine & base() const _NOEXCEPT
Definition: random:2076
template<class _Ty >
bool operator== ( const uniform_int_distribution< _Ty > &  _Left,
const uniform_int_distribution< _Ty > &  _Right 
)
2426  { // test for equality
2427  return (_Left.param() == _Right.param());
2428  }
uniform_int::param
param_type param() const
Definition: random:2254
bool operator== ( const bernoulli_distribution &  _Left,
const bernoulli_distribution &  _Right 
)
inline
2562  { // test for equality
2563  return (_Left.param() == _Right.param());
2564  }
bernoulli_distribution::param
param_type param() const
Definition: random:2494
template<class _Ty >
bool operator== ( const geometric_distribution< _Ty > &  _Left,
const geometric_distribution< _Ty > &  _Right 
)
2725  { // test for equality
2726  return (_Left.param() == _Right.param());
2727  }
geometric_distribution::param
param_type param() const
Definition: random:2655
template<class _Ty >
bool operator== ( const poisson_distribution< _Ty > &  _Left,
const poisson_distribution< _Ty > &  _Right 
)
2946  { // test for equality
2947  return (_Left.param() == _Right.param());
2948  }
poisson_distribution::param
param_type param() const
Definition: random:2860
template<class _Ty >
bool operator== ( const binomial_distribution< _Ty > &  _Left,
const binomial_distribution< _Ty > &  _Right 
)
3177  { // test for equality
3178  return (_Left.param() == _Right.param());
3179  }
binomial_distribution::param
param_type param() const
Definition: random:3072
template<class _Ty >
bool operator== ( const uniform_real_distribution< _Ty > &  _Left,
const uniform_real_distribution< _Ty > &  _Right 
)
3416  { // test for equality
3417  return (_Left.param() == _Right.param());
3418  }
uniform_real::param
param_type param() const
Definition: random:3281
template<class _Ty >
bool operator== ( const exponential_distribution< _Ty > &  _Left,
const exponential_distribution< _Ty > &  _Right 
)
3556  { // test for equality
3557  return (_Left.param() == _Right.param());
3558  }
exponential_distribution::param
param_type param() const
Definition: random:3487
template<class _Ty >
bool operator== ( const normal_distribution< _Ty > &  _Left,
const normal_distribution< _Ty > &  _Right 
)
3779  { // test for equality
3780  return (_Left.param() == _Right.param());
3781  }
normal_distribution::param
param_type param() const
Definition: random:3669
template<class _Ty >
bool operator== ( const gamma_distribution< _Ty > &  _Left,
const gamma_distribution< _Ty > &  _Right 
)
4013  { // test for equality
4014  return (_Left.param() == _Right.param());
4015  }
gamma_distribution::param
param_type param() const
Definition: random:3889
template<class _Ty >
bool operator== ( const weibull_distribution< _Ty > &  _Left,
const weibull_distribution< _Ty > &  _Right 
)
4193  { // test for equality
4194  return (_Left.param() == _Right.param());
4195  }
weibull_distribution::param
param_type param() const
Definition: random:4120
template<class _Ty >
bool operator== ( const extreme_value_distribution< _Ty > &  _Left,
const extreme_value_distribution< _Ty > &  _Right 
)
4371  { // test for equality
4372  return (_Left.param() == _Right.param());
4373  }
extreme_value_distribution::param
param_type param() const
Definition: random:4298
template<class _Ty >
bool operator== ( const lognormal_distribution< _Ty > &  _Left,
const lognormal_distribution< _Ty > &  _Right 
)
4549  { // test for equality
4550  return (_Left.param() == _Right.param());
4551  }
lognormal_distribution::param
param_type param() const
Definition: random:4476
template<class _Ty >
bool operator== ( const chi_squared_distribution< _Ty > &  _Left,
const chi_squared_distribution< _Ty > &  _Right 
)
4709  { // test for equality
4710  return (_Left.param() == _Right.param());
4711  }
chi_squared_distribution::param
param_type param() const
Definition: random:4640
template<class _Ty >
bool operator== ( const cauchy_distribution< _Ty > &  _Left,
const cauchy_distribution< _Ty > &  _Right 
)
4888  { // test for equality
4889  return (_Left.param() == _Right.param());
4890  }
cauchy_distribution::param
param_type param() const
Definition: random:4814
template<class _Ty >
bool operator== ( const fisher_f_distribution< _Ty > &  _Left,
const fisher_f_distribution< _Ty > &  _Right 
)
5127  { // test for equality
5128  return (_Left.param() == _Right.param());
5129  }
fisher_f_distribution::param
param_type param() const
Definition: random:5051
template<class _Ty >
bool operator== ( const student_t_distribution< _Ty > &  _Left,
const student_t_distribution< _Ty > &  _Right 
)
5300  { // test for equality
5301  return (_Left.param() == _Right.param());
5302  }
student_t_distribution::param
param_type param() const
Definition: random:5218
template<class _Ty >
bool operator== ( const negative_binomial_distribution< _Ty > &  _Left,
const negative_binomial_distribution< _Ty > &  _Right 
)
5487  { // test for equality
5488  return (_Left.param() == _Right.param());
5489  }
negative_binomial_distribution::param
param_type param() const
Definition: random:5409
template<class _Ty >
bool operator== ( const discrete_distribution< _Ty > &  _Left,
const discrete_distribution< _Ty > &  _Right 
)
5759  { // test for equality
5760  return (_Left.param() == _Right.param());
5761  }
discrete_distribution::param
param_type param() const
Definition: random:5659
template<class _Ty >
bool operator== ( const piecewise_constant_distribution< _Ty > &  _Left,
const piecewise_constant_distribution< _Ty > &  _Right 
)
6020  { // test for equality
6021  return (_Left.param() == _Right.param());
6022  }
piecewise_constant_distribution::param
param_type param() const
Definition: random:5941
template<class _Ty >
bool operator== ( const piecewise_linear_distribution< _Ty > &  _Left,
const piecewise_linear_distribution< _Ty > &  _Right 
)
6334  { // test for equality
6335  return (_Left.param() == _Right.param());
6336  }
piecewise_linear_distribution::param
param_type param() const
Definition: random:6237
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 
)
591  { // read state from _Istr
592  _Wrap_istream<_Elem, _Traits, _Uint> _In(_Istr);
593  _Eng.seed(_In);
594  return (_Istr);
595  }
linear_congruential::seed
void seed(_Uint _X0=default_seed)
Definition: random:489
_Wrap_istream
Definition: random:159
_In
basic_istream< _Elem, _Traits > & _In(basic_istream< _Elem, _Traits > &_Is, _Ty &_Dx)
Definition: random:133
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 
)
901  { // read state from _Istr
902  _Wrap_istream<_Elem, _Traits, typename _Swc_Traits::_Seed_t>
903  _Gen(_Istr);
904  _Eng.seed(_Gen, true);
905  return (_Istr);
906  }
_Wrap_istream
Definition: random:159
_Swc_base::seed
void seed(_Seed_t _Value=default_seed)
Definition: random:771
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 
)
1442  { // read state from _Istr
1443  _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr);
1444  _Eng.seed(_Gen);
1445  return (_Istr);
1446  }
_Wrap_istream
Definition: random:159
mersenne_twister::seed
void seed(_Ty _X0=default_seed, _Ty _Fx=(_Ty) 1812433253)
Definition: random:1304
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 
)
1727  { // read state from _Istr
1728  return (_Eng._Read(_Istr));
1729  }
discard_block::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:1670
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 
)
1994  { // read state from _Istr
1995  return (_Eng._Read(_Istr));
1996  }
independent_bits_engine::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:1915
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 
)
2169  { // read state from _Istr
2170  return (_Eng._Read(_Istr));
2171  }
shuffle_order_engine::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2108
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
uniform_int< _Ty > &  _Dist 
)
2366  { // read state from _Istr
2367  return (_Dist._Read(_Istr));
2368  }
uniform_int::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2298
template<class _Elem , class _Traits >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
bernoulli_distribution &  _Dist 
)
2577  { // read state from _Istr
2578  return (_Dist._Read(_Istr));
2579  }
bernoulli_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2532
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
geometric_distribution< _Ty > &  _Dist 
)
2742  { // read state from _Istr
2743  return (_Dist._Read(_Istr));
2744  }
geometric_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2693
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
poisson_distribution< _Ty > &  _Dist 
)
2963  { // read state from _Istr
2964  return (_Dist._Read(_Istr));
2965  }
poisson_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2898
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
binomial_distribution< _Ty > &  _Dist 
)
3194  { // read state from _Istr
3195  return (_Dist._Read(_Istr));
3196  }
binomial_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3110
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
uniform_real< _Ty > &  _Dist 
)
3356  { // read state from _Istr
3357  return (_Dist._Read(_Istr));
3358  }
uniform_real::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3319
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
exponential_distribution< _Ty > &  _Dist 
)
3573  { // read state from _Istr
3574  return (_Dist._Read(_Istr));
3575  }
exponential_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3525
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
normal_distribution< _Ty > &  _Dist 
)
3796  { // read state from _Istr
3797  return (_Dist._Read(_Istr));
3798  }
normal_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3710
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
gamma_distribution< _Ty > &  _Dist 
)
4030  { // read state from _Istr
4031  return (_Dist._Read(_Istr));
4032  }
gamma_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3927
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
weibull_distribution< _Ty > &  _Dist 
)
4210  { // read state from _Istr
4211  return (_Dist._Read(_Istr));
4212  }
weibull_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4158
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
extreme_value_distribution< _Ty > &  _Dist 
)
4388  { // read state from _Istr
4389  return (_Dist._Read(_Istr));
4390  }
extreme_value_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4336
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
lognormal_distribution< _Ty > &  _Dist 
)
4566  { // read state from _Istr
4567  return (_Dist._Read(_Istr));
4568  }
lognormal_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4514
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
chi_squared_distribution< _Ty > &  _Dist 
)
4726  { // read state from _Istr
4727  return (_Dist._Read(_Istr));
4728  }
chi_squared_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4678
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
cauchy_distribution< _Ty > &  _Dist 
)
4905  { // read state from _Istr
4906  return (_Dist._Read(_Istr));
4907  }
cauchy_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4852
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
fisher_f_distribution< _Ty > &  _Dist 
)
5144  { // read state from _Istr
5145  return (_Dist._Read(_Istr));
5146  }
fisher_f_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5089
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
student_t_distribution< _Ty > &  _Dist 
)
5317  { // read state from _Istr
5318  return (_Dist._Read(_Istr));
5319  }
student_t_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5256
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
negative_binomial_distribution< _Ty > &  _Dist 
)
5504  { // read state from _Istr
5505  return (_Dist._Read(_Istr));
5506  }
negative_binomial_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5447
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
discrete_distribution< _Ty > &  _Dist 
)
5776  { // read state from _Istr
5777  return (_Dist._Read(_Istr, _Dist._Par));
5778  }
discrete_distribution::_Par
param_type _Par
Definition: random:5753
discrete_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
Definition: random:5697
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
piecewise_constant_distribution< _Ty > &  _Dist 
)
6037  { // read state from _Istr
6038  return (_Dist._Read(_Istr));
6039  }
piecewise_constant_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5979
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
piecewise_linear_distribution< _Ty > &  _Dist 
)
6351  { // read state from _Istr
6352  return (_Dist._Read(_Istr, _Dist._Par));
6353  }
piecewise_linear_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
Definition: random:6275
piecewise_linear_distribution::_Par
param_type _Par
Definition: random:6328

Variable Documentation

constexpr long double _Exp1 = 2.71828182845904523536028747135266250L
static
constexpr int _MP_len = 5
static
constexpr int _Nwords = 4
static
constexpr long double _Pi = 3.14159265358979323846264338327950288L
static
constexpr long double _Two31 = 2147483648.0L
static
constexpr long double _Two32 = 4294967296.0L
static
Generated on Mon Jul 24 2017 18:15:35 for STLdoc by   doxygen 1.8.8