random

CMakeLists.txt

@@ -42,6 +42,6 @@ find_package(glfw3)
 add_subdirectory(colormap)
 
 add_executable(cloudlife)
-target_sources(cloudlife PUBLIC main.cpp imgui_elements.cpp)
+target_sources(cloudlife PUBLIC main.cpp imgui_elements.cpp random.c)
 target_link_libraries(cloudlife IMGUI glfw GL colormap)
 set_target_properties(cloudlife PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

main.cpp

@@ -6,6 +6,8 @@
 
 #include <colormap/colormap.hpp>
 
+#include "random.h"
+
 #include <math.h> // exp
 
 #include <error.h>
@@ -27,42 +29,6 @@
 #include <GLFW/glfw3.h> // Will drag system OpenGL headers
 //#include <GL/glut.h>
 
-// https://prng.di.unimi.it/xoshiro256plusplus.c
-
-/* This is xoshiro256++ 1.0, one of our all-purpose, rock-solid generators.
-   It has excellent (sub-ns) speed, a state (256 bits) that is large
-   enough for any parallel application, and it passes all tests we are
-   aware of.
-
-   For generating just floating-point numbers, xoshiro256+ is even faster.
-
-   The state must be seeded so that it is not everywhere zero. If you have
-   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
-   output to fill s. */
-
-static inline uint64_t rotl(const uint64_t x, int k) {
-	return (x << k) | (x >> (64 - k));
-}
-
-static uint64_t s[4] = {1,2,3,4};
-
-uint64_t xoshiro256(void) {
-	const uint64_t result = rotl(s[0] + s[3], 23) + s[0];
-
-	const uint64_t t = s[1] << 17;
-
-	s[2] ^= s[0];
-	s[3] ^= s[1];
-	s[1] ^= s[2];
-	s[0] ^= s[3];
-
-	s[2] ^= t;
-
-	s[3] = rotl(s[3], 45);
-
-	return result;
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 static int item_current_idx = 0;
@@ -71,7 +37,6 @@ auto pal = colormap::palettes.at("inferno");
 
 bool draw_pal_combo() {
     bool ret = false;
-    #if 1
     auto pb = colormap::palettes.begin();
     std::advance(pb, item_current_idx);
 
@@ -97,7 +62,6 @@ bool draw_pal_combo() {
         }
         ImGui::EndCombo();
     }
-    #endif
     return ret;
 }
 
@@ -238,7 +202,7 @@ void init_field()
 static unsigned int
 random_cell(unsigned int p)
 {
-    int r = xoshiro256() & 0xff;
+    int r = xoshiro256plus() & 0xff;
 
     if (r < p) {
         return (1);
@@ -347,7 +311,7 @@ draw_field(uint32_t *p)
 
         /* rows 0 and height-1 are off screen and not drawn. */
         for (x = 1; x < f->width - 1; x++) {
-            rx = xoshiro256();
+            rx = xoshiro256plus();
             ry = rx >> f->cell_size;
             rx &= mask;
             ry &= mask;

random.c

@@ -0,0 +1,150 @@
+// https://prng.di.unimi.it/splitmix64.c
+
+/*  Written in 2015 by Sebastiano Vigna ([email protected])
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is a fixed-increment version of Java 8's SplittableRandom generator
+   See http://dx.doi.org/10.1145/2714064.2660195 and
+   http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html
+
+   It is a very fast generator passing BigCrush, and it can be useful if
+   for some reason you absolutely want 64 bits of state. */
+
+static uint64_t x = 0x1234567890abcdef; /* The state can be seeded with any value. */
+
+uint64_t splitmix64() {
+	uint64_t z = (x += 0x9e3779b97f4a7c15);
+	z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+	z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+	return z ^ (z >> 31);
+}
+
+
+
+// https://prng.di.unimi.it/xoshiro256plus.c
+
+/*  Written in 2018 by David Blackman and Sebastiano Vigna ([email protected])
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+/* This is xoshiro256+ 1.0, our best and fastest generator for floating-point
+   numbers. We suggest to use its upper bits for floating-point
+   generation, as it is slightly faster than xoshiro256++/xoshiro256**. It
+   passes all tests we are aware of except for the lowest three bits,
+   which might fail linearity tests (and just those), so if low linear
+   complexity is not considered an issue (as it is usually the case) it
+   can be used to generate 64-bit outputs, too.
+
+   We suggest to use a sign test to extract a random Boolean value, and
+   right shifts to extract subsets of bits.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s. */
+
+
+static inline uint64_t rotl(const uint64_t x, int k) {
+	return (x << k) | (x >> (64 - k));
+}
+
+
+static uint64_t s[4] = {1,2,3,4};
+
+uint64_t xoshiro256plus(void) {
+	const uint64_t result = s[0] + s[3];
+
+	const uint64_t t = s[1] << 17;
+
+	s[2] ^= s[0];
+	s[3] ^= s[1];
+	s[1] ^= s[2];
+	s[0] ^= s[3];
+
+	s[2] ^= t;
+
+	s[3] = rotl(s[3], 45);
+
+	return result;
+}
+
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^128 calls to xoshiro256plus(); it can be used to generate 2^128
+   non-overlapping subsequences for parallel computations. */
+
+void jump(void) {
+	static const uint64_t JUMP[] = { 0x180ec6d33cfd0aba, 0xd5a61266f0c9392c, 0xa9582618e03fc9aa, 0x39abdc4529b1661c };
+
+	uint64_t s0 = 0;
+	uint64_t s1 = 0;
+	uint64_t s2 = 0;
+	uint64_t s3 = 0;
+	for(int i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+		for(int b = 0; b < 64; b++) {
+			if (JUMP[i] & UINT64_C(1) << b) {
+				s0 ^= s[0];
+				s1 ^= s[1];
+				s2 ^= s[2];
+				s3 ^= s[3];
+			}
+			xoshiro256plus();
+		}
+
+	s[0] = s0;
+	s[1] = s1;
+	s[2] = s2;
+	s[3] = s3;
+}
+
+
+/* This is the long-jump function for the generator. It is equivalent to
+   2^192 calls to xoshiro256plus(); it can be used to generate 2^64 starting points,
+   from each of which jump() will generate 2^64 non-overlapping
+   subsequences for parallel distributed computations. */
+
+void long_jump(void) {
+	static const uint64_t LONG_JUMP[] = { 0x76e15d3efefdcbbf, 0xc5004e441c522fb3, 0x77710069854ee241, 0x39109bb02acbe635 };
+
+	uint64_t s0 = 0;
+	uint64_t s1 = 0;
+	uint64_t s2 = 0;
+	uint64_t s3 = 0;
+	for(int i = 0; i < sizeof LONG_JUMP / sizeof *LONG_JUMP; i++)
+		for(int b = 0; b < 64; b++) {
+			if (LONG_JUMP[i] & UINT64_C(1) << b) {
+				s0 ^= s[0];
+				s1 ^= s[1];
+				s2 ^= s[2];
+				s3 ^= s[3];
+			}
+			xoshiro256plus();
+		}
+
+	s[0] = s0;
+	s[1] = s1;
+	s[2] = s2;
+	s[3] = s3;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+void seed(uint64_t v) {
+    x = v;
+    s[0] = splitmix64();
+    s[1] = splitmix64();
+    s[2] = splitmix64();
+    s[3] = splitmix64();
+}

random.h

@@ -0,0 +1,9 @@
+#include <stdint.h>
+
+extern "C" {
+
+void seed(uint64_t v);
+uint64_t xoshiro256plus(void);
+uint64_t splitmix64();
+
+}