Xorshift

xorwow

Marsaglia suggested increasing the period by combining this with a simple additive counter modulo 2³² (which he calls a "Weyl sequence" after Weyl's equidistribution theorem), producing a period of 2¹⁶⁰−2³²:

/* The state array must be initialized to not be all zero in the first four words */
uint32_t xorwow(uint32_t state[static 5])
{
	/* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */
	uint32_t s, t = state[3];
	t ^= t >> 2;
	t ^= t << 1;
	state[3] = state[2]; state[2] = state[1]; state[1] = s = state[0];
	t ^= s;
	t ^= s << 4;	
	state[0] = t;
	return t + (state[4] += 362437);
}

This performs well, but fails a few tests in BigCrush.^[5] This generator is the default in Nvidia's CUDA toolkit.^[6]

xorshift*

A xorshift* generator takes a xorshift generator and applies an invertible multiplication (modulo the word size) to its output as a non-linear transformation, as suggested by Marsaglia.^[1] The following 64-bit generator with 64 bits of state has a maximal period of 2⁶⁴ − 1^[7] and fails only the MatrixRank test of BigCrush:

#include <stdint.h>

uint64_t xorshift64star(uint64_t state[static 1]) {
	uint64_t x = state[0];	/* The state must be seeded with a nonzero value. */
	x ^= x >> 12; // a
	x ^= x << 25; // b
	x ^= x >> 27; // c
	state[0] = x;
	return x * 0x2545F4914F6CDD1D;
}

A similar generator is suggested in Numerical Recipes^[8] as RanQ1, but it also fails the BirthdaySpacings test.

If the generator is modified to only return the high 32 bits, then it passes BigCrush with zero failures.^[9] In fact, a reduced version with only 40 bits of internal state passes the suite, suggesting a large safety margin.^[10]

Vigna^[7] suggests the following xorshift1024* generator with 1024 bits of state and a maximal period of 2¹⁰²⁴ − 1; it however does not always pass BigCrush:

#include <stdint.h>

/* The state must be seeded so that it is not everywhere zero. */
static uint64_t s[16];
static int p;

uint64_t xorshift1024star(void) {
	const uint64_t s0 = s[p++];
	uint64_t s1 = s[p &= 15];
	s1 ^= s1 << 31; // a
	s1 ^= s1 >> 11; // b
	s1 ^= s0 ^ (s0 >> 30); // c
	s[p] = s1;
	return s1 * (uint64_t)1181783497276652981;
}

Both generators, as it happens with all xorshift* generators, emit a sequence of 64-bit values that is equidistributed in the maximum possible dimension (except that they will never output zero for 16 calls, i.e. 128 bytes, in a row).^[7]

xorshift+

Rather than using multiplication, it is possible to use addition as a faster non-linear transformation. The idea was first proposed by Saito and Matsumoto (also responsible for the Mersenne Twister) in the XSadd generator, which adds two consecutive outputs of an underlying xorshift generator based on 32-bit shifts.^[11]

XSadd, however, has some weakness in the low-order bits of its output; it fails several BigCrush tests when the output words are bit-reversed. To correct this problem, Vigna^[12] introduced the xorshift+ family, based on 64-bit shifts: the following xorshift128+ generator uses 128 bits of state and has a maximal period of 2¹²⁸ − 1. It passes BigCrush, even when reversed.

#include <stdint.h>

/* The state must be seeded so that it is not all zero */
uint64_t s[2];

uint64_t xorshift128plus(void) {
	uint64_t x = s[0];
	uint64_t const y = s[1];
	s[0] = y;
	x ^= x << 23; // a
	s[1] = x ^ y ^ (x >> 17) ^ (y >> 26); // b, c
	return s[1] + y;
}

This generator is one of the fastest generators passing BigCrush.^[4] One disadvantage of adding consecutive outputs is while the underlying xorshift128 generator is 2-dimensionally equidistributed, the associated xorshift128+ generator is only 1-dimensionally equidistributed.^[12]