normal_distribution< _Ty > Class Template Reference

Classes
struct	param_type

Public Types
typedef normal_distribution< _Ty >	_Myt
typedef _Ty	result_type

Public Member Functions
	normal_distribution (_Ty _Mean0=0.0, _Ty _Sigma0=1.0)
	normal_distribution (const param_type &_Par0)
_Ty	mean () const
_Ty	sigma () const
_Ty	stddev () const
param_type	param () const
void	param (const param_type &_Par0)
result_type()	min () const
result_type()	max () const
void	reset ()
template<class _Engine >
result_type	operator() (_Engine &_Eng)
template<class _Engine >
result_type	operator() (_Engine &_Eng, const param_type &_Par0)
template<class _Elem , class _Traits >
basic_istream< _Elem, _Traits > &	_Read (basic_istream< _Elem, _Traits > &_Istr)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	_Write (basic_ostream< _Elem, _Traits > &_Ostr) const

Private Member Functions
template<class _Engine >
result_type	_Eval (_Engine &_Eng, const param_type &_Par0, bool _Keep=true)

Private Attributes
param_type	_Par
bool	_Valid
_Ty	_X2

Member Typedef Documentation

template<class _Ty = double>

typedef normal_distribution<_Ty> normal_distribution< _Ty >::_Myt

template<class _Ty = double>

typedef _Ty normal_distribution< _Ty >::result_type

Constructor & Destructor Documentation

template<class _Ty = double>

normal_distribution< _Ty >::normal_distribution ( _Ty  _Mean0 = 0.0, _Ty  _Sigma0 = 1.0  )

inlineexplicit

        : _Par(_Mean0, _Sigma0), _Valid(false), _X2(0)
        {   // construct
        }

template<class _Ty = double>

normal_distribution< _Ty >::normal_distribution ( const param_type &  _Par0 )

inlineexplicit

        : _Par(_Par0), _Valid(false), _X2(0)
        {   // construct from parameter package
        }

Member Function Documentation

template<class _Ty = double>

template<class _Engine >

result_type normal_distribution< _Ty >::_Eval ( _Engine &  _Eng, const param_type &  _Par0, bool  _Keep = true  )

inlineprivate

        {   // compute next value
            // Knuth, vol. 2, p. 122, alg. P
        _Ty _Res;
        if (_Keep && _Valid)
            {   // return stored value
            _Res = _X2;
            _Valid = false;
            }
        else
            {   // generate two values, store one, return one
            double _V1, _V2, _Sx;
            for (; ; )
                {   // reject bad values
                _V1 = 2 * _NRAND(_Eng, _Ty) - 1.0;
                _V2 = 2 * _NRAND(_Eng, _Ty) - 1.0;
                _Sx = _V1 * _V1 + _V2 * _V2;
                if (_Sx < 1.0)
                    break;
                }
            double _Fx = _CSTD sqrt(-2.0 * _CSTD log(_Sx) / _Sx);
            if (_Keep)
                {   // save second value for next call
                _X2 = _Fx * _V2;
                _Valid = true;
                }
            _Res = _Fx * _V1;
            }
        return (_Res * _Par0._Sigma + _Par0._Mean);
        }

template<class _Ty = double>

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& normal_distribution< _Ty >::_Read ( basic_istream< _Elem, _Traits > &  _Istr )

inline

        {   // read state from _Istr
        _Ty _Mean0;
        _Ty _Sigma0;
        _In(_Istr, _Mean0);
        _In(_Istr, _Sigma0);
        _Par._Init(_Mean0, _Sigma0);

        _Istr >> _Valid;
        _In(_Istr, _X2);
        return (_Istr);
        }

template<class _Ty = double>

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& normal_distribution< _Ty >::_Write ( basic_ostream< _Elem, _Traits > &  _Ostr ) const

inline

        {   // write state to _Ostr
        _Out(_Ostr, _Par._Mean);
        _Out(_Ostr, _Par._Sigma);

        _Ostr << ' ' << _Valid;
        _Out(_Ostr, _X2);
        return (_Ostr);
        }

template<class _Ty = double>

result_type() normal_distribution< _Ty >::max ( ) const

inline

        {   // get largest possible result
        return ((numeric_limits<result_type>::max)());
        }

template<class _Ty = double>

_Ty normal_distribution< _Ty >::mean ( ) const

inline

        {   // return mean value
        return (_Par.mean());
        }

template<class _Ty = double>

result_type() normal_distribution< _Ty >::min ( ) const

inline

        {   // get smallest possible result
        return (numeric_limits<result_type>::denorm_min());
        }

template<class _Ty = double>

template<class _Engine >

result_type normal_distribution< _Ty >::operator() ( _Engine &  _Eng )

inline

        {   // return next value
        return (_Eval(_Eng, _Par));
        }

template<class _Ty = double>

template<class _Engine >

result_type normal_distribution< _Ty >::operator() ( _Engine &  _Eng, const param_type &  _Par0  )

inline

        {   // return next value, given parameter package
        reset();
        return (_Eval(_Eng, _Par0, false));
        }

template<class _Ty = double>

param_type normal_distribution< _Ty >::param ( ) const

inline

        {   // return parameter package
        return (_Par);
        }

template<class _Ty = double>

void normal_distribution< _Ty >::param ( const param_type &  _Par0 )

inline

        {   // set parameter package
        _Par = _Par0;
        reset();
        }

template<class _Ty = double>

void normal_distribution< _Ty >::reset ( )

inline

        {   // clear internal state
        _Valid = false;
        }

template<class _Ty = double>

_Ty normal_distribution< _Ty >::sigma ( ) const

inline

        {   // return sigma value
        return (_Par.sigma());
        }

template<class _Ty = double>

_Ty normal_distribution< _Ty >::stddev ( ) const

inline

        {   // return sigma value
        return (_Par.sigma());
        }

Member Data Documentation

template<class _Ty = double>

param_type normal_distribution< _Ty >::_Par

private

template<class _Ty = double>

bool normal_distribution< _Ty >::_Valid

private

template<class _Ty = double>

_Ty normal_distribution< _Ty >::_X2

private

---

The documentation for this class was generated from the following file:

• VS2015/inc/random