mersenne_twister_engine Class

Artikel
02/26/2013

Generiert eine zufällige Sequenz durch den Mersenne-Twisteralgorithmus.

template<class UIntType,
   size_t W, size_t N, size_t M, size_t R,
   UIntType A, size_t U,
   UIntType D, size_t S,
   UIntType B, size_t T,
   UIntType C, size_t L
   UIntType F>
class mersenne_twister_engine {
public:
   typedef UIntType result_type;
   static const size_t word_size = W;
   static const size_t state_size = N;
   static const size_t shift_size = M;
   static const size_t mask_bits = R;
   static const UIntType xor_mask = A;
   static const size_t tempering_u = U;
   static const size_t tempering_d = D;
   static const size_t tempering_s = S;
   static const UIntType tempering_b = B;
   static const size_t tempering_t = T;
   static const UIntType tempering_c = C;
   static const size_t tempering_l = L;
   static const UIntType initialization_multiplier = C;
   static const result_type default_seed = 5489U;
   explicit mersenne_twister_engine(unsigned long x0 = default_seed);
   explicit mersenne_twister_engine(seed_seq& seq);
   void seed(unsigned long x0 = default_seed);
   template<class Gen>
      void seed(seed_seq& seq);
   result_type min() const;
   result_type max() const;
   result_type operator()();
   void discard(unsigned long long count)();
   };

Parameter

UIntType
Der vorzeichenlose Ergebnistyp ganze Zahl.
W
Der W-Modulparameter.
N
Der N-Modulparameter.
M
Der M-Modulparameter.
R
Der R-Modulparameter.
A
Der a-Modulparameter.
U
Der U-Modulparameter.
D
Der D-Modulparameter.
S
Der S-Modulparameter.
B
Der B-Modulparameter.
T
Der T-Modulparameter.
C
Der C-Modulparameter.
L
Der L-Modulparameter.
F
Der F-Modulparameter.

Hinweise

Diese Vorlagenklasse beschreibt <random>.Sie enthält einen großen ganzzahliger Wert mit W * (N - 1) + R Bits an.Sie extrahiert W Bits gleichzeitig von diesem hohen Wert und wenn sie alle Bits verwendet wurde, es verzerrt großen Wert, indem sie die Bits verschieben und kombinieren, damit sie einen neuen Satz von hat zu extrahieren Bits.Der Zustand des Moduls ist die letzte NW- Bitwerte verwendet, wenn operator() mindestens N Zeiten aufgerufen wurde; andernfalls MW- Bitwerte, die verwendet wurden und die letzten N - M-Werte des Startwerts.

Das Vorlagenargument UIntType muss groß genug sein, Werte bis zu 2W - 1 aufzunehmen.Die Werte der anderen Vorlagenargumente müssen die folgenden Anforderungen erfüllen:

1 < M <= N

0 <= R, U, S, T, L <= W

0 <= A, B, C <= 2W - 1

W * (N - 1) + R muss eine Mersenne-höchsteVollkommenheit sein

Der Generator verzerrt großen Wert, den er enthält, indem Sie den folgenden Code ausführt:

    for (size_t i = 0; i < N; ++i)
        {    // twist
        temp = (x[i] & LMASK) << (W - 1) | (x[i + 1] & HMASK) >> 1;
        if (temp & 1)
            y[i] = (temp >> 1) ^ A ^ x[(i + R) % N];
        else
            y[i] = (temp >> 1) ^ x[(i + R) % N];
        }
        for (size_t i = 0; i < N; ++i)
            x[i] = y[i];

wobei LMASKW ohne Vorzeichen ist - Bitwert mit den grundlegenden R Bits, die auf 1 festgelegt sind und dem Rest der Bits, die auf 0 festgelegt werden, und HMASK ist die Ergänzen von LMASK.

Der Generator enthält einen aktuellen Index idx initialisiert bis 0 an.Er extrahiert Bits, indem er den folgenden Code ausführt:

    temp = x[idx++];
    temp = temp ^ ((temp >> U) & D);
    temp = temp ^ ((temp << S) & B);
    temp = temp ^ ((temp << T) & C);
    temp = temp ^ (temp >> L);

Wenn idxN erreicht, verzerrt der Generator den gespeicherten Wert und legt idx zurück auf 0 fest.