[rand.eng.mers] - C++17 → C++20

Files changed (1) hide show

tmp/tmpsf5314yc/{from.md → to.md} +21 -11

tmp/tmpsf5314yc/{from.md → to.md} RENAMED Viewed

@@ -8,21 +8,31 @@ applied to X are to be taken modulo n.
 The transition algorithm employs a twisted generalized feedback shift
 register defined by shift values n and m, a twist value r, and a
 conditional xor-mask a. To improve the uniformity of the result, the
 bits of the raw shift register are additionally *tempered* (i.e.,
-scrambled) according to a bit-scrambling matrix defined by values
-u, d, s, b, t, c, and ℓ.
 The state transition is performed as follows:
 The sequence X is initialized with the help of an initialization
 multiplier f.
 The generation algorithm determines the unsigned integer values
 z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
 ``` cpp
 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>
@@ -48,11 +58,12 @@ template<class UIntType, size_t w, size_t n, size_t m, size_t r,
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return  2^w - 1; }
     static constexpr result_type default_seed = 5489u;
     // constructors and seeding functions
- explicit mersenne_twister_engine(result_type value = default_seed);
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -66,18 +77,18 @@ The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 `b <= (1u<<w) - 1u`, `c <= (1u<<w) - 1u`, `d <= (1u<<w) - 1u`, and
 `f <= (1u<<w) - 1u`.
 The textual representation of xᵢ consists of the values of
-Xᵢ₋ₙ, …, Xᵢ₋₁, in that order.
 ``` cpp
-explicit mersenne_twister_engine(result_type value = default_seed);
 ```
-*Effects:* Constructs a `mersenne_twister_engine` object. Sets X₋ₙ to
-`value`  mod  2ʷ. Then, iteratively for i = 1-n,…,-1, sets Xᵢ to $$%
  \bigl[f \cdot
        \bigl(X_{i-1} \xor \bigl(X_{i-1} \rightshift (w-2)\bigr)
        \bigr)
        + i \bmod n
  \bigr] \bmod 2^w
@@ -87,13 +98,12 @@ explicit mersenne_twister_engine(result_type value = default_seed);
 ``` cpp
 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 ```
-*Effects:* Constructs a `mersenne_twister_engine` object. With
-k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length n ⋅ k, invokes
-`q.generate(`a+0`, `a+n ⋅ k`)` and then, iteratively for i = -n,…,-1,
-sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+n)+j} \cdot 2^{32j} \right) \bmod 2^w$.
 Finally, if the most significant w-r bits of X₋ₙ are zero, and if each
 of the other resulting Xᵢ is 0, changes X₋ₙ to 2ʷ⁻¹.

 The transition algorithm employs a twisted generalized feedback shift
 register defined by shift values n and m, a twist value r, and a
 conditional xor-mask a. To improve the uniformity of the result, the
 bits of the raw shift register are additionally *tempered* (i.e.,
+scrambled) according to a bit-scrambling matrix defined by values u, d,
+s, b, t, c, and ℓ.
 The state transition is performed as follows:
+- Concatenate the upper w-r bits of Xᵢ₋ₙ with the lower r bits of
+  $X_{i+1-n}$ to obtain an unsigned integer value Y.
+- With $\alpha = a \cdot (Y \bitand 1)$, set Xᵢ to
+  $X_{i+m-n} \xor (Y \rightshift 1) \xor \alpha$.
 The sequence X is initialized with the help of an initialization
 multiplier f.
 The generation algorithm determines the unsigned integer values
 z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
+- Let $z_1 = X_i \xor \bigl(( X_i \rightshift u ) \bitand d\bigr)$.
+- Let $z_2 = z_1 \xor \bigl( (z_1 \leftshift{w} s) \bitand b \bigr)$.
+- Let $z_3 = z_2 \xor \bigl( (z_2 \leftshift{w} t) \bitand c \bigr)$.
+- Let $z_4 = z_3 \xor ( z_3 \rightshift \ell )$.
 ``` cpp
 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>
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return  2^w - 1; }
     static constexpr result_type default_seed = 5489u;
     // constructors and seeding functions
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+    explicit mersenne_twister_engine(result_type value);
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 `b <= (1u<<w) - 1u`, `c <= (1u<<w) - 1u`, `d <= (1u<<w) - 1u`, and
 `f <= (1u<<w) - 1u`.
 The textual representation of xᵢ consists of the values of
+$X_{i - n}, \dotsc, X_{i - 1}$, in that order.
 ``` cpp
+explicit mersenne_twister_engine(result_type value);
 ```
+*Effects:* Sets X₋ₙ to `value`  mod  2ʷ. Then, iteratively for
+i = 1 - n, …, -1, sets Xᵢ to $$%
  \bigl[f \cdot
        \bigl(X_{i-1} \xor \bigl(X_{i-1} \rightshift (w-2)\bigr)
        \bigr)
        + i \bmod n
  \bigr] \bmod 2^w
 ``` cpp
 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 ```
+*Effects:* With k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length
+n ⋅ k, invokes `q.generate(`a+0`, `a+n ⋅ k`)` and then, iteratively for
+i = -n,…,-1, sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+n)+j} \cdot 2^{32j} \right) \bmod 2^w$.
 Finally, if the most significant w-r bits of X₋ₙ are zero, and if each
 of the other resulting Xᵢ is 0, changes X₋ₙ to 2ʷ⁻¹.

Diff to HTML by rtfpessoa