binomial_distribution< _Ty > Class Template Reference

Classes
struct	param_type

Public Types
typedef binomial_distribution< _Ty >	_Myt
typedef double	_Ty1
typedef _Ty	result_type

Public Member Functions
	binomial_distribution (_Ty _T0=1, _Ty1 _P0=_Ty1(0.5))
	binomial_distribution (const param_type &_Par0)
_Ty	t () const
_Ty1	p () 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)
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) const

Private Attributes
param_type	_Par

Member Typedef Documentation

template<class _Ty = int>

typedef binomial_distribution<_Ty> binomial_distribution< _Ty >::_Myt

template<class _Ty = int>

typedef double binomial_distribution< _Ty >::_Ty1

template<class _Ty = int>

typedef _Ty binomial_distribution< _Ty >::result_type

Constructor & Destructor Documentation

template<class _Ty = int>

binomial_distribution< _Ty >::binomial_distribution ( _Ty  _T0 = 1, _Ty1  _P0 = _Ty1(0.5)  )

inlineexplicit

        : _Par(_T0, _P0)
        {   // construct
        }

template<class _Ty = int>

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

inlineexplicit

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

Member Function Documentation

template<class _Ty = int>

template<class _Engine >

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

inlineprivate

        {   // Press et al., Numerical Recipes in C, 2nd ed., pp 295-296.
        _Ty _Res;
        if (_Par0._Tx < 25)
            {   // generate directly
            _Res = 0;
            for (_Ty _Ix = 0; _Ix < _Par0._Tx; ++_Ix)
                if (_NRAND(_Eng, _Ty1) < _Par0._Px)
                    ++_Res;
            return (_Res);
            }
        else if (_Par0._Mean < 1.0)
            // events are rare, use Poisson distribution
            _Res = _Par0._Small(_Eng);
        else
            {   // no shortcuts
            for (; ; )
                {   // generate and reject
                _Ty1 _Yx;
                for (; ; )
                    {   // generate a tentative value
                    _Yx = (_Ty1)_CSTD tan(_Pi * _NRAND(_Eng, _Ty1));
                    _Res = (_Ty)(_Par0._Sqrt * _Yx + _Par0._Mean);
                    if (static_cast<_Ty>(0) <= _Res && _Res <= _Par0._Tx)
                        break;
                    }
                if (_NRAND(_Eng, _Ty1) <= 1.2 * _Par0._Sqrt
                    * (1.0 + _Yx * _Yx)
                    * _CSTD exp(_Par0._G1 - _XLgamma(_Res + 1.0)
                        - _XLgamma(_Par0._Tx - _Res
                        + 1.0) + _Res * _Par0._Logp
                        + (_Par0._Tx - _Res) * _Par0._Logp1))
                    break;
                }
            }
        return (_Par0._Px == _Par0._Pp ? _Res : (_Par0._Tx - _Res));
        }

template<class _Ty = int>

template<class _Elem , class _Traits >

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

inline

        {   // read state from _Istr
        _Ty _T0;
        _Ty1 _P0;
        _In(_Istr, _P0);
        _In(_Istr, _T0);
        _Par._Init(_T0, _P0);
        return (_Istr);
        }

template<class _Ty = int>

template<class _Elem , class _Traits >

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

inline

        {   // write state to _Ostr
        _Out(_Ostr, _Par._Px);
        _Out(_Ostr, _Par._Tx);
        return (_Ostr);
        }

template<class _Ty = int>

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

inline

        {   // get largest possible result
        return (_Par.t());
        }

template<class _Ty = int>

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

inline

        {   // get smallest possible result
        return (0);
        }

template<class _Ty = int>

template<class _Engine >

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

inline

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

template<class _Ty = int>

template<class _Engine >

result_type binomial_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>

_Ty1 binomial_distribution< _Ty >::p ( ) const

inline

        {   // return probability
        return (_Par.p());
        }

template<class _Ty = int>

param_type binomial_distribution< _Ty >::param ( ) const

inline

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

template<class _Ty = int>

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

inline

        {   // set parameter package
        _Par = _Par0;
        }

template<class _Ty = int>

void binomial_distribution< _Ty >::reset ( )

inline

        {   // clear internal state
        }

template<class _Ty = int>

_Ty binomial_distribution< _Ty >::t ( ) const

inline

        {   // return max value
        return (_Par.t());
        }

Member Data Documentation

template<class _Ty = int>

param_type binomial_distribution< _Ty >::_Par

private

---

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

• VS2015/inc/random