discard_block< _Engine, _Px, _Rx > Class Template Reference

Inheritance diagram for discard_block< _Engine, _Px, _Rx >:

Public Types
typedef discard_block< _Engine, _Px, _Rx >	_Myt
typedef _Engine	base_type
typedef _Engine::result_type	result_type

Public Member Functions
	discard_block ()
	discard_block (const _Engine &_Ex)
	discard_block (result_type _Seed)
template<class _Seed_seq , class = typename _Enable_if_seed_seq<_Seed_seq, _Myt, _Engine>::type>
	discard_block (_Seed_seq &_Seq)
void	seed ()
void	seed (result_type _X0)
template<class _Seed_seq , class = typename _Enable_if_seed_seq<_Seed_seq, _Myt>::type>
void	seed (_Seed_seq &_Seq)
const base_type &	base () const _NOEXCEPT
result_type()	min () const
result_type()	max () const
result_type	operator() ()
void	discard (unsigned long long _Nskip)
bool	_Equals (const _Myt &_Right) 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

Static Public Attributes
static constexpr int	block_size = _Px
static constexpr int	used_block = _Rx

Private Attributes
base_type	_Eng
int	_Nx

Member Typedef Documentation

template<class _Engine, int _Px, int _Rx>

typedef discard_block<_Engine, _Px, _Rx> discard_block< _Engine, _Px, _Rx >::_Myt

template<class _Engine, int _Px, int _Rx>

typedef _Engine discard_block< _Engine, _Px, _Rx >::base_type

template<class _Engine, int _Px, int _Rx>

typedef _Engine::result_type discard_block< _Engine, _Px, _Rx >::result_type

Constructor & Destructor Documentation

template<class _Engine, int _Px, int _Rx>

discard_block< _Engine, _Px, _Rx >::discard_block ( )

inline

        : _Eng(), _Nx(0)
        {   // construct
        }

template<class _Engine, int _Px, int _Rx>

discard_block< _Engine, _Px, _Rx >::discard_block ( const _Engine &  _Ex )

inlineexplicit

        : _Eng(_Ex), _Nx(0)
        {   // construct with engine initializer _Ex
        }

template<class _Engine, int _Px, int _Rx>

discard_block< _Engine, _Px, _Rx >::discard_block ( result_type  _Seed )

inlineexplicit

        : _Eng(_Seed), _Nx(0)
        {   // construct from specified seed value
        }

template<class _Engine, int _Px, int _Rx>

template<class _Seed_seq , class = typename _Enable_if_seed_seq<_Seed_seq, _Myt, _Engine>::type>

discard_block< _Engine, _Px, _Rx >::discard_block ( _Seed_seq &  _Seq )

inlineexplicit

        : _Eng(_Seq), _Nx(0)
        {   // construct from seed sequence
        }

Member Function Documentation

template<class _Engine, int _Px, int _Rx>

bool discard_block< _Engine, _Px, _Rx >::_Equals ( const _Myt &  _Right ) const

inline

        {   // return true if *this will generate same sequence as _Right
        return (_Eng == _Right._Eng && _Nx == _Right._Nx);
        }

template<class _Engine, int _Px, int _Rx>

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& discard_block< _Engine, _Px, _Rx >::_Read ( basic_istream< _Elem, _Traits > &  _Istr )

inline

        {   // read state from _Istr
        return (_Istr >> _Eng >> _Nx);
        }

template<class _Engine, int _Px, int _Rx>

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& discard_block< _Engine, _Px, _Rx >::_Write ( basic_ostream< _Elem, _Traits > &  _Ostr ) const

inline

        {   // write state to _Ostr
        return (_Ostr << _Eng << ' ' << _Nx);
        }

template<class _Engine, int _Px, int _Rx>

const base_type& discard_block< _Engine, _Px, _Rx >::base ( ) const

inline

        {   // return const reference to engine
        return (_Eng);
        }

template<class _Engine, int _Px, int _Rx>

void discard_block< _Engine, _Px, _Rx >::discard ( unsigned long long  _Nskip )

inline

        {   // discard _Nskip elements
        for (; 0 < _Nskip; --_Nskip)
            (*this)();
        }

template<class _Engine, int _Px, int _Rx>

result_type() discard_block< _Engine, _Px, _Rx >::max ( ) const

inline

        {   // return maximum possible generated value
        return ((_Eng.max)());
        }

template<class _Engine, int _Px, int _Rx>

result_type() discard_block< _Engine, _Px, _Rx >::min ( ) const

inline

        {   // return minimum possible generated value
        return ((_Eng.min)());
        }

template<class _Engine, int _Px, int _Rx>

result_type discard_block< _Engine, _Px, _Rx >::operator() ( )

inline

        {   // return next value
        if (_Rx <= _Nx)
            {   // discard values
            while (_Nx++ < _Px)
                _Eng();
            _Nx = 0;
            }
        ++_Nx;
        return (_Eng());
        }

template<class _Engine, int _Px, int _Rx>

void discard_block< _Engine, _Px, _Rx >::seed ( )

inline

        {   // seed engine from default value
        _Eng.seed();
        _Nx = 0;
        }

template<class _Engine, int _Px, int _Rx>

void discard_block< _Engine, _Px, _Rx >::seed ( result_type  _X0 )

inline

        {   // seed engine from specified value
        _Eng.seed(_X0);
        _Nx = 0;
        }

template<class _Engine, int _Px, int _Rx>

template<class _Seed_seq , class = typename _Enable_if_seed_seq<_Seed_seq, _Myt>::type>

void discard_block< _Engine, _Px, _Rx >::seed ( _Seed_seq &  _Seq )

inline

        {   // seed engine from seed sequence
        _Eng.seed(_Seq);
        _Nx = 0;
        }

Member Data Documentation

template<class _Engine, int _Px, int _Rx>

base_type discard_block< _Engine, _Px, _Rx >::_Eng

private

template<class _Engine, int _Px, int _Rx>

int discard_block< _Engine, _Px, _Rx >::_Nx

private

template<class _Engine, int _Px, int _Rx>

const int discard_block< _Engine, _Px, _Rx >::block_size = _Px

static

template<class _Engine, int _Px, int _Rx>

const int discard_block< _Engine, _Px, _Rx >::used_block = _Rx

static

---

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

• VS2015/inc/random