Xorshift RNGs
George Marsaglia
∗
The Florida State University
Abstract
Description of a class of simple, extremely fast random number generators (RNGs) with periods 2
k
−1 for k =
32, 64, 96, 128, 160, 192. These RNGs seem to pass tests of randomness very well.
1 Introduction
A xorshift random number generator (xorshift RNG) produces a sequence of 2
32
−1 integers x, or a sequence of 2
64
−1
pairs x,y, or a sequence of 2
96
−1 triples x,y,z, etc., by means of repeated use of a simple computer construction:
exclusive-or (xor) a computer word with a shifted version of itself. In C, the basic operation is yˆ(y<<a) for shifts
left, yˆ(y>>a) for shifts right. (In Fortran, a single form, ieor(y,ishft(y,a)) will produce the desired
result, with negative a for shifts right, nonnegative for shifts left.)
Combining such xorshift operations for various shifts and arguments provides extremely fast and simple RNGs that
seem to do very well on tests of randomness. To give an idea of the power and effectiveness of xorshift operations,
here is the essential part of a C procedure that, with only three xorshift operations per call, will provide 2
128
−1 random
32-bit integers, given four random seeds x,y,z,w:
tmp=(xˆ(x<<15)); x=y; y=z; z=w; return w=(wˆ(w>>21))ˆ(tmpˆ(tmp>>4));
Such a procedure is very fast, typically over 200 million/second, and the resulting random integers pass all the tests
of randomness that have been applied to them, particularly the“tough" tests in [3] and the new version of the Diehard
Battery [2].
Background theory for establishing the periods and choices that provide a variety of xorshift RNGs with periods up
to 2
160
are given here. Longer periods are available, for example, from multiply-with-carry RNGs, but they use integer
multiplication and require keeping a (sometimes large) table of the most recently generated values. More detailed
comparisons are given in the final, summary section.
2 Theory
A mathematical model for most RNGs can be put in the following form: We have a seed set Z made up of m-tuples
(x
1
, x
2
, . . . , x
m
), and a one-to-one function f ( ) on Z. Most commonly, Z is just a set of integers, but for better RNGs,
it may be a set of pairs, triples, etc. If z is chosen uniformly and randomly from Z, then the output of the RNG is the
sequence f (z), f
2
(z), f
3
(z), . . ., where f
2
(z) means f ( f (z)), etc. Because f is 1-1 over Z, the random variable f (z)
is itself uniform over Z, as is f
2
(z); indeed, each element of the sequence f (z), f
2
(z), . . . is uniformly distributed
over the seed set Z, but they are not independent.
For xorshift RNGs, the seed set Z is the set of 1×n binary vectors, β = (b
1
, b
2
, . . . , b
n
), excluding the zero vector.
Usually, n will be 32, 64, 96, etc., so that its elements can be made up by adjoining 32-bit computer words. The
elements of the vectors β in Z are in the field {0, 1}, so that addition of binary vectors can be implemented by xor’ing
the constituent 32-bit parts. For our xorshift RNG, we need an invertible function over Z, and for that we use a linear
transformation over the binary vector space, characterized by a nonsingular n×n binary matrix T. If β is a uniform
random choice, (the seed), from Z, then each member of the sequence βT, βT
2
, βT
3
, . . . is also uniformly distributed
∗
While the author is now Professor Emeritus, portions of the research for this article were done under by grants from The National Science
Foundation.
1