public class L64X256Mix extends LongProvider implements 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 64-bit LCG and 256-bit Xor-based
generator. It is named as "L64X256MixRandom"
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 384 bits and the period is 264 (2256 - 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 63-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.
Modifier and Type | Field and Description |
---|---|
protected long |
la
Per-instance LCG additive parameter (must be odd).
|
protected long |
ls
State of the LCG generator.
|
Modifier | Constructor and Description |
---|---|
protected |
L64X256Mix(L64X256Mix source)
Creates a copy instance.
|
|
L64X256Mix(long[] seed)
Creates a new instance.
|
|
L64X256Mix(long seed0,
long seed1,
long seed2,
long seed3,
long seed4,
long seed5)
Creates a new instance using a 6 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.
|
long |
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, nextInt, nextLong, resetCachedState
checkIndex, checkStateSize, composeStateInternal, extendSeed, extendSeed, fillState, fillState, restoreState, saveState, splitStateInternal, toString
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
doubles, doubles, doubles, doubles, ints, ints, ints, ints, longs, longs, longs, longs, split, splits, splits, splits
nextBoolean, nextBytes, nextBytes, nextDouble, nextDouble, nextDouble, nextFloat, nextFloat, nextFloat, nextInt, nextInt, nextInt, nextLong, nextLong, nextLong
longJumps, longJumps
jumps, jumps
protected long la
protected long ls
public L64X256Mix(long[] seed)
seed
- Initial seed.
If the length is larger than 6, only the first 6 elements will
be used; if smaller, the remaining elements will be automatically
set. A seed containing all zeros in the last four elements
will create a non-functional XBG sub-generator and a low
quality output with a period of 264.
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 L64X256Mix(long seed0, long seed1, long seed2, long seed3, long seed4, long seed5)
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.seed4
- Initial seed element 4.seed5
- Initial seed element 5.protected L64X256Mix(L64X256Mix source)
source
- Source to copy.protected byte[] getStateInternal()
protected void setStateInternal(byte[] s)
state
.s
- State (previously obtained by a call to
BaseProvider.getStateInternal()
).BaseProvider.checkStateSize(byte[],int)
public long next()
next
in interface RandomLongSource
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 (2256 - 1) positions. It can provide up to 264 non-overlapping subsequences.
jump
in interface JumpableUniformRandomProvider
public JumpableUniformRandomProvider longJump()
The jump is performed by advancing the state of the LCG sub-generator by 232 cycles. The XBG state is unchanged.
The jump size is the equivalent of moving the state backwards by
232 (2256 - 1) positions. It can provide up to
232 non-overlapping subsequences of length 232
(2256 - 1); each subsequence can provide up to 232
non-overlapping subsequences of length (2256 - 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.