independent_bits_engine< _Engine, _Wx, _UIntType > Class Template Reference

Public Types
typedef independent_bits_engine< _Engine, _Wx, _UIntType >	_Myt
typedef _Engine	base_type
typedef _UIntType	result_type
typedef _Engine::result_type	_Eres

Public Member Functions
	independent_bits_engine ()
	independent_bits_engine (const _Engine &_Ex)
	independent_bits_engine (_Engine &&_Ex)
	independent_bits_engine (result_type _X0)
template<class _Seed_seq , class = typename _Enable_if_seed_seq<_Seed_seq, _Myt, _Engine>::type>
	independent_bits_engine (_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 _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 constexpr result_type()	min ()
static constexpr result_type()	max ()

Private Member Functions
void	_Init ()

Private Attributes
_Engine	_Eng
size_t	_N0
size_t	_Nx
size_t	_W0
_Eres	_Y0
_Eres	_Y1

Member Typedef Documentation

template<class _Engine, size_t _Wx, class _UIntType>

typedef _Engine::result_type independent_bits_engine< _Engine, _Wx, _UIntType >::_Eres

template<class _Engine, size_t _Wx, class _UIntType>

typedef independent_bits_engine<_Engine, _Wx, _UIntType> independent_bits_engine< _Engine, _Wx, _UIntType >::_Myt

template<class _Engine, size_t _Wx, class _UIntType>

typedef _Engine independent_bits_engine< _Engine, _Wx, _UIntType >::base_type

template<class _Engine, size_t _Wx, class _UIntType>

typedef _UIntType independent_bits_engine< _Engine, _Wx, _UIntType >::result_type

Constructor & Destructor Documentation

template<class _Engine, size_t _Wx, class _UIntType>

independent_bits_engine< _Engine, _Wx, _UIntType >::independent_bits_engine ( )

inline

        {   // construct
        _Init();
        }

template<class _Engine, size_t _Wx, class _UIntType>

independent_bits_engine< _Engine, _Wx, _UIntType >::independent_bits_engine ( const _Engine &  _Ex )

inlineexplicit

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

template<class _Engine, size_t _Wx, class _UIntType>

independent_bits_engine< _Engine, _Wx, _UIntType >::independent_bits_engine ( _Engine &&  _Ex )

inlineexplicit

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

template<class _Engine, size_t _Wx, class _UIntType>

independent_bits_engine< _Engine, _Wx, _UIntType >::independent_bits_engine ( result_type  _X0 )

inlineexplicit

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

template<class _Engine, size_t _Wx, class _UIntType>

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

independent_bits_engine< _Engine, _Wx, _UIntType >::independent_bits_engine ( _Seed_seq &  _Seq )

inlineexplicit

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

Member Function Documentation

template<class _Engine, size_t _Wx, class _UIntType>

void independent_bits_engine< _Engine, _Wx, _UIntType >::_Init ( )

inlineprivate

        {   // compute values for operator()
        size_t _Mx = 0;
        _Eres _Rx = (_Engine::max)() - (_Engine::min)() + 1;

        _Eres _Tmp = _Rx;
        if (_Tmp == 0)
            {   // all bits used, make _Rx finite
            _Mx = 1;
            --_Tmp;
            }
        for (; 1 < _Tmp; _Tmp >>= 1)
            ++_Mx;  // compute _Mx = floor(log2(_Rx))

        for (size_t _Nfix = 0; ; ++_Nfix)
            {   // compute consistent set of parameters
            _Nx = (_Wx + _Mx - 1) / _Mx + _Nfix;    // trial _Nx
            _W0 = _Wx / _Nx;
            _N0 = _Nx - _Wx % _Nx;
            _Y0 = (_Rx >> _W0) << _W0;
            _Y1 = (((_Rx >> _W0) >> 1) << _W0) << 1;
            if (_Nfix == 1 || _Rx - _Y0 <= _Y0 / _Nx)
                break;  // also works if _Rx == 0 (_Mx == all bits)
            }
        --_Y0;
        --_Y1;
        }

template<class _Engine, size_t _Wx, class _UIntType>

template<class _Elem , class _Traits >

basic_istream<_Elem, _Traits>& independent_bits_engine< _Engine, _Wx, _UIntType >::_Read ( basic_istream< _Elem, _Traits > &  _Istr )

inline

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

template<class _Engine, size_t _Wx, class _UIntType>

template<class _Elem , class _Traits >

basic_ostream<_Elem, _Traits>& independent_bits_engine< _Engine, _Wx, _UIntType >::_Write ( basic_ostream< _Elem, _Traits > &  _Ostr ) const

inline

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

template<class _Engine, size_t _Wx, class _UIntType>

const _Engine& independent_bits_engine< _Engine, _Wx, _UIntType >::base ( ) const

inline

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

template<class _Engine, size_t _Wx, class _UIntType>

void independent_bits_engine< _Engine, _Wx, _UIntType >::discard ( unsigned long long  _Nskip )

inline

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

template<class _Engine, size_t _Wx, class _UIntType>

static constexpr result_type() independent_bits_engine< _Engine, _Wx, _UIntType >::max ( )

inlinestatic

        {   // return maximum possible generated value
        return ((((result_type)1 << (_Wx - 1)) << 1) - 1);
        }

template<class _Engine, size_t _Wx, class _UIntType>

static constexpr result_type() independent_bits_engine< _Engine, _Wx, _UIntType >::min ( )

inlinestatic

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

template<class _Engine, size_t _Wx, class _UIntType>

result_type independent_bits_engine< _Engine, _Wx, _UIntType >::operator() ( )

inline

        {   // return next value
        size_t _Idx = 0;
        result_type _Res = 0;
        result_type _Mask = (((result_type)1 << (_W0 - 1)) << 1) - 1;
        _Eres _Val;

        for (; _Idx < _N0; ++_Idx)
            {   // pack _W0-bit values
            for (; ; )
                {   // get a small enough value
                _Val = _Eng() - (_Engine::min)();
                if (_Val <= _Y0)
                    break;
                }
            _Res = _Res << _W0 | static_cast<result_type>(_Val) & _Mask;
            }

        _Mask = _Mask << 1 | 1;
        for (; _Idx < _Nx; ++_Idx)
            {   // pack _W0+1-bit values
            for (; ; )
                {   // get a small enough value
                _Val = _Eng() - (_Engine::min)();
                if (_Val <= _Y1)
                    break;
                }
            _Res = (_Res << (_W0 + 1)) | static_cast<result_type>(_Val) & _Mask;
            }
        return (_Res);
        }

template<class _Engine, size_t _Wx, class _UIntType>

void independent_bits_engine< _Engine, _Wx, _UIntType >::seed ( )

inline

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

template<class _Engine, size_t _Wx, class _UIntType>

void independent_bits_engine< _Engine, _Wx, _UIntType >::seed ( result_type  _X0 )

inline

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

template<class _Engine, size_t _Wx, class _UIntType>

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

void independent_bits_engine< _Engine, _Wx, _UIntType >::seed ( _Seed_seq &  _Seq )

inline

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

Member Data Documentation

template<class _Engine, size_t _Wx, class _UIntType>

_Engine independent_bits_engine< _Engine, _Wx, _UIntType >::_Eng

private

template<class _Engine, size_t _Wx, class _UIntType>

size_t independent_bits_engine< _Engine, _Wx, _UIntType >::_N0

private

template<class _Engine, size_t _Wx, class _UIntType>

size_t independent_bits_engine< _Engine, _Wx, _UIntType >::_Nx

private

template<class _Engine, size_t _Wx, class _UIntType>

size_t independent_bits_engine< _Engine, _Wx, _UIntType >::_W0

private

template<class _Engine, size_t _Wx, class _UIntType>

_Eres independent_bits_engine< _Engine, _Wx, _UIntType >::_Y0

private

template<class _Engine, size_t _Wx, class _UIntType>

_Eres independent_bits_engine< _Engine, _Wx, _UIntType >::_Y1

private

---

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

• VS2015/inc/random