java.io.Serializable
public class XoShiRo256PlusRandom
extends java.util.Random
XoShiRo256StarStarRandom
. 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 integer outputs, too.
More information can be found at our PRNG page.
If you need a general PRNG, use XoShiRo256StarStarRandom
. If you are tight on space,
you might try XoRoShiRo128PlusRandom
.
By using the supplied jump()
method it is possible to generate nonoverlapping long sequences
for parallel computations; longJump()
makes it possible to create several
starting points, each providing several nonoverlapping sequences, for distributed computations. This class provides also a split()
method to support recursive parallel computations, in the spirit of
SplittableRandom
.
Note that this is not a secure generator.
it.unimi.dsi.util
,
RandomGenerator
,
XoShiRo256PlusRandomGenerator
,
Serialized FormModifier  Constructor  Description 


XoShiRo256PlusRandom() 
Creates a new generator seeded using
Util.randomSeed() . 

XoShiRo256PlusRandom(long seed) 
Creates a new generator using a given seed.

protected 
XoShiRo256PlusRandom(long s0,
long s1,
long s2,
long s3) 
Modifier and Type  Method  Description 

XoShiRo256PlusRandom 
copy() 
Returns a copy of this generator.

XoShiRo256PlusRandom 
jump() 
The jump function for this generator.

XoShiRo256PlusRandom 
longJump() 
The longjump function for this generator.

static void 
main(java.lang.String[] arg) 

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) 
Sets the state of this generator.

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

protected XoShiRo256PlusRandom(long s0, long s1, long s2, long s3)
public XoShiRo256PlusRandom()
Util.randomSeed()
.public XoShiRo256PlusRandom(long seed)
seed
 a seed for the generator.public XoShiRo256PlusRandom copy()
This method is particularly useful in conjunction with the jump()
method: by calling repeatedly
jump().copy()
over a generator it is possible to create several generators producing nonoverlapping sequences.
public long nextLong()
nextLong
in class java.util.Random
public int nextInt()
nextInt
in class java.util.Random
public int nextInt(int n)
nextInt
in class java.util.Random
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 java.util.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}. Before
version 2.4.1, this was actually the standard implementation of
nextDouble()
, so you can use this method if you need to
reproduce exactly results obtained using previous versions.
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 float nextFloat()
nextFloat
in class java.util.Random
public boolean nextBoolean()
nextBoolean
in class java.util.Random
public void nextBytes(byte[] bytes)
nextBytes
in class java.util.Random
public XoShiRo256PlusRandom jump()
nextLong()
; it can be used to generate 2^{128}
nonoverlapping subsequences for parallel computations.copy()
public XoShiRo256PlusRandom longJump()
nextLong()
; it can be used to generate 2^{64} starting points,
from each of which jump()
will generate 2^{64} nonoverlapping
subsequences for parallel distributed computations.copy()
public XoShiRo256PlusRandom 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.
setSeed
in class java.util.Random
seed
 a seed for this generator.public void setState(long[] state)
The internal state of the generator will be reset, and the state array filled with the provided array.
state
 an array of 2 longs; at least one must be nonzero.public static void main(java.lang.String[] arg)