public class XorShift1024StarPhiRandom extends Random
More details can be found in my paper “An experimental exploration of
Marsaglia's xorshift
generators, scrambled”, ACM Trans. Math. Softw., 42(4), 2016, and
on the xoroshiro+
/xorshift*
/xorshift+
generators and the PRNG shootout page.
With respect to the original XorShift1024StarRandom
, this class offers
an improved constant that deletes linear dependencies from the third lowest bit.
Note that this is not a cryptographicstrength pseudorandom number generator. Its period is 2^{1024} − 1, which is more than enough for any massive parallel application (it is actually possible to define analogously a generator with period 2^{4096} − 1, but its interest is eminently academic).
By using the supplied jump()
method it is possible to generate nonoverlapping long sequences
for parallel computations. This class provides also a split()
method to support recursive parallel computations, in the spirit of
Java 8's SplittableRandom
.
Constructor and Description 

XorShift1024StarPhiRandom()
Creates a new generator seeded using
Util.randomSeed() . 
XorShift1024StarPhiRandom(long seed)
Creates a new generator using a given seed.

Modifier and Type  Method and Description 

void 
jump()
The the jump function for this generator.

protected int 
next(int bits) 
boolean 
nextBoolean() 
void 
nextBytes(byte[] bytes) 
double 
nextDouble() 
double 
nextDoubleFast()
Returns the next pseudorandom, uniformly distributed
double value between 0.0 and
1.0 from this random number generator's sequence,
using a fast multiplicationfree method which, however,
can provide only 52 significant bits. 
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.

XorShift1024StarPhiRandom 
split()
Returns a new instance that shares no mutable state
with this instance.

public XorShift1024StarPhiRandom()
Util.randomSeed()
.public XorShift1024StarPhiRandom(long seed)
seed
 a seed for the generator.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 64bit 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 Random
public double nextDoubleFast()
double
value between 0.0
and
1.0
from this random number generator's sequence,
using a fast multiplicationfree method which, however,
can provide only 52 significant bits.
This method is faster than nextDouble()
, but it
can return only dyadic rationals of the form k / 2^{−52},
instead of the standard k / 2^{−53}.
The only difference between the output of this method and that of
nextDouble()
is an additional least significant bit set in half of the
returned values. For most applications, this difference is negligible.
double
value between 0.0
and 1.0
from this
random number generator's sequence, using 52 significant bits only.public boolean nextBoolean()
nextBoolean
in class Random
public void jump()
nextLong()
; it can be used to generate 2^{512}
nonoverlapping subsequences for parallel computations.public XorShift1024StarPhiRandom split()
public void setSeed(long seed)
The argument will be used to seed a SplitMix64RandomGenerator
, whose output
will in turn be used to seed this generator. This approach makes “warmup” unnecessary,
and makes the probability 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.