seed_seq Class Reference

Public Types
typedef unsigned int	result_type

Public Member Functions
	seed_seq ()
template<class _Ty >
	seed_seq (_XSTD initializer_list< _Ty > _Ilist)
template<class _InIt >
	seed_seq (_InIt _First, _InIt _Last)
template<class _RanIt >
void	generate (_RanIt _First, _RanIt _Last) const
template<class _OutIt >
void	param (_OutIt _Dest) const
size_t	size () const _NOEXCEPT
	seed_seq (const seed_seq &)=delete
void	operator= (const seed_seq &)=delete

Private Member Functions
template<class _InIt >
void	_Construct (_InIt _First, _InIt _Last)
template<class _RanIt >
void	_Generate_unchecked (_RanIt _First, _RanIt _Last) const
result_type	_Xor27 (result_type _Val) const

Private Attributes
vector< result_type >	_Myvec

Member Typedef Documentation

typedef unsigned int seed_seq::result_type

Constructor & Destructor Documentation

seed_seq::seed_seq ( )

inline

        {   // default constructor
        }

template<class _Ty >

seed_seq::seed_seq ( _XSTD initializer_list< _Ty >  _Ilist )

inline

        {   // construct from [_First, _Last)
        _Construct(_Ilist.begin(), _Ilist.end());
        }

template<class _InIt >

seed_seq::seed_seq ( _InIt  _First, _InIt  _Last  )

inline

        {   // construct from [_First, _Last)
        _Construct(_First, _Last);
        }

seed_seq::seed_seq ( const seed_seq &  )

delete

Member Function Documentation

template<class _InIt >

void seed_seq::_Construct ( _InIt  _First, _InIt  _Last  )

inlineprivate

        {   // construct from [_First, _Last)
        for (; _First != _Last; ++_First)
            _Myvec.push_back((unsigned int)*_First);
        }

template<class _RanIt >

void seed_seq::_Generate_unchecked ( _RanIt  _First, _RanIt  _Last  ) const

inlineprivate

        {   // generate randomized interval from seeds
        const size_t _Nx = _Last - _First;

        if (0 < _Nx)
            {   // finite interval, fill it
            const size_t _Sx = _Myvec.size();
            const size_t _Tx = 623 <= _Nx ? 11 : 68 <= _Nx ? 7
                : 39 <= _Nx ? 5 : 7 <= _Nx ? 3 : (_Nx - 1) / 2;
            const size_t _Px = (_Nx - _Tx) / 2;
            const size_t _Qx = _Px + _Tx;
            const size_t _Mx = _Nx <= _Sx ? _Sx + 1 : _Nx;
            size_t _Kx;

            _Iter_value_t<_RanIt> _Mask = _Iter_value_t<_RanIt>(1) << 31;
            _Mask <<= 1;    // build 32-bit mask safely
            _Mask -= 1;

            for (_Kx = 0; _Kx < _Nx; ++_Kx)
                _First[_Kx] = 0x8b8b8b8b;
            for (_Kx = 0; _Kx < _Mx; ++_Kx)
                {   // scramble and add any vector contributions
                result_type _R1 = 1664525 * _Xor27(_First[_Kx % _Nx]
                    ^ _First[(_Kx + _Px) % _Nx] ^ _First[(_Kx - 1) % _Nx]);
                result_type _R2 = (result_type)((_R1 + (_Kx == 0 ? _Sx
                    : _Kx <= _Sx ? _Kx % _Nx + _Myvec[(_Kx - 1) % _Sx]
                    : _Kx % _Nx)) & _Mask);

                _First[(_Kx + _Px) % _Nx] =
                    (_First[(_Kx + _Px) % _Nx] + _R1) & _Mask;
                _First[(_Kx + _Qx) % _Nx] =
                    (_First[(_Kx + _Qx) % _Nx] + _R2) & _Mask;
                _First[_Kx % _Nx] = _R2;
                }
            for (; _Kx < _Mx + _Nx; ++_Kx)
                {   // rescramble
                result_type _R3 = 1566083941 * _Xor27(_First[_Kx % _Nx]
                    + _First[(_Kx + _Px) % _Nx] + _First[(_Kx - 1) % _Nx]);
                result_type _R4 = (result_type)((_R3 - _Kx % _Nx) & _Mask);

                _First[(_Kx + _Px) % _Nx] =
                    (_First[(_Kx + _Px) % _Nx] ^ _R3) & _Mask;
                _First[(_Kx + _Qx) % _Nx] =
                    (_First[(_Kx + _Qx) % _Nx] ^ _R4) & _Mask;
                _First[_Kx % _Nx] = _R4;
                }
            }
        }

result_type seed_seq::_Xor27 ( result_type  _Val ) const

inlineprivate

        {   // shift and merge
        return (_Val ^ (_Val >> 27));
        }

template<class _RanIt >

void seed_seq::generate ( _RanIt  _First, _RanIt  _Last  ) const

inline

        {   // generate randomized interval from seeds
        _DEBUG_RANGE(_First, _Last);
        _Generate_unchecked(_Unchecked(_First), _Unchecked(_Last));
        }

void seed_seq::operator= ( const seed_seq &  )

delete

template<class _OutIt >

void seed_seq::param ( _OutIt  _Dest ) const

inline

        {   // copy seeds
        _STD copy(_Myvec.begin(), _Myvec.end(), _Dest);
        }

size_t seed_seq::size ( ) const

inline

        {   // get size of seed
        return (_Myvec.size());
        }

Member Data Documentation

vector<result_type> seed_seq::_Myvec

private

---

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

• VS2015/inc/random