Changeset 90fb672 for libcfa/src

Timestamp:

Mar 21, 2023, 7:44:45 AM (15 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

1205b3e

Parents:

12b006c

Message:

use splitmix32/64 to prime set seed for all PRNG

File:

• libcfa/src/bits/random.hfa (modified) (12 diffs)

libcfa/src/bits/random.hfa

@@ -10 +10 @@
 // Created On       : Fri Jan 14 07:18:11 2022
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 20 10:01:40 2023
-// Update Count     : 180
+// Last Modified On : Mon Mar 20 21:45:24 2023
+// Update Count     : 186
 // 
 
@@ -131 +131 @@
 #ifdef __cforall                                                                                // don't include in C code (invoke.h)
 
-// Splitmix64
 // https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64
-// Splitmix64 is not recommended for demanding random number requirements,
-// but is often used to calculate initial states for other more complex
-// pseudo-random number generators.                              
+//
+// Splitmix64 is not recommended for demanding random number requirements, but is often used to calculate initial states
+// for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
+// Also https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64.
 static inline uint64_t splitmix64( uint64_t & state ) {
     state += 0x9e3779b97f4a7c15;
@@ -149 +149 @@
 } // splitmix64_set_seed
 
-// Splitmix32
 // https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
-// Splitmix32 is not recommended for demanding random number requirements,
-// but is often used to calculate initial states for other more complex
-// pseudo-random number generators.
-// SplitMix32 is a 32 bit variant of Splitmix64
+//
+// Splitmix32 is not recommended for demanding random number requirements, but is often used to calculate initial states
+// for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
+
 static inline uint32_t splitmix32( uint32_t & state ) {
     state += 0x9e3779b9;
@@ -169 +168 @@
 
 #ifdef __SIZEOF_INT128__
-        //--------------------------------------------------
-        static inline uint64_t lehmer64( __uint128_t & state ) {
-                __uint128_t ret = state;
-                state *= 0x_da94_2042_e4dd_58b5;
-                return ret >> 64;
-        } // lehmer64
-
-        static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
-                // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
-                state = seed;
-                lehmer64( state );                                                              // prime
-        } // lehmer64_set_seed
-
-        //--------------------------------------------------
-        static inline uint64_t wyhash64( uint64_t & state ) {
-                uint64_t ret = state;
-                state += 0x_60be_e2be_e120_fc15;
-                __uint128_t tmp;
-                tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
-                uint64_t m1 = (tmp >> 64) ^ tmp;
-                tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
-                uint64_t m2 = (tmp >> 64) ^ tmp;
-                return m2;
-        } // wyhash64
+//--------------------------------------------------
+static inline uint64_t lehmer64( __uint128_t & state ) {
+        __uint128_t ret = state;
+        state *= 0x_da94_2042_e4dd_58b5;
+        return ret >> 64;
+} // lehmer64
+
+static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
+        // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
+        state = splitmix64( seed );                                                     // prime
+} // lehmer64_set_seed
+
+//--------------------------------------------------
+static inline uint64_t wyhash64( uint64_t & state ) {
+        uint64_t ret = state;
+        state += 0x_60be_e2be_e120_fc15;
+        __uint128_t tmp;
+        tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
+        uint64_t m1 = (tmp >> 64) ^ tmp;
+        tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
+        uint64_t m2 = (tmp >> 64) ^ tmp;
+        return m2;
+} // wyhash64
+
+static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) {
+        state = splitmix64( seed );                                                     // prime
+} // wyhash64_set_seed
 #endif // __SIZEOF_INT128__
 
@@ -227 +229 @@
 
 static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state, uint64_t seed ) {
-    // these are done explicitly in this order to attain repeatable seeding.
-    // do not call splitmix64 directly in the state init since order of argument evaluation
-    // may not be consistent leading to irreproducible seeding
-    uint64_t seed1 = splitmix64( seed );
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint64_t seed1 = splitmix64( seed );                                // prime
     uint64_t seed2 = splitmix64( seed );
     uint64_t seed3 = splitmix64( seed );
     uint64_t seed4 = splitmix64( seed );
         state = (xoshiro256pp_t){ seed1, seed2, seed3, seed4 };
-        xoshiro256pp( state );                                                          // prime
 } // xoshiro256pp_set_seed
 
@@ -269 +268 @@
 
 static inline void xoshiro128pp_set_seed( xoshiro128pp_t & state, uint32_t seed ) {
-    // these are done explicitly in this order to attain repeatable seeding.
-    // do not call splitmix32 directly in the state init since order of argument evaluation
-    // may not be consistent leading to irreproducible seeding
-    uint32_t seed1 = splitmix32( seed );
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint32_t seed1 = splitmix32( seed );                                // prime
     uint32_t seed2 = splitmix32( seed );
     uint32_t seed3 = splitmix32( seed );
     uint32_t seed4 = splitmix32( seed );
         state = (xoshiro128pp_t){ seed1, seed2, seed3, seed4 };
-        xoshiro128pp( state );                                                          // prime
 } // xoshiro128pp_set_seed
 
@@ -290 +286 @@
 
 static inline void xorshift_13_7_17_set_seed( uint64_t & state, uint64_t seed ) {
-        state = seed;
-        xorshift_13_7_17( state );                                                      // prime
+        state = splitmix64( seed );                                                     // prime
 } // xorshift_13_7_17_set_seed
 
@@ -308 +303 @@
 
 static inline void xorshift_6_21_7_set_seed( uint32_t & state, uint32_t seed ) {
-        state = seed;
-        xorshift_6_21_7( state );                                                       // prime
+    state = splitmix32( seed );                                                 // prime
 } // xorshift_6_21_7_set_seed
 
@@ -323 +317 @@
 
 static inline void xorshift_12_25_27_set_seed( uint64_t & state, uint64_t seed ) {
-        state = seed;
-        xorshift_12_25_27( state );                                                     // prime
+        state = splitmix64( seed );                                                     // prime
 } // xorshift_12_25_27_set_seed
 
@@ -345 +338 @@
 
 static inline void kiss_64_set_seed( kiss_64_t & rs, uint64_t seed ) with(rs) {
-        z = 1; w = 1; jsr = 4; jcong = seed;
-        kiss_64( rs );                                                                          // prime
+        z = 1; w = 1; jsr = 4; jcong = splitmix64( seed );      // prime
 } // kiss_64_set_seed
 
@@ -374 +366 @@
 
 static inline void xorwow_set_seed( xorwow_t & rs, uint32_t seed ) {
-    // these are done explicitly in this order to attain repeatable seeding.
-    // do not call splitmix32 directly in the state init since order of argument evaluation
-    // may not be consistent leading to irreproducible seeding
-    uint32_t seed1 = splitmix32( seed );
+    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
+    uint32_t seed1 = splitmix32( seed );                                // prime
     uint32_t seed2 = splitmix32( seed );
     uint32_t seed3 = splitmix32( seed );
     uint32_t seed4 = splitmix32( seed );
         rs = (xorwow_t){ seed1, seed2, seed3, seed4, 0 };
-        xorwow( rs );                                                                           // prime
 } // xorwow_set_seed
 
@@ -388 +377 @@
 // Used in __tls_rand_fwd
 #define M  (1_l64u << 48_l64u)
-#define A  (25214903917_l64u)
-#define AI (18446708753438544741_l64u)
+#define A  (25_214_903_917_l64u)
+#define AI (18_446_708_753_438_544_741_l64u)
 #define C  (11_l64u)
 #define D  (16_l64u)