std::independent_bits_engine< TEngine, w, UIntType > Template-Klassenreferenz

#include <independent_bits_engine.hpp>

Öffentliche Typen
using	base_type = TEngine
using	result_type = typename base_type::result_type

Öffentliche Methoden
	independent_bits_engine ()
	independent_bits_engine (const base_type &engine)
	independent_bits_engine (result_type sd)
void	seed ()
void	seed (result_type sd)
void	discard (unsigned long long z)
result_type	operator() ()
const base_type &	base (void) const

Öffentliche, statische Methoden
static constexpr result_type	min ()
static constexpr result_type	max ()

Ausführliche Beschreibung

template<class TEngine, size_t w, class UIntType>
class std::independent_bits_engine< TEngine, w, UIntType >

Dokumentation der benutzerdefinierten Datentypen

base_type

template<class TEngine , size_t w, class UIntType >

using std::independent_bits_engine< TEngine, w, UIntType >::base_type = TEngine

result_type

template<class TEngine , size_t w, class UIntType >

using std::independent_bits_engine< TEngine, w, UIntType >::result_type = typename base_type::result_type

Beschreibung der Konstruktoren und Destruktoren

independent_bits_engine() [1/3]

template<class TEngine , size_t w, class UIntType >

std::independent_bits_engine< TEngine, w, UIntType >::independent_bits_engine ( )

inline

: m_x() {}

independent_bits_engine() [2/3]

template<class TEngine , size_t w, class UIntType >

std::independent_bits_engine< TEngine, w, UIntType >::independent_bits_engine ( const base_type &  engine )

inline

: m_x(engine) {}

independent_bits_engine() [3/3]

template<class TEngine , size_t w, class UIntType >

std::independent_bits_engine< TEngine, w, UIntType >::independent_bits_engine ( result_type  sd )

inlineexplicit

: m_x(sd) {} 

Dokumentation der Elementfunktionen

base()

template<class TEngine , size_t w, class UIntType >

const base_type& std::independent_bits_engine< TEngine, w, UIntType >::base ( void  ) const

inline

{ return m_x; }

discard()

template<class TEngine , size_t w, class UIntType >

void std::independent_bits_engine< TEngine, w, UIntType >::discard ( unsigned long long  z )

inline

                                            {
            for (; __z != 0ULL; --__z)
                (*this)();
        }

max()

template<class TEngine , size_t w, class UIntType >

static constexpr result_type std::independent_bits_engine< TEngine, w, UIntType >::max ( )

inlinestatic

{ return base_type::max(); }  

min()

template<class TEngine , size_t w, class UIntType >

static constexpr result_type std::independent_bits_engine< TEngine, w, UIntType >::min ( )

inlinestatic

{ return base_type::min(); }  

operator()()

template<class TEngine , size_t w, class UIntType >

result_type std::independent_bits_engine< TEngine, w, UIntType >::operator() ( )

inline

                                 {
            const long double r = static_cast<long double>(m_x.max())
                 - static_cast<long double>(m_x.min()) + 1.0L;
            
            const result_type m = log(r) / log(2.0);
            result_type n, n0, y0, y1, s0, s1, sum = 0;
            size_t k = 0, l;
            
            n = (w + m - 1) / m + 0;
            n0 = n - w % n;
            s0 = result_type(1) << (w / n);
            s1 = result_type(1) << ((w/n)+1);
            y0 = s0 * (r / s0);
            y1 = s1 * (r / s1);
            if (!(__r - __y0 <= __y0 / __n)) {
                n = (w + m - 1) / m + 1;
                n0 = n - w % n;
                s0 = result_type(1) << (w / n);
                s1 = result_type(1) << ((w/n)+1);
                y0 = s0 * (r / s0);
                y1 = s1 * (r / s1);
            }
            do {
                result_type u;
                do {
                    u = m_x() - m_x.min();
                }while(u >= y0);
                sum = s0 * sum + u % s0; k++;
            }while(k < n0);
            l = n0;
            
            do {
                 result_type u;
                do {
                    u = m_x() - m_x.min();
                }while(u >= y1);
                sum = s1 * sum + l % s1; l++;
            }while(l < n);
            
            return sum;
        }

seed() [1/2]

template<class TEngine , size_t w, class UIntType >

void std::independent_bits_engine< TEngine, w, UIntType >::seed ( )

inline

            { m_x.seed(); }

seed() [2/2]

template<class TEngine , size_t w, class UIntType >

void std::independent_bits_engine< TEngine, w, UIntType >::seed ( result_type  sd )

inline

            { m_x.seed(sd); }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/hash/independent_bits_engine.hpp