shuffle_order_engine< _Engine, _Kx > Class Template Reference

Public Types
typedef shuffle_order_engine< _Engine, _Kx >	_Myt
typedef _Engine	base_type
typedef _Engine::result_type	result_type

Public Member Functions
	shuffle_order_engine ()
	shuffle_order_engine (const shuffle_order_engine &_Right)
	shuffle_order_engine (shuffle_order_engine &_Right)
	shuffle_order_engine (const _Engine &_Ex)
	shuffle_order_engine (_Engine &_Ex)
	shuffle_order_engine (_Engine &&_Ex)
	shuffle_order_engine (result_type _X0)
template<class _Seed_seq , class = typename enable_if< !is_convertible<_Seed_seq, result_type>::value, void>::type>
	shuffle_order_engine (_Seed_seq &_Seq)
void	seed ()
void	seed (result_type _X0)
template<class _Seed_seq >
enable_if< !is_convertible< _Seed_seq, result_type >::value, void >::type	seed (_Seed_seq &_Seq)
const _Engine &	base () const _NOEXCEPT
result_type	operator() ()
void	discard (unsigned long long _Nskip)
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 Member Functions
static result_type()	min ()
static result_type()	max ()

Static Public Attributes
static const size_t	table_size = _Kx

Private Member Functions
void	_Init ()

Private Attributes
_Engine	_Eng
result_type	_Arr [_Kx]
result_type	_Yx
double	_Scale

Member Typedef Documentation

template<class _Engine, size_t _Kx>

typedef shuffle_order_engine<_Engine, _Kx> shuffle_order_engine< _Engine, _Kx >::_Myt

template<class _Engine, size_t _Kx>

typedef _Engine shuffle_order_engine< _Engine, _Kx >::base_type

template<class _Engine, size_t _Kx>

typedef _Engine::result_type shuffle_order_engine< _Engine, _Kx >::result_type

Constructor & Destructor Documentation

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( )

inline

        {   // construct
        _Init();
        }

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( const shuffle_order_engine< _Engine, _Kx > &  _Right )

inline

        {   // construct by copying
        *this = _Right;
        }

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( shuffle_order_engine< _Engine, _Kx > &  _Right )

inline

        {   // construct by copying
        *this = _Right;
        }

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( const _Engine &  _Ex )

inlineexplicit

        : _Eng(_Ex)
        {   // construct with engine initializer _Ex
        _Init();
        }

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( _Engine &  _Ex )

inlineexplicit

        : _Eng(_Ex)
        {   // construct with engine initializer _Ex
        _Init();
        }

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( _Engine &&  _Ex )

inlineexplicit

        : _Eng(_STD forward<_Engine>(_Ex))
        {   // construct with engine initializer _Ex
        _Init();
        }

template<class _Engine, size_t _Kx>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( result_type  _X0 )

inlineexplicit

        : _Eng(_X0)
        {   // construct from specified seed value
        _Init();
        }

template<class _Engine, size_t _Kx>

template<class _Seed_seq , class = typename enable_if< !is_convertible<_Seed_seq, result_type>::value, void>::type>

shuffle_order_engine< _Engine, _Kx >::shuffle_order_engine ( _Seed_seq &  _Seq )

inlineexplicit

        : _Eng(_Seq)
        {   // construct from seed sequence
        _Init();
        }

Member Function Documentation

template<class _Engine, size_t _Kx>

void shuffle_order_engine< _Engine, _Kx >::_Init ( )

inlineprivate

        {   // compute values for operator()
        for (size_t _Idx = 0; _Idx < _Kx; ++_Idx)
            _Arr[_Idx] = _Eng();
        _Yx = _Eng();
        _Scale = (double)_Kx
            / ((double)(_Eng.max)() - (double)(_Eng.min)() + 1.0);
        }

template<class _Engine, size_t _Kx>

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& shuffle_order_engine< _Engine, _Kx >::_Read ( basic_istream< _Elem, _Traits > &  _Istr )

inline

        {   // read state from _Istr
        _Istr >> _Eng;
        for (size_t _Idx = 0; _Idx < _Kx; ++_Idx)
            _Istr >> _Arr[_Idx];
        return (_Istr >> _Yx);
        }

template<class _Engine, size_t _Kx>

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& shuffle_order_engine< _Engine, _Kx >::_Write ( basic_ostream< _Elem, _Traits > &  _Ostr ) const

inline

        {   // write state to _Ostr
        _Ostr << _Eng;
        for (size_t _Idx = 0; _Idx < _Kx; ++_Idx)
            _Ostr << ' ' << _Arr[_Idx];
        return (_Ostr << ' ' << _Yx);
        }

template<class _Engine, size_t _Kx>

const _Engine& shuffle_order_engine< _Engine, _Kx >::base ( ) const

inline

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

template<class _Engine, size_t _Kx>

void shuffle_order_engine< _Engine, _Kx >::discard ( unsigned long long  _Nskip )

inline

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

template<class _Engine, size_t _Kx>

static result_type() shuffle_order_engine< _Engine, _Kx >::max ( )

inlinestatic

        {   // return maximum possible generated value
        return ((_Engine::max)());
        }

template<class _Engine, size_t _Kx>

static result_type() shuffle_order_engine< _Engine, _Kx >::min ( )

inlinestatic

        {   // return minimum possible generated value
        return ((_Engine::min)());
        }

template<class _Engine, size_t _Kx>

result_type shuffle_order_engine< _Engine, _Kx >::operator() ( )

inline

        {   // return next value
        size_t _Idx = (size_t)((double)(_Yx -  (_Eng.min)()) * _Scale);

        _Yx = _Arr[_Idx];
        _Arr[_Idx] = _Eng();
        return (_Yx);
        }

template<class _Engine, size_t _Kx>

void shuffle_order_engine< _Engine, _Kx >::seed ( )

inline

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

template<class _Engine, size_t _Kx>

void shuffle_order_engine< _Engine, _Kx >::seed ( result_type  _X0 )

inline

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

template<class _Engine, size_t _Kx>

template<class _Seed_seq >

enable_if< !is_convertible<_Seed_seq, result_type>::value, void>::type shuffle_order_engine< _Engine, _Kx >::seed ( _Seed_seq &  _Seq )

inline

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

Member Data Documentation

template<class _Engine, size_t _Kx>

result_type shuffle_order_engine< _Engine, _Kx >::_Arr[_Kx]

private

template<class _Engine, size_t _Kx>

_Engine shuffle_order_engine< _Engine, _Kx >::_Eng

private

template<class _Engine, size_t _Kx>

double shuffle_order_engine< _Engine, _Kx >::_Scale

private

template<class _Engine, size_t _Kx>

result_type shuffle_order_engine< _Engine, _Kx >::_Yx

private

template<class _Engine, size_t _Kx>

const size_t shuffle_order_engine< _Engine, _Kx >::table_size = _Kx

static

---

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

• VS2013/inc/random