discrete_distribution< _Ty > Class Template Reference

Classes
struct	param_type

Public Types
typedef discrete_distribution< _Ty >	_Myt
typedef vector< double >	_Myvec
typedef _Ty	result_type

Public Member Functions
	_RNG_REQUIRE_INTTYPE (discrete_distribution, _Ty)
	discrete_distribution ()
template<class _InIt >
	discrete_distribution (_InIt _First, _InIt _Last)
	discrete_distribution (initializer_list< double > _Ilist)
template<class _Fn >
	discrete_distribution (size_t _Count, double _Low, double _High, _Fn _Func)
	discrete_distribution (const param_type &_Par0)
_Myvec	probabilities () 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) const
template<class _Engine >
result_type	operator() (_Engine &_Eng, const param_type &_Par0) const
template<class _Elem , class _Traits >
basic_istream< _Elem, _Traits > &	_Read (basic_istream< _Elem, _Traits > &_Istr, param_type &_Par0)
template<class _Elem , class _Traits >
basic_ostream< _Elem, _Traits > &	_Write (basic_ostream< _Elem, _Traits > &_Ostr, const param_type &_Par0) const

Public Attributes
param_type	_Par

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

Member Typedef Documentation

template<class _Ty = int>

typedef discrete_distribution<_Ty> discrete_distribution< _Ty >::_Myt

template<class _Ty = int>

typedef vector<double> discrete_distribution< _Ty >::_Myvec

template<class _Ty = int>

typedef _Ty discrete_distribution< _Ty >::result_type

Constructor & Destructor Documentation

template<class _Ty = int>

discrete_distribution< _Ty >::discrete_distribution ( )

inline

        {   // default constructor
        }

template<class _Ty = int>

template<class _InIt >

discrete_distribution< _Ty >::discrete_distribution ( _InIt  _First, _InIt  _Last  )

inline

        : _Par(_First, _Last)
        {   // construct from [_First, _Last)
        }

template<class _Ty = int>

discrete_distribution< _Ty >::discrete_distribution ( initializer_list< double >  _Ilist )

inline

        : _Par(_Ilist)
        {   // construct from initializer list
        }

template<class _Ty = int>

template<class _Fn >

discrete_distribution< _Ty >::discrete_distribution ( size_t  _Count, double  _Low, double  _High, _Fn  _Func  )

inline

        : _Par(_Count, _Low, _High, _Func)
        {   // construct from function
        }

template<class _Ty = int>

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

inlineexplicit

        : _Par(_Par0)
        {   // construct from parameter package
        }

Member Function Documentation

template<class _Ty = int>

template<class _Engine >

result_type discrete_distribution< _Ty >::_Eval ( _Engine &  _Eng, const param_type &  _Par0  ) const

inlineprivate

        {   // return next value
        double _Px = _NRAND(_Eng, double);
        result_type _Count = (result_type)_Par0._Pcdf.size();
        result_type _First = 0;

        while (0 < _Count)
            {   // divide and conquer, find half that contains answer
            result_type _Count2 = _Count / 2;
            result_type _Mid = _First + _Count2;

            if (_Px <= _Par0._Pcdf[_Mid])
                _Count = _Count2;   // answer in first half, stay there
            else
                {   // answer in second half, move up
                _First = ++_Mid;
                _Count -= _Count2 + 1;
                }
            }
        return (_First);
        }

template<class _Ty = int>

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& discrete_distribution< _Ty >::_Read ( basic_istream< _Elem, _Traits > &  _Istr, param_type &  _Par0  )

inline

        {   // read state from _Istr
        size_t _Nvals;
        _Istr >> _Nvals;
        _Par0._Pvec.clear();
        for (; 0 < _Nvals; --_Nvals)
            {   // get a value and add to vector
            double _Val;
            _In(_Istr, _Val);
            _Par0._Pvec.push_back(_Val);
            }
        _Par0._Init(false); // don't renormalize, just compute CDF
        return (_Istr);
        }

template<class _Ty = int>

discrete_distribution< _Ty >::_RNG_REQUIRE_INTTYPE	(	discrete_distribution< _Ty >	,
		_Ty
	)

template<class _Ty = int>

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& discrete_distribution< _Ty >::_Write ( basic_ostream< _Elem, _Traits > &  _Ostr, const param_type &  _Par0  ) const

inline

        {   // write state to _Ostr
        size_t _Nvals = _Par0._Pvec.size();
        _Ostr << ' ' << _Nvals;

        for (size_t _Idx = 0; _Idx < _Par0._Pvec.size(); ++_Idx)
            _Out(_Ostr, _Par0._Pvec[_Idx]);
        return (_Ostr);
        }

template<class _Ty = int>

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

inline

        {   // return maximum possible generated value
        return ((result_type)(_Par._Pvec.size() - 1));
        }

template<class _Ty = int>

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

inline

        {   // return minimum possible generated value
        return (0);
        }

template<class _Ty = int>

template<class _Engine >

result_type discrete_distribution< _Ty >::operator() ( _Engine &  _Eng ) const

inline

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

template<class _Ty = int>

template<class _Engine >

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

inline

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

template<class _Ty = int>

param_type discrete_distribution< _Ty >::param ( ) const

inline

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

template<class _Ty = int>

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

inline

        {   // set parameter package
        _Par = _Par0;
        }

template<class _Ty = int>

_Myvec discrete_distribution< _Ty >::probabilities ( ) const

inline

        {   // return scaled probabilities vector
        return (_Par.probabilities());
        }

template<class _Ty = int>

void discrete_distribution< _Ty >::reset ( )

inline

        {   // clear internal state
        }

Member Data Documentation

template<class _Ty = int>

param_type discrete_distribution< _Ty >::_Par

---

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

• VS2017/inc/random