public final class L32X64Mix extends IntProvider implements LongJumpableUniformRandomProvider, SplittableUniformRandomProvider
This is a member of the LXM family of generators: L=Linear congruential generator;
X=Xor based generator; and M=Mix. This member uses a 32-bit LCG and 64-bit Xor-based
generator. It is named as "L32X64MixRandom"
in the java.util.random
package introduced in JDK 17; the LXM family is described in further detail in:
Steele and Vigna (2021) LXM: better splittable pseudorandom number generators (and almost as fast). Proceedings of the ACM on Programming Languages, Volume 5, Article 148, pp 1–31.
Memory footprint is 128 bits and the period is 232 (264 - 1).
This generator implements LongJumpableUniformRandomProvider
.
In addition instances created with a different additive parameter for the LCG are robust
against accidental correlation in a multi-threaded setting. The additive parameters must be
different in the most significant 31-bits.
This generator implements
SplittableUniformRandomProvider
.
The stream of generators created using the splits
methods support parallelisation
and are robust against accidental correlation by using unique values for the additive parameter
for each instance in the same stream. The primitive streaming methods support parallelisation
but with no assurances of accidental correlation; each thread uses a new instance with a
randomly initialised state.
Constructor and Description |
---|
L32X64Mix(int[] seed)
Creates a new instance.
|
L32X64Mix(int seed0,
int seed1,
int seed2,
int seed3)
Creates a new instance using a 4 element seed.
|
Modifier and Type | Method and Description |
---|---|
protected byte[] |
getStateInternal()
Creates a snapshot of the RNG state.
|
UniformRandomProvider |
jump()
Creates a copy of the UniformRandomProvider and then retreats the state of the
current instance.
|
JumpableUniformRandomProvider |
longJump()
Creates a copy of the UniformRandomProvider and then retreats the state of the
current instance.
|
int |
next() |
protected void |
setStateInternal(byte[] s)
Resets the RNG to the given
state . |
SplittableUniformRandomProvider |
split(UniformRandomProvider source) |
Stream<SplittableUniformRandomProvider> |
splits(long streamSize,
SplittableUniformRandomProvider source) |
nextBoolean, nextBytes, nextBytes, nextDouble, nextInt, nextLong, resetCachedState
checkIndex, checkStateSize, composeStateInternal, extendSeed, extendSeed, fillState, fillState, restoreState, saveState, splitStateInternal, toString
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
longJumps, longJumps
jumps, jumps
doubles, doubles, doubles, doubles, ints, ints, ints, ints, longs, longs, longs, longs, nextBoolean, nextBytes, nextBytes, nextDouble, nextDouble, nextDouble, nextFloat, nextFloat, nextFloat, nextInt, nextInt, nextInt, nextLong, nextLong, nextLong
public L32X64Mix(int[] seed)
seed
- Initial seed.
If the length is larger than 4, only the first 4 elements will
be used; if smaller, the remaining elements will be automatically
set. A seed containing all zeros in the last two elements
will create a non-functional XBG sub-generator and a low
quality output with a period of 232.
The 1st element is used to set the LCG increment; the least significant bit is set to odd to ensure a full period LCG. The 2nd element is used to set the LCG state.
public L32X64Mix(int seed0, int seed1, int seed2, int seed3)
The 1st element is used to set the LCG increment; the least significant bit is set to odd to ensure a full period LCG. The 2nd element is used to set the LCG state.
seed0
- Initial seed element 0.seed1
- Initial seed element 1.seed2
- Initial seed element 2.seed3
- Initial seed element 3.protected byte[] getStateInternal()
getStateInternal
in class IntProvider
protected void setStateInternal(byte[] s)
state
.setStateInternal
in class IntProvider
s
- State (previously obtained by a call to
BaseProvider.getStateInternal()
).BaseProvider.checkStateSize(byte[],int)
public int next()
next
in interface RandomIntSource
public UniformRandomProvider jump()
The jump is performed by advancing the state of the LCG sub-generator by 1 cycle. The XBG state is unchanged. The jump size is the equivalent of moving the state backwards by (264 - 1) positions. It can provide up to 232 non-overlapping subsequences.
jump
in interface JumpableUniformRandomProvider
public JumpableUniformRandomProvider longJump()
The jump is performed by advancing the state of the LCG sub-generator by
216 cycles. The XBG state is unchanged. The jump size is the equivalent
of moving the state backwards by 216 (264 - 1)
positions. It can provide up to 216 non-overlapping subsequences of
length 216 (264 - 1); each subsequence can provide up to
216 non-overlapping subsequences of length (264 - 1) using
the jump()
method.
longJump
in interface LongJumpableUniformRandomProvider
public SplittableUniformRandomProvider split(UniformRandomProvider source)
split
in interface SplittableUniformRandomProvider
public Stream<SplittableUniformRandomProvider> splits(long streamSize, SplittableUniformRandomProvider source)
splits
in interface SplittableUniformRandomProvider
Copyright © 2016–2022 The Apache Software Foundation. All rights reserved.