public class XorShift1024StarRandom extends Random
Warning: the parameters of this generator have changed in version 2.1.7.
More details about xorshift* generators can be found in my paper “An experimental exploration of Marsaglia's xorshift generators,
scrambled”, 2014.
Note that this is
not a cryptographic-strength pseudorandom number generator, but its quality is
preposterously higher than Random's, and its period is
21024 − 1, which is more than enough for any application (it is actually
possible to define analogously a generator with period 24096 − 1,
but its interest is eminently academic).
A speed-comparison table in the documentation of XorShift64StarRandom shows
that in several cases this generator is faster than ThreadLocalRandom.
This is a top-quality generator: for instance, it performs significantly better than WELL1024a
or MT19937 in the TestU01 BigCrush suite.
More details can be found on the xorshift*/xorshift+ generators and the PRNG shootout page.
This class extends Random, overriding (as usual) the Random.next(int) method.
Nonetheless, since the generator is inherently 64-bit also Random.nextInt(),
Random.nextInt(int), Random.nextLong() and Random.nextDouble() have been
overridden for speed (preserving, of course, Random's semantics).
If you do not need an instance of Random, or if you need a RandomGenerator to
use with Commons Math, you might be wanting
XorShift1024StarRandomGenerator instead of this class.
If you want to use less memory at the expense of the period, consider using XorShift128PlusRandom or XorShift64StarRandom.
Testing with TestU01 and Dieharder shows no difference in quality between the higher and the lower bits of this generator. Thus, right shifting is used whenever a subset of bits is necessary.
| Constructor and Description |
|---|
XorShift1024StarRandom()
Creates a new generator seeded using
Util.randomSeed(). |
XorShift1024StarRandom(long seed)
Creates a new generator using a given seed.
|
| Modifier and Type | Method and Description |
|---|---|
protected int |
next(int bits) |
boolean |
nextBoolean() |
void |
nextBytes(byte[] bytes) |
double |
nextDouble() |
float |
nextFloat() |
int |
nextInt() |
int |
nextInt(int n) |
long |
nextLong() |
long |
nextLong(long n)
Returns a pseudorandom uniformly distributed
long value
between 0 (inclusive) and the specified value (exclusive), drawn from
this random number generator's sequence. |
void |
setSeed(long seed)
Sets the seed of this generator.
|
void |
setState(long[] state,
int p)
Sets the state of this generator.
|
nextGaussianpublic XorShift1024StarRandom()
Util.randomSeed().public XorShift1024StarRandom(long seed)
seed - a nonzero seed for the generator (if zero, the generator will be seeded with -1).public long nextLong(long n)
long value
between 0 (inclusive) and the specified value (exclusive), drawn from
this random number generator's sequence. The algorithm used to generate
the value guarantees that the result is uniform, provided that the
sequence of 64-bit values produced by this generator is.n - the positive bound on the random number to be returned.long value between 0 (inclusive) and n (exclusive).public double nextDouble()
nextDouble in class Randompublic boolean nextBoolean()
nextBoolean in class Randompublic void setSeed(long seed)
The argument will be used to seed a XorShift64StarRandomGenerator, whose output
will in turn be used to seed this generator. This approach makes “warmup” unnecessary,
and makes the possibility of starting from a state
with a large fraction of bits set to zero astronomically small.
public void setState(long[] state,
int p)
The internal state of the generator will be reset, and the state array filled with the provided array.
state - an array of 16 longs; at least one must be nonzero.p - the internal index.