Merge branch 'main' of https://github.com/schmouk/CppRandLib

Author: schmouk

README.md

@@ -116,7 +116,7 @@ Notice: a comparison of the computation times for all implemented PRNGs in **Cpp
       <td>Cwg64</td>
       <td>*CWG64*</td>
       <td>8 x 4-bytes</td>
-      <td>&gt;= 2^70</td>
+      <td>&gt;= 2^64</td>
       <td>0</td>
       <td>0</td>
       <td>0</td>
@@ -127,7 +127,7 @@ Notice: a comparison of the computation times for all implemented PRNGs in **Cpp
       <td>Cwg128_64</td>
       <td>*CWG128-64*</td>
       <td>10 x 4-bytes</td>
-      <td>&gt;= 2^71</td>
+      <td>&gt;= 2^64</td>
       <td>0</td>
       <td>0</td>
       <td>0</td>
@@ -138,7 +138,7 @@ Notice: a comparison of the computation times for all implemented PRNGs in **Cpp
       <td>Cwg128</td>
       <td>*CWG128*</td>
       <td>16 x 4-bytes</td>
-      <td>&gt;= 2^135</td>
+      <td>&gt;= 2^128</td>
       <td>0</td>
       <td>0</td>
       <td>0</td>
@@ -845,9 +845,9 @@ Since version **2.0** of **CppRandLib** also, the newly implemented method `getr
 
 
 ---
-### Cwg64  --  minimum 2^70 period
+### Cwg64  --  minimum 2^64 period
 
-**Cwg64** implements the full 64 bits version of the Collatz-Weyl Generator algorithm: computations are done on 64-bits, the output generated value is coded on 64-bits also. It provides a medium period which is at minimum 2^70 (i.e. about 1.18e+21), short computation time and a four 64-bits integers internal state (x, a, weyl, s).
+**Cwg64** implements the full 64 bits version of the Collatz-Weyl Generator algorithm: computations are done on 64-bits, the output generated value is coded on 64-bits also. It provides a medium period which is at minimum 2^64 (i.e. about 1.84e+19), short computation time and a four 64-bits integers internal state (x, a, weyl, s).
 
 This version of the CGW algorithm evaluates pseudo-random suites *output(i)* as the combination of the next instructions applied to *state(i-1)*:
 
@@ -858,21 +858,9 @@ This version of the CGW algorithm evaluates pseudo-random suites *output(i)* as
 
 
 
-### Cwg64  --  minimum 2^70 period
+### Cwg128_64  --  minimum 2^64 period
 
-**Cwg64** implements the full 64 bits version of the Collatz-Weyl Generator algorithm: computations are done on 64-bits. The output generated value is coded on 64-bits also. It provides a medium period which is at minimum 2^70 (i.e. about 1.18e+21), short computation time and a four 64-bits integers internal state (x, a, weyl, s).
-
-This version of the CGW algorithm evaluates pseudo-random suites *output(i)* as the combination of the next instructions applied to *state(i-1)*:
-
-    a(i)      = a(i-1) + x(i-1)
-    weyl(i)   = weyl(i-1) + s  // s is constant over time and must be odd, this is the value to modify to get multi-streams
-    x(i)      = ((x(i-1) >> 1) * ((a(i)) | 1)) ^ (weyl(i)))
-    output(i) = (a(i) >> 48) ^ x(i)
-
-
-### Cwg128_64  --  minimum 2^71 period
-
-**Cwg128_64** implements the mixed 128/64 bits version of the Collatz-Weyl Generator algorithm: computations are done on 128- and 64- bits. The output generated value is coded on 64-bits also. It provides a medium period which is at minimum 2^71 (i.e. about 2.36e+21), short computation time and a three 64-bits (a, weyl, s) plus one 128-bits integer internal state (x). 
+**Cwg128_64** implements the mixed 128/64 bits version of the Collatz-Weyl Generator algorithm: computations are done on 128- and 64- bits. The output generated value is coded on 64-bits also. It provides a medium period which is at minimum 2^64 (i.e. about 1.84e+19), short computation time and a three 64-bits (a, weyl, s) plus one 128-bits integer internal state (x). 
 
 This version of the CGW algorithm evaluates pseudo-random suites *output(i)* as the combination of the next instructions applied to *state(i-1)*:
 
@@ -883,9 +871,9 @@ This version of the CGW algorithm evaluates pseudo-random suites *output(i)* as
 
 
 
-### Cwg128  --  minimum 2^135 period
+### Cwg128  --  minimum 2^128 period
 
-**Cwg128** implements the full 128 bits version of the Collatz-Weyl Generator algorithm: computations are done on 128-bits. The output generated value is coded on 128-bits also. It provides a medium period which is at minimum 2^135 (i.e. about 4.36e+40), short computation time and a four 128-bits integers internal state (x, a, weyl, s).
+**Cwg128** implements the full 128 bits version of the Collatz-Weyl Generator algorithm: computations are done on 128-bits. The output generated value is coded on 128-bits also. It provides a medium period which is at minimum 2^128 (i.e. about 6.81e+38), short computation time and a four 128-bits integers internal state (x, a, weyl, s).
 
 This version of the CGW algorithm evaluates pseudo-random suites *output(i)* as the combination of the next instructions applied to *state(i-1)*:
 

c++11/baseclasses/basecwg.h

@@ -73,15 +73,15 @@ SOFTWARE.
 *   implemented  version.  See  implementation  classes  to  get  their formal
 *   description.
 *
-*   See Cwg64 for a minimum  2^70  (i.e. about 1.18e+21)  period  CW-Generator
+*   See Cwg64 for a minimum  2^64  (i.e. about 1.84e+19)  period  CW-Generator
 *   with low computation time, medium period,  64- bits output values and very
 *   good randomness characteristics.
 * 
-*   See Cwg128_64 for a minimum 2^71 (i.e. about 2.36e+21) period CW-Generator
+*   See Cwg128_64 for a minimum 2^64 (i.e. about 1.84e+19) period CW-Generator
 *   with very low computation time,  medium period,  64-bits output values and
 *   very good randomness characteristics.
 * 
-*   See Cwg128 for a minimum 2^135 (i.e. about 4.36e+40)  period  CW-generator
+*   See Cwg128 for a minimum 2^128 (i.e. about 6.81e+38)  period  CW-generator
 *   with very low computation time, medium period,  128-bits output values and
 *   very good randomness characteristics.
 *
@@ -107,9 +107,9 @@ SOFTWARE.
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 * | CppRandLib class | [8] generator name | Memory Usage | Period   | time-32bits | time-64 bits | SmallCrush fails | Crush fails | BigCrush fails |
 * | ---------------- | ------------------ | ------------ | -------- | ----------- | ------------ | ---------------- | ----------- | -------------- |
-* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^70  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^71  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^135 |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^128 |    n.a.     |     n.a.     |         0        |      0      |       0        |
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 *
 *   * _small crush_ is a small set of simple tests that quickly tests some  of

c++11/baseclasses/baserandom.h

@@ -52,13 +52,13 @@ SOFTWARE.
 //===========================================================================
 /** @brief This is the base class for all pseudo-random numbers generators.
 *
-*   See Cwg64 for a minimum 2^70 (i.e. about 1.18e+21) period  Collatz-Weyl  Generator
+*   See Cwg64 for a minimum 2^64 (i.e. about 1.84e+19) period  Collatz-Weyl  Generator
 *   with  low  computation time,  medium period,  64- bits output values and very good
 *   randomness characteristics.
-*   See Cwg128_64 for a minimum 2^71 (i.e. about 2.36e+21) period C-W  Generator  with
+*   See Cwg128_64 for a minimum 2^64 (i.e. about 1.84e+19) period C-W  Generator  with
 *   with  very  low  computation time,  medium period,  64-bits output values and very
 *   good randomness characteristics.
-*   See Cwg128 for a minimum 2^135  (i.e. about 4.36e+40)  period  C-W generator  with
+*   See Cwg128 for a minimum 2^128  (i.e. about 6.81e+38)  period  C-W generator  with
 *   very  low  computation time,  medium period,  64- bits output values and very good
 *   randomness characteristics.
 *

c++11/cwg128.h

@@ -40,11 +40,11 @@ SOFTWARE.
 
 
 //===========================================================================
-/** @brief A 128-bits Collatz-Weyl pseudorandom Generator with a short period (4.36e+40).
+/** @brief A 128-bits Collatz-Weyl pseudorandom Generator with a short period (6.81e+38).
 *
 *   Pseudo-random numbers generator  -  Collatz-Weyl  pseudorandom  Generators
 *   dedicated  to  128-bits calculations and 128-bits output values with large
-*   period (min 2^135, i.e. 4.36e+40) but  short  computation  time.  All  CWG
+*   period (min 2^128, i.e. 6.81e+38) but  short  computation  time.  All  CWG
 *   algorithms offer multi streams features, by simply using different initial
 *   settings for control value 's' - see below.
 *
@@ -59,11 +59,11 @@ SOFTWARE.
 *   PRNG.  's' must be initally odd.  'a', 'weyl' and initial state 'x' may be
 *   initialized each with any 64-bits value.
 *
-*   See Cwg64 for a minimum  2^70  (i.e. about 1.18e+21)  period  CW-Generator
+*   See Cwg64 for a minimum  2^64  (i.e. about 1.84e+19)  period  CW-Generator
 *   with very low computation time, medium period,  64- bits output values and
 *   very good randomness characteristics.
 *
-*   See Cwg128_64 for a minimum 2^71 (i.e. about 2.36e+21) period CW-Generator
+*   See Cwg128_64 for a minimum 2^64 (i.e. about 1.84e+19) period CW-Generator
 *   with very low computation time,  medium period,  64-bits output values and
 *   very good randomness characteristics.
 *
@@ -89,9 +89,9 @@ SOFTWARE.
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 * | CppRandLib class | [8] generator name | Memory Usage | Period   | time-32bits | time-64 bits | SmallCrush fails | Crush fails | BigCrush fails |
 * | ---------------- | ------------------ | ------------ | -------- | ----------- | ------------ | ---------------- | ----------- | -------------- |
-* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^70  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^71  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^135 |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^128 |    n.a.     |     n.a.     |         0        |      0      |       0        |
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 *
 *   * _small crush_ is a small set of simple tests that quickly tests some  of

c++11/cwg128_64.cpp

@@ -99,7 +99,7 @@ const Cwg128_64::output_type Cwg128_64::next() noexcept
     _internal_state.state.state = ((_internal_state.state.state | 1) * (_internal_state.state.a >> 1)) ^ _internal_state.state.weyl;
 
     // returns the xored - shifted output value
-    return (_internal_state.state.state ^ (_internal_state.state.a >> 48)).lo;
+    return _internal_state.state.state ^ (_internal_state.state.a >> 48);
 }
 
 //---------------------------------------------------------------------------

c++11/cwg128_64.h

@@ -40,11 +40,11 @@ SOFTWARE.
 
 
 //===========================================================================
-/** @brief A 128-/64- bits Collatz-Weyl pseudorandom Generator with a short period (1.18e+21).
+/** @brief A 128-/64- bits Collatz-Weyl pseudorandom Generator with a short period (1.84e+19).
 *
 *   Pseudo-random numbers  generator  -  Collatz-Weyl  pseudorandom  Generator
 *   dedicated  to  128-bits  calculations and 64-bits output values with small
-*   period (min 2^71, i.e. 2.36e+21)  but  short  computation  time.  All  CWG
+*   period (min 2^64, i.e. 1.84e+19)  but  short  computation  time.  All  CWG
 *   algorithms offer multi streams features, by simply using different initial
 *   settings for control value 's' - see below.
 *
@@ -59,11 +59,11 @@ SOFTWARE.
 *   PRNG.  's' must be initally odd.  'a', 'weyl' and initial state 'x' may be
 *   initialized each with any 64-bits value.
 *
-*   See Cwg64 for a minimum  2^70  (i.e. about 1.18e+21)  period  CW-Generator
+*   See Cwg64 for a minimum  2^64  (i.e. about 1.84e+19)  period  CW-Generator
 *   with very low computation time, medium period,  64- bits output values and
 *   very good randomness characteristics.
 *
-*   See Cwg128_64 for a minimum 2^135 (i.e. about 4.36e+40)  period  CW-generator
+*   See Cwg128_64 for a minimum 2^128 (i.e. about 6.81e+38)  period  CW-generator
 *   with very low computation time, medium period,  128-bits output values and
 *   very good randomness characteristics.
 *
@@ -89,9 +89,9 @@ SOFTWARE.
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 * | CppRandLib class | [8] generator name | Memory Usage | Period   | time-32bits | time-64 bits | SmallCrush fails | Crush fails | BigCrush fails |
 * | ---------------- | ------------------ | ------------ | -------- | ----------- | ------------ | ---------------- | ----------- | -------------- |
-* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^70  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^71  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^135 |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^128 |    n.a.     |     n.a.     |         0        |      0      |       0        |
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 *
 *   * _small crush_ is a small set of simple tests that quickly tests some  of
@@ -103,11 +103,11 @@ SOFTWARE.
 *   * _big crush_ is the ultimate set of difficult tests that  any  GOOD  PRNG
 *   should definitively pass.
 */
-class Cwg128_64 : public BaseCWG<std::uint64_t, utils::UInt128, std::uint64_t, 64>
+class Cwg128_64 : public BaseCWG<std::uint64_t, utils::UInt128, utils::UInt128, 128>
 {
 public:
     //---   Wrappers   ------------------------------------------------------
-    using MyBaseClass = BaseCWG<std::uint64_t, utils::UInt128, std::uint64_t, 64>;
+    using MyBaseClass = BaseCWG<std::uint64_t, utils::UInt128, utils::UInt128, 128>;
 
     using output_type = typename MyBaseClass::output_type;
     using state_type  = typename MyBaseClass::state_type;

c++11/cwg64.h

@@ -40,11 +40,11 @@ SOFTWARE.
 
 
 //===========================================================================
-/** @brief A 64-bits Collatz-Weyl pseudorandom Generator with a long period (1.18e+21).
+/** @brief A 64-bits Collatz-Weyl pseudorandom Generator with a long period (1.84e+19).
 *
 *   Pseudo-random numbers  generator  -  Collatz-Weyl  pseudorandom  Generator
 *   dedicated  to  64-bits  calculations  and 64-bits output values with small
-*   period (min 2^70, i.e. 1.18e+21)  but  short  computation  time.  All  CWG
+*   period (min 2^64, i.e. 1.84e+19)  but  short  computation  time.  All  CWG
 *   algorithms offer multi streams features, by simply using different initial
 *   settings for control value 's' - see below.
 *
@@ -59,11 +59,11 @@ SOFTWARE.
 *   PRNG.  's' must be initally odd.  'a', 'weyl' and initial state 'x' may be
 *   initialized each with any 64-bits value.
 *
-*   See Cwg128_64 for a minimum 2^71 (i.e. about 2.36e+21) period CW-Generator
+*   See Cwg128_64 for a minimum 2^64 (i.e. about 1.84e+19) period CW-Generator
 *   with very low computation time,  medium period,  64-bits output values and
 *   very good randomness characteristics.
 *
-*   See Cwg128 for a minimum 2^135 (i.e. about 4.36e+40)  period  CW-generator
+*   See Cwg128 for a minimum 2^128 (i.e. about 6.81e+38)  period  CW-generator
 *   with very low computation time, medium period,  128-bits output values and
 *   very good randomness characteristics.
 *
@@ -89,9 +89,9 @@ SOFTWARE.
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 * | CppRandLib class | [8] generator name | Memory Usage | Period   | time-32bits | time-64 bits | SmallCrush fails | Crush fails | BigCrush fails |
 * | ---------------- | ------------------ | ------------ | -------- | ----------- | ------------ | ---------------- | ----------- | -------------- |
-* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^70  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^71  |    n.a.     |     n.a.     |         0        |      0      |       0        |
-* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^135 |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg64            | CWG64              |  8 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128_64        | CWG128_64          | 10 x 4-bytes | >= 2^64  |    n.a.     |     n.a.     |         0        |      0      |       0        |
+* | Cwg128           | CWG128             | 16 x 4-bytes | >= 2^128 |    n.a.     |     n.a.     |         0        |      0      |       0        |
 * +------------------------------------------------------------------------------------------------------------------------------------------------+
 *
 *   * _small crush_ is a small set of simple tests that quickly tests some  of