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

Classes

struct  _Is_RealType< _Ty >
 
struct  _Is_UIntType< _Ty >
 
struct  _Is_IntType< _Ty >
 
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_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 >
 
struct  _Swc_01_traits< _Ty, _Wx, _Rx >
 
class  subtract_with_carry_01< _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  xor_combine< _Engine1, _S1, _Engine2, _S2 >
 
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< _Ty0, _Ty1 >
 
struct  geometric_distribution< _Ty0, _Ty1 >::param_type
 
class  _Small_poisson_distribution< _Ty0, _Ty1 >
 
class  poisson_distribution< _Ty0, _Ty1 >
 
struct  poisson_distribution< _Ty0, _Ty1 >::param_type
 
class  binomial_distribution< _Ty0, _Ty1 >
 
struct  binomial_distribution< _Ty0, _Ty1 >::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
 

Namespaces

 tr1
 

Macros

#define _RANDOM_
 
#define _BITS_BYTE   8
 
#define _RNG_ASSERT(ex, msg)   ((void)0)
 
#define _NRAND(eng, resty)   _Nrand(eng, (eng.min)(), (resty)1)
 

Typedefs

typedef unsigned 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 subtract_with_carry_01< float, 24, 10, 24 > ranlux_base_01
 
typedef subtract_with_carry_01< double, 48, 5, 12 > ranlux64_base_01
 
typedef discard_block< ranlux_base_01, 223, 24 > ranlux3_01
 
typedef discard_block< ranlux_base_01, 389, 24 > ranlux4_01
 
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 _NO_RETURN (__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 _Engine , class _Ety , class _Rty >
_Rty _Nrand (_Engine &_Eng, _Ety _Emin, _Rty _Inc)
 
template<class _Engine , class _Rty >
_Rty _Nrand (_Engine &_Eng, float _Emin, _Rty)
 
template<class _Engine , class _Rty >
_Rty _Nrand (_Engine &_Eng, double _Emin, _Rty)
 
template<class _Engine , class _Rty >
_Rty _Nrand (_Engine &_Eng, long double _Emin, _Rty)
 
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 _Engine1 , int _S1, class _Engine2 , int _S2>
bool operator== (const xor_combine< _Engine1, _S1, _Engine2, _S2 > &_Left, const xor_combine< _Engine1, _S1, _Engine2, _S2 > &_Right)
 
template<class _Engine1 , int _S1, class _Engine2 , int _S2>
bool operator!= (const xor_combine< _Engine1, _S1, _Engine2, _S2 > &_Left, const xor_combine< _Engine1, _S1, _Engine2, _S2 > &_Right)
 
template<class _Elem , class _Traits , class _Engine1 , int _S1, class _Engine2 , int _S2>
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, xor_combine< _Engine1, _S1, _Engine2, _S2 > &_Eng)
 
template<class _Elem , class _Traits , class _Engine1 , int _S1, class _Engine2 , int _S2>
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const xor_combine< _Engine1, _S1, _Engine2, _S2 > &_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 _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 _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, geometric_distribution< _Ty0, _Ty1 > &_Dist)
 
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const geometric_distribution< _Ty0, _Ty1 > &_Dist)
 
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, poisson_distribution< _Ty0, _Ty1 > &_Dist)
 
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const poisson_distribution< _Ty0, _Ty1 > &_Dist)
 
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_istream< _Elem, _Traits > & operator>> (basic_istream< _Elem, _Traits > &_Istr, binomial_distribution< _Ty0, _Ty1 > &_Dist)
 
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_ostream< _Elem, _Traits > & operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const binomial_distribution< _Ty0, _Ty1 > &_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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 const long double _Pi = 3.14159265358979323846264338327950288L
 
static const long double _Exp1 = 2.71828182845904523536028747135266250L
 
static const long double _Two32 = 4294967296.0L
 
static const long double _Two31 = 2147483648.0L
 
static const int _Nwords = 4
 
static const int _MP_len = 5
 

Macro Definition Documentation

#define _BITS_BYTE   8
#define _NRAND (   eng,
  resty 
)    _Nrand(eng, (eng.min)(), (resty)1)
#define _RANDOM_
#define _RNG_ASSERT (   ex,
  msg 
)    ((void)0)

Typedef Documentation

typedef unsigned 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<_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<ranlux_base_01, 223, 24> ranlux3_01
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
typedef discard_block<ranlux_base_01, 389, 24> ranlux4_01
typedef subtract_with_carry_01<double, 48, 5, 12> ranlux64_base_01
typedef subtract_with_carry_01<float, 24, 10, 24> ranlux_base_01

Function Documentation

template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& _In ( basic_istream< _Elem, _Traits > &  _Is,
_Ty &  _Dx 
)
152  { // read from stream
153  long double _Vx;
154  _Ty _Max = (numeric_limits<_Ty>::max)();
155  _Read(_Is, _Vx);
156  if (_CSTD fabsl(_Vx) <= _Max)
157  _Dx = (_Ty)_Vx;
158  else if (_Vx < 0)
159  _Dx = -_Max;
160  else
161  _Dx = _Max;
162  return (_Is);
163  }
fabsl
__inline long double __CRTDECL fabsl(_In_ long double _X)
Definition: math.h:856
_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Is, long double &_Dx)
Definition: random:130
_CSTD
#define _CSTD
Definition: yvals.h:559
numeric_limits
Definition: limits:79
_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   
)
_CRTIMP2_PURE _NO_RETURN ( __CLRCALL_PURE_OR_CDECL   _Rng_abort_In_z_ const char *_Msg)
template<class _Engine , class _Ety , class _Rty >
_Rty _Nrand ( _Engine &  _Eng,
_Ety  _Emin,
_Rty  _Inc 
)
80  { // scale random value to [0, 1), integer engine
81  return ((_Eng() - _Emin)
82  / ((_Rty)(_Eng.max)() - (_Rty)_Emin + _Inc));
83  }
template<class _Engine , class _Rty >
_Rty _Nrand ( _Engine &  _Eng,
float  _Emin,
_Rty   
)
88  { // scale random value to [0, 1), float engine
89  return ((_Eng() - _Emin) / ((_Eng.max)() - _Emin));
90  }
template<class _Engine , class _Rty >
_Rty _Nrand ( _Engine &  _Eng,
double  _Emin,
_Rty   
)
95  { // scale random value to [0, 1), double engine
96  return ((_Eng() - _Emin) / ((_Eng.max)() - _Emin));
97  }
template<class _Engine , class _Rty >
_Rty _Nrand ( _Engine &  _Eng,
long double  _Emin,
_Rty   
)
102  { // scale random value to [0, 1), long double engine
103  return ((_Eng() - _Emin) / ((_Eng.max)() - _Emin));
104  }
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& _Out ( basic_ostream< _Elem, _Traits > &  _Os,
_Ty  _Dx 
)
170  { // write to stream
171  return (_Write(_Os, _Dx));
172  }
_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Os, long double _Dx)
Definition: random:111
_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 
)
131  { // read long double from stream
132  long double _Frac = 0.0;
133  long _Digits;
134  for (int _Nw = 0; _Nw < _Nwords; ++_Nw)
135  { // accumulate 31-bit words
136  _Is >> _Digits;
137  long double _Temp = _Digits / _Two31;
138  for (int _Idx = 0; _Idx < _Nw; ++_Idx)
139  _Temp /= _Two31;
140  _Frac += _Temp;
141  }
142  _Is >> _Digits;
143  _Dx = _CSTD ldexpl(_Frac, _Digits);
144  return (_Is);
145  }
ldexpl
__inline long double __CRTDECL ldexpl(_In_ long double _X, _In_ int _Y)
Definition: math.h:894
_CSTD
#define _CSTD
Definition: yvals.h:559
_Two31
static const long double _Two31
Definition: random:65
_Nwords
static const int _Nwords
Definition: random:107
template<class _Elem , class _Traits >
basic_ostream<_Elem, _Traits>& _Write ( basic_ostream< _Elem, _Traits > &  _Os,
long double  _Dx 
)
113  { // write long double to stream
114  int _Ex;
115  long double _Frac = _CSTD frexpl(_Dx, &_Ex);
116  for (int _Nw = 0; _Nw < _Nwords; ++_Nw)
117  { // break into 31-bit words
118  _Frac *= _Two31;
119  long _Digits = (long)_Frac;
120  _Frac -= _Digits;
121  _Os << ' ' << _Digits;
122  }
123  _Os << ' ' << _Ex;
124  return (_Os);
125  }
_CSTD
#define _CSTD
Definition: yvals.h:559
_Two31
static const long double _Two31
Definition: random:65
frexpl
__inline long double __CRTDECL frexpl(_In_ long double _X, _Out_ int *_Y)
Definition: math.h:877
_Nwords
static const int _Nwords
Definition: random:107
_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)
315  { // build a floating-point value from random sequence
316  static_assert(_Is_RealType<_Real>::value,
317  "invalid template argument for generate_canonical");
318 
319  int _Minbits = _Bits < 1 ? 1 : _Bits;
320  if (numeric_limits<_Real>::digits < _Minbits)
321  _Minbits = numeric_limits<_Real>::digits;
322 
323  _Real _Gxmin = (_Real)(_Gx.min)();
324  _Real _Ans = (_Real)_Gx() - _Gxmin;
325  _Real _Base = (_Real)(_Gx.max)() + (_Real)1 - _Gxmin;
326  double _Basen = _CSTD ldexp(1.0, _Minbits);
327 
328  for (; 1.0 < _Basen; _Basen /= _Base)
329  _Ans = _Ans * _Base + (_Real)_Gx() - _Gxmin;
330  return (_Ans);
331  }
ldexp
_CRTIMP double __cdecl ldexp(_In_ double _X, _In_ int _Y)
_Is_RealType
Definition: random:33
_CSTD
#define _CSTD
Definition: yvals.h:559
numeric_limits
Definition: limits:79
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 
)
611  { // return true if *this will not generate same sequence as _Right
612  return (!_Left._Equals(_Right));
613  }
linear_congruential::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:556
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 
)
923  { // return true if _Left will not generate same sequence as _Right
924  return (!_Left._Equals(_Right));
925  }
_Swc_base::_Equals
bool _Equals(const _Swc_base &_Right) const
Definition: random:855
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 
)
1501  { // return true if _Left will not generate same sequence as _Right
1502  return (!_Left._Equals(_Right));
1503  }
_Circ_buf< _Ty, _Nx >::_Equals
bool _Equals(const _Circ_buf &_Right) const
Definition: random:728
template<class _Engine , int _Px, int _Rx>
bool operator!= ( const discard_block< _Engine, _Px, _Rx > &  _Left,
const discard_block< _Engine, _Px, _Rx > &  _Right 
)
1809  { // return true if _Left will not generate same sequence as _Right
1810  return (!(_Left == _Right));
1811  }
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 
)
2113  { // return true if _Left will not generate same sequence as _Right
2114  return (!(_Left == _Right));
2115  }
template<class _Engine , size_t _Kx>
bool operator!= ( const shuffle_order_engine< _Engine, _Kx > &  _Left,
const shuffle_order_engine< _Engine, _Kx > &  _Right 
)
2306  { // return true if _Left will not generate same sequence as _Right
2307  return (!(_Left == _Right));
2308  }
template<class _Engine1 , int _S1, class _Engine2 , int _S2>
bool operator!= ( const xor_combine< _Engine1, _S1, _Engine2, _S2 > &  _Left,
const xor_combine< _Engine1, _S1, _Engine2, _S2 > &  _Right 
)
2533  { // return true if _Left will not generate same sequence as _Right
2534  return (!(_Left == _Right));
2535  }
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 
)
639  { // write state to _Ostr
640  return (_Eng._Write(_Ostr));
641  }
linear_congruential::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:563
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 
)
952  { // write state to _Ostr
953  return (_Eng._Write(_Ostr));
954  }
_Swc_base::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:863
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 
)
1525  { // write state to _Ostr
1526  return (_Eng._Write(_Ostr));
1527  }
mersenne_twister::_Write
basic_ostream< _Elem, _S_Traits > & _Write(basic_ostream< _Elem, _S_Traits > &_Ostr) const
Definition: random:1397
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 
)
1833  { // write state to _Ostr
1834  return (_Eng._Write(_Ostr));
1835  }
discard_block::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:1772
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 
)
2137  { // write state to _Ostr
2138  return (_Eng._Write(_Ostr));
2139  }
independent_bits_engine::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2054
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 
)
2328  { // write state to _Ostr
2329  return (_Eng._Write(_Ostr));
2330  }
shuffle_order_engine::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2267
template<class _Elem , class _Traits , class _Engine1 , int _S1, class _Engine2 , int _S2>
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const xor_combine< _Engine1, _S1, _Engine2, _S2 > &  _Eng 
)
2559  { // write state to _Ostr
2560  return (_Ostr << _Eng.base1() << ' ' << _Eng.base2());
2561  }
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const uniform_int< _Ty > &  _Dist 
)
2756  { // write state to _Ostr
2757  return (_Dist._Write(_Ostr));
2758  }
uniform_int::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2690
template<class _Elem , class _Traits >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const bernoulli_distribution &  _Dist 
)
2941  { // write state to _Ostr
2942  return (_Dist._Write(_Ostr));
2943  }
bernoulli_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:2910
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const geometric_distribution< _Ty0, _Ty1 > &  _Dist 
)
3094  { // write state to _Ostr
3095  return (_Dist._Write(_Ostr));
3096  }
geometric_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3058
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const poisson_distribution< _Ty0, _Ty1 > &  _Dist 
)
3298  { // write state to _Ostr
3299  return (_Dist._Write(_Ostr));
3300  }
poisson_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3245
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const binomial_distribution< _Ty0, _Ty1 > &  _Dist 
)
3514  { // write state to _Ostr
3515  return (_Dist._Write(_Ostr));
3516  }
binomial_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3444
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const uniform_real< _Ty > &  _Dist 
)
3672  { // write state to _Ostr
3673  return (_Dist._Write(_Ostr));
3674  }
uniform_real::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3639
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const exponential_distribution< _Ty > &  _Dist 
)
3862  { // write state to _Ostr
3863  return (_Dist._Write(_Ostr));
3864  }
exponential_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:3829
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const normal_distribution< _Ty > &  _Dist 
)
4072  { // write state to _Ostr
4073  return (_Dist._Write(_Ostr));
4074  }
normal_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4006
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const gamma_distribution< _Ty > &  _Dist 
)
4293  { // write state to _Ostr
4294  return (_Dist._Write(_Ostr));
4295  }
gamma_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4207
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const weibull_distribution< _Ty > &  _Dist 
)
4459  { // write state to _Ostr
4460  return (_Dist._Write(_Ostr));
4461  }
weibull_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4424
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const extreme_value_distribution< _Ty > &  _Dist 
)
4623  { // write state to _Ostr
4624  return (_Dist._Write(_Ostr));
4625  }
extreme_value_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4588
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const lognormal_distribution< _Ty > &  _Dist 
)
4787  { // write state to _Ostr
4788  return (_Dist._Write(_Ostr));
4789  }
lognormal_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4752
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const chi_squared_distribution< _Ty > &  _Dist 
)
4933  { // write state to _Ostr
4934  return (_Dist._Write(_Ostr));
4935  }
chi_squared_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:4900
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const cauchy_distribution< _Ty > &  _Dist 
)
5098  { // write state to _Ostr
5099  return (_Dist._Write(_Ostr));
5100  }
cauchy_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5062
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const fisher_f_distribution< _Ty > &  _Dist 
)
5323  { // write state to _Ostr
5324  return (_Dist._Write(_Ostr));
5325  }
fisher_f_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5284
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const student_t_distribution< _Ty > &  _Dist 
)
5482  { // write state to _Ostr
5483  return (_Dist._Write(_Ostr));
5484  }
student_t_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5436
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const negative_binomial_distribution< _Ty > &  _Dist 
)
5655  { // write state to _Ostr
5656  return (_Dist._Write(_Ostr));
5657  }
negative_binomial_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:5615
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const discrete_distribution< _Ty > &  _Dist 
)
5900  { // write state to _Ostr
5901  return (_Dist._Write(_Ostr, _Dist._Par));
5902  }
discrete_distribution::_Par
param_type _Par
Definition: random:5881
discrete_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr, const param_type &_Par0) const
Definition: random:5844
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const piecewise_constant_distribution< _Ty > &  _Dist 
)
6146  { // write state to _Ostr
6147  return (_Dist._Write(_Ostr));
6148  }
piecewise_constant_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:6109
template<class _Elem , class _Traits , class _Ty >
basic_ostream<_Elem, _Traits>& operator<< ( basic_ostream< _Elem, _Traits > &  _Ostr,
const piecewise_linear_distribution< _Ty > &  _Dist 
)
6449  { // write state to _Ostr
6450  return (_Dist._Write(_Ostr));
6451  }
piecewise_linear_distribution::_Write
basic_ostream< _Elem, _Traits > & _Write(basic_ostream< _Elem, _Traits > &_Ostr) const
Definition: random:6399
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 _Left will generate same sequence as _Right
601  return (_Left._Equals(_Right));
602  }
linear_congruential::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:556
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 
)
913  { // return true if _Left will generate same sequence as _Right
914  return (_Left._Equals(_Right));
915  }
_Swc_base::_Equals
bool _Equals(const _Swc_base &_Right) const
Definition: random:855
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 
)
1490  { // return true if _Left will generate same sequence as _Right
1491  return (_Left._Equals(_Right));
1492  }
_Circ_buf< _Ty, _Nx >::_Equals
bool _Equals(const _Circ_buf &_Right) const
Definition: random:728
template<class _Engine , int _Px, int _Rx>
bool operator== ( const discard_block< _Engine, _Px, _Rx > &  _Left,
const discard_block< _Engine, _Px, _Rx > &  _Right 
)
1799  { // return true if _Left will generate same sequence as _Right
1800  return (_Left._Equals(_Right));
1801  }
discard_block::_Equals
bool _Equals(const _Myt &_Right) const
Definition: random:1757
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 
)
2103  { // return true if _Left will generate same sequence as _Right
2104  return (_Left.base() == _Right.base());
2105  }
independent_bits_engine::base
const _Engine & base() const _NOEXCEPT
Definition: random:1991
template<class _Engine , size_t _Kx>
bool operator== ( const shuffle_order_engine< _Engine, _Kx > &  _Left,
const shuffle_order_engine< _Engine, _Kx > &  _Right 
)
2297  { // return true if _Left will generate same sequence as _Right
2298  return (_Left.base() == _Right.base());
2299  }
shuffle_order_engine::base
const _Engine & base() const _NOEXCEPT
Definition: random:2224
template<class _Engine1 , int _S1, class _Engine2 , int _S2>
bool operator== ( const xor_combine< _Engine1, _S1, _Engine2, _S2 > &  _Left,
const xor_combine< _Engine1, _S1, _Engine2, _S2 > &  _Right 
)
2521  { // return true if _Left will generate same sequence as _Right
2522  return (_Left.base1() == _Right.base1()
2523  && _Left.base2() == _Right.base2());
2524  }
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 
)
624  { // read state from _Istr
625  _Wrap_istream<_Elem, _Traits, _Uint> _In(_Istr);
626  _Eng.seed(_In);
627  return (_Istr);
628  }
linear_congruential::seed
void seed(_Uint _X0=default_seed)
Definition: random:524
_Wrap_istream
Definition: random:177
_In
basic_istream< _Elem, _Traits > & _In(basic_istream< _Elem, _Traits > &_Is, _Ty &_Dx)
Definition: random:151
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 
)
936  { // read state from _Istr
937  _Wrap_istream<_Elem, _Traits, typename _Swc_Traits::_Seed_t>
938  _Gen(_Istr);
939  _Eng.seed(_Gen, true);
940  return (_Istr);
941  }
_Wrap_istream
Definition: random:177
_Swc_base::seed
void seed(unsigned long _Value=19780503U)
Definition: random:814
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 
)
1512  { // read state from _Istr
1513  _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr);
1514  _Eng.seed(_Gen);
1515  return (_Istr);
1516  }
mersenne_twister::seed
void seed(unsigned long _X0=default_seed, _Ty _Fx=(_Ty) 1812433253)
Definition: random:1376
_Wrap_istream
Definition: random:177
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 
)
1821  { // read state from _Istr
1822  return (_Eng._Read(_Istr));
1823  }
discard_block::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:1764
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 
)
2125  { // read state from _Istr
2126  return (_Eng._Read(_Istr));
2127  }
independent_bits_engine::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2046
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 
)
2317  { // read state from _Istr
2318  return (_Eng._Read(_Istr));
2319  }
shuffle_order_engine::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2256
template<class _Elem , class _Traits , class _Engine1 , int _S1, class _Engine2 , int _S2>
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
xor_combine< _Engine1, _S1, _Engine2, _S2 > &  _Eng 
)
2546  { // read state from _Istr
2547  return (_Istr >> _Eng._Base1() >> _Eng._Base2());
2548  }
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
uniform_int< _Ty > &  _Dist 
)
2746  { // read state from _Istr
2747  return (_Dist._Read(_Istr));
2748  }
uniform_int::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2678
template<class _Elem , class _Traits >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
bernoulli_distribution &  _Dist 
)
2932  { // read state from _Istr
2933  return (_Dist._Read(_Istr));
2934  }
bernoulli_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:2899
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
geometric_distribution< _Ty0, _Ty1 > &  _Dist 
)
3083  { // read state from _Istr
3084  return (_Dist._Read(_Istr));
3085  }
geometric_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3047
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
poisson_distribution< _Ty0, _Ty1 > &  _Dist 
)
3287  { // read state from _Istr
3288  return (_Dist._Read(_Istr));
3289  }
poisson_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3234
template<class _Elem , class _Traits , class _Ty0 , class _Ty1 >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
binomial_distribution< _Ty0, _Ty1 > &  _Dist 
)
3503  { // read state from _Istr
3504  return (_Dist._Read(_Istr));
3505  }
binomial_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3431
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
uniform_real< _Ty > &  _Dist 
)
3662  { // read state from _Istr
3663  return (_Dist._Read(_Istr));
3664  }
uniform_real::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3627
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
exponential_distribution< _Ty > &  _Dist 
)
3852  { // read state from _Istr
3853  return (_Dist._Read(_Istr));
3854  }
exponential_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3818
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
normal_distribution< _Ty > &  _Dist 
)
4062  { // read state from _Istr
4063  return (_Dist._Read(_Istr));
4064  }
normal_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:3990
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
gamma_distribution< _Ty > &  _Dist 
)
4283  { // read state from _Istr
4284  return (_Dist._Read(_Istr));
4285  }
gamma_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4194
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
weibull_distribution< _Ty > &  _Dist 
)
4449  { // read state from _Istr
4450  return (_Dist._Read(_Istr));
4451  }
weibull_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4411
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
extreme_value_distribution< _Ty > &  _Dist 
)
4613  { // read state from _Istr
4614  return (_Dist._Read(_Istr));
4615  }
extreme_value_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4575
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
lognormal_distribution< _Ty > &  _Dist 
)
4777  { // read state from _Istr
4778  return (_Dist._Read(_Istr));
4779  }
lognormal_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4739
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
chi_squared_distribution< _Ty > &  _Dist 
)
4923  { // read state from _Istr
4924  return (_Dist._Read(_Istr));
4925  }
chi_squared_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:4889
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
cauchy_distribution< _Ty > &  _Dist 
)
5088  { // read state from _Istr
5089  return (_Dist._Read(_Istr));
5090  }
cauchy_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5049
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
fisher_f_distribution< _Ty > &  _Dist 
)
5313  { // read state from _Istr
5314  return (_Dist._Read(_Istr));
5315  }
fisher_f_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5272
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
student_t_distribution< _Ty > &  _Dist 
)
5472  { // read state from _Istr
5473  return (_Dist._Read(_Istr));
5474  }
student_t_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5425
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
negative_binomial_distribution< _Ty > &  _Dist 
)
5645  { // read state from _Istr
5646  return (_Dist._Read(_Istr));
5647  }
negative_binomial_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:5602
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
discrete_distribution< _Ty > &  _Dist 
)
5890  { // read state from _Istr
5891  return (_Dist._Read(_Istr, _Dist._Par));
5892  }
discrete_distribution::_Par
param_type _Par
Definition: random:5881
discrete_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
Definition: random:5825
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
piecewise_constant_distribution< _Ty > &  _Dist 
)
6136  { // read state from _Istr
6137  return (_Dist._Read(_Istr));
6138  }
piecewise_constant_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr)
Definition: random:6092
template<class _Elem , class _Traits , class _Ty >
basic_istream<_Elem, _Traits>& operator>> ( basic_istream< _Elem, _Traits > &  _Istr,
piecewise_linear_distribution< _Ty > &  _Dist 
)
6439  { // read state from _Istr
6440  return (_Dist._Read(_Istr, _Dist._Par));
6441  }
piecewise_linear_distribution::_Read
basic_istream< _Elem, _Traits > & _Read(basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
Definition: random:6372
piecewise_linear_distribution::_Par
param_type _Par
Definition: random:6430

Variable Documentation

const long double _Exp1 = 2.71828182845904523536028747135266250L
static
const int _MP_len = 5
static
const int _Nwords = 4
static
const long double _Pi = 3.14159265358979323846264338327950288L
static
const long double _Two31 = 2147483648.0L
static
const long double _Two32 = 4294967296.0L
static
Generated on Sun Jul 23 2017 10:00:27 for STLdoc by   doxygen 1.8.8