Changes in libcfa/src/bits/random.hfa [90fb672:12b006c]

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 21:45:24 2023
-// Update Count     : 186
+// Last Modified On : Mon Mar 20 10:01:40 2023
+// Update Count     : 180
 // 
 
@@ -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 (see https://prng.di.unimi.it).
-// Also 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.                              
 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 (see https://prng.di.unimi.it).
-
+// 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
 static inline uint32_t splitmix32( uint32_t & state ) {
     state += 0x9e3779b9;
@@ -168 +169 @@
 
 #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 = 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
+        //--------------------------------------------------
+        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
 #endif // __SIZEOF_INT128__
 
@@ -229 +227 @@
 
 static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state, uint64_t seed ) {
-    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
-    uint64_t seed1 = splitmix64( seed );                                // prime
+    // 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 );
     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
 
@@ -268 +269 @@
 
 static inline void xoshiro128pp_set_seed( xoshiro128pp_t & state, uint32_t seed ) {
-    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
-    uint32_t seed1 = splitmix32( seed );                                // prime
+    // 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 );
     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
 
@@ -286 +290 @@
 
 static inline void xorshift_13_7_17_set_seed( uint64_t & state, uint64_t seed ) {
-        state = splitmix64( seed );                                                     // prime
+        state = seed;
+        xorshift_13_7_17( state );                                                      // prime
 } // xorshift_13_7_17_set_seed
 
@@ -303 +308 @@
 
 static inline void xorshift_6_21_7_set_seed( uint32_t & state, uint32_t seed ) {
-    state = splitmix32( seed );                                                 // prime
+        state = seed;
+        xorshift_6_21_7( state );                                                       // prime
 } // xorshift_6_21_7_set_seed
 
@@ -317 +323 @@
 
 static inline void xorshift_12_25_27_set_seed( uint64_t & state, uint64_t seed ) {
-        state = splitmix64( seed );                                                     // prime
+        state = seed;
+        xorshift_12_25_27( state );                                                     // prime
 } // xorshift_12_25_27_set_seed
 
@@ -338 +345 @@
 
 static inline void kiss_64_set_seed( kiss_64_t & rs, uint64_t seed ) with(rs) {
-        z = 1; w = 1; jsr = 4; jcong = splitmix64( seed );      // prime
+        z = 1; w = 1; jsr = 4; jcong = seed;
+        kiss_64( rs );                                                                          // prime
 } // kiss_64_set_seed
 
@@ -366 +374 @@
 
 static inline void xorwow_set_seed( xorwow_t & rs, uint32_t seed ) {
-    // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
-    uint32_t seed1 = splitmix32( seed );                                // prime
+    // 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 );
     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
 
@@ -377 +388 @@
 // Used in __tls_rand_fwd
 #define M  (1_l64u << 48_l64u)
-#define A  (25_214_903_917_l64u)
-#define AI (18_446_708_753_438_544_741_l64u)
+#define A  (25214903917_l64u)
+#define AI (18446708753438544741_l64u)
 #define C  (11_l64u)
 #define D  (16_l64u)