You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ah...@apache.org on 2019/06/10 20:09:52 UTC
[commons-rng] branch master updated (b95eed5 -> 715451c)
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git.
from b95eed5 composeStateInternal requires arguments [state, parentState].
new b05d755 RNG-97: Define the JumpableUniformRandomProvider interface.
new efbc7ad RNG-97: Implement jump() function in XorShiRo generators.
new c030d85 RNG-97: Move common tests to JumpableProvidersParametricTest.
new 28c4f41 Merge branch 'feature-RNG-97'
new 089ba39 Typo: remove hyphen.
new 715451c RNG-97: Track changes.
The 6 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../commons/rng/JumpableUniformRandomProvider.java | 41 ++++
.../rng/core/source32/AbstractXoShiRo128.java | 68 ++++++-
.../commons/rng/core/source32/IntProvider.java | 33 ++++
.../commons/rng/core/source32/XoShiRo128Plus.java | 21 +++
.../rng/core/source32/XoShiRo128StarStar.java | 21 +++
.../rng/core/source64/AbstractXoRoShiRo128.java | 62 +++++-
.../rng/core/source64/AbstractXoShiRo256.java | 70 ++++++-
.../rng/core/source64/AbstractXoShiRo512.java | 87 ++++++++-
.../commons/rng/core/source64/LongProvider.java | 38 ++++
.../rng/core/source64/XoRoShiRo128Plus.java | 21 +++
.../rng/core/source64/XoRoShiRo128StarStar.java | 21 +++
.../commons/rng/core/source64/XoShiRo256Plus.java | 21 +++
.../rng/core/source64/XoShiRo256StarStar.java | 21 +++
.../commons/rng/core/source64/XoShiRo512Plus.java | 21 +++
.../rng/core/source64/XoShiRo512StarStar.java | 21 +++
.../rng/core/source64/XorShift1024Star.java | 70 ++++++-
.../rng/core/source64/XorShift1024StarPhi.java | 17 ++
.../rng/core/JumpableProvidersParametricTest.java | 209 +++++++++++++++++++++
.../org/apache/commons/rng/core/ProvidersList.java | 29 +++
.../org/apache/commons/rng/core/RandomAssert.java | 88 ++++++++-
.../rng/core/source32/XoShiRo128PlusTest.java | 74 +++++---
.../rng/core/source32/XoShiRo128StarStarTest.java | 74 +++++---
.../rng/core/source64/XoRoShiRo128PlusTest.java | 76 +++++---
.../core/source64/XoRoShiRo128StarStarTest.java | 76 +++++---
.../rng/core/source64/XoShiRo256PlusTest.java | 76 +++++---
.../rng/core/source64/XoShiRo256StarStarTest.java | 76 +++++---
.../rng/core/source64/XoShiRo512PlusTest.java | 81 ++++----
.../rng/core/source64/XoShiRo512StarStarTest.java | 81 ++++----
.../rng/core/source64/XorShift1024StarPhiTest.java | 71 ++++---
.../rng/core/source64/XorShift1024StarTest.java | 71 ++++---
src/changes/changes.xml | 6 +
31 files changed, 1437 insertions(+), 305 deletions(-)
create mode 100644 commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java
create mode 100644 commons-rng-core/src/test/java/org/apache/commons/rng/core/JumpableProvidersParametricTest.java
[commons-rng] 06/06: RNG-97: Track changes.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git
commit 715451cea693e103c180c0599a201455d6673a12
Author: Alex Herbert <ah...@apache.org>
AuthorDate: Mon Jun 10 21:09:48 2019 +0100
RNG-97: Track changes.
Closes #48
---
src/changes/changes.xml | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index f39ce4e..7da2d5a 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -75,6 +75,12 @@ re-run tests that fail, and pass the build if they succeed
within the allotted number of reruns (the test will be marked
as 'flaky' in the report).
">
+ <action dev="aherbert" type="add" issue="97">
+ New "JumpableUniformRandomProvider" interface provides a jump method that advances
+ the generator a large number of steps of the output sequence in a single operation. A
+ copy is returned allowing repeat invocations to create a series of generators
+ for use in parallel computations.
+ </action>
<action dev="aherbert" type="update" issue="RNG-103">
"LargeMeanPoissonSampler: Switch from SmallMeanPoissonSampler to use
KempSmallMeanPoissonSampler for the fractional mean sample.
[commons-rng] 02/06: RNG-97: Implement jump() function in XorShiRo
generators.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git
commit efbc7ad3dce438c931b741605f13ae60f01e1494
Author: Alex Herbert <ah...@apache.org>
AuthorDate: Sun Jun 9 20:54:29 2019 +0100
RNG-97: Implement jump() function in XorShiRo generators.
Assert the pre- and post-jump output sequences.
---
.../rng/core/source32/AbstractXoShiRo128.java | 68 ++++++++++-
.../commons/rng/core/source32/IntProvider.java | 33 ++++++
.../commons/rng/core/source32/XoShiRo128Plus.java | 21 ++++
.../rng/core/source32/XoShiRo128StarStar.java | 21 ++++
.../rng/core/source64/AbstractXoRoShiRo128.java | 62 +++++++++-
.../rng/core/source64/AbstractXoShiRo256.java | 70 ++++++++++-
.../rng/core/source64/AbstractXoShiRo512.java | 87 +++++++++++++-
.../commons/rng/core/source64/LongProvider.java | 38 ++++++
.../rng/core/source64/XoRoShiRo128Plus.java | 21 ++++
.../rng/core/source64/XoRoShiRo128StarStar.java | 21 ++++
.../commons/rng/core/source64/XoShiRo256Plus.java | 21 ++++
.../rng/core/source64/XoShiRo256StarStar.java | 21 ++++
.../commons/rng/core/source64/XoShiRo512Plus.java | 21 ++++
.../rng/core/source64/XoShiRo512StarStar.java | 21 ++++
.../rng/core/source64/XorShift1024Star.java | 70 ++++++++++-
.../rng/core/source64/XorShift1024StarPhi.java | 17 +++
.../org/apache/commons/rng/core/RandomAssert.java | 131 ++++++++++++++++++++-
.../rng/core/source32/XoShiRo128PlusTest.java | 79 ++++++++-----
.../rng/core/source32/XoShiRo128StarStarTest.java | 79 ++++++++-----
.../rng/core/source64/XoRoShiRo128PlusTest.java | 81 ++++++++-----
.../core/source64/XoRoShiRo128StarStarTest.java | 81 ++++++++-----
.../rng/core/source64/XoShiRo256PlusTest.java | 81 ++++++++-----
.../rng/core/source64/XoShiRo256StarStarTest.java | 81 ++++++++-----
.../rng/core/source64/XoShiRo512PlusTest.java | 86 ++++++++------
.../rng/core/source64/XoShiRo512StarStarTest.java | 86 ++++++++------
.../rng/core/source64/XorShift1024StarPhiTest.java | 76 ++++++++----
.../rng/core/source64/XorShift1024StarTest.java | 76 ++++++++----
27 files changed, 1245 insertions(+), 305 deletions(-)
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/AbstractXoShiRo128.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/AbstractXoShiRo128.java
index 80ec607..789613b 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/AbstractXoShiRo128.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/AbstractXoShiRo128.java
@@ -17,6 +17,8 @@
package org.apache.commons.rng.core.source32;
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.core.util.NumberFactory;
/**
@@ -27,9 +29,13 @@ import org.apache.commons.rng.core.util.NumberFactory;
*
* @since 1.3
*/
-abstract class AbstractXoShiRo128 extends IntProvider {
+abstract class AbstractXoShiRo128 extends IntProvider implements JumpableUniformRandomProvider {
/** Size of the state vector. */
private static final int SEED_SIZE = 4;
+ /** The coefficients for the jump function. */
+ private static final int[] JUMP_COEFFICIENTS = {
+ 0x8764000b, 0xf542d2d3, 0x6fa035c3, 0x77f2db5b
+ };
// State is maintained using variables rather than an array for performance
@@ -77,6 +83,19 @@ abstract class AbstractXoShiRo128 extends IntProvider {
}
/**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected AbstractXoShiRo128(AbstractXoShiRo128 source) {
+ super(source);
+ state0 = source.state0;
+ state1 = source.state1;
+ state2 = source.state2;
+ state3 = source.state3;
+ }
+
+ /**
* Copies the state from the array into the generator state.
*
* @param state the new state
@@ -105,4 +124,51 @@ abstract class AbstractXoShiRo128 extends IntProvider {
super.setStateInternal(c[1]);
}
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>The jump size is the equivalent of 2<sup>64</sup>
+ * calls to {@link UniformRandomProvider#nextInt() nextInt()}. It can provide
+ * up to 2<sup>64</sup> non-overlapping subsequences.</p>
+ */
+ @Override
+ public UniformRandomProvider jump() {
+ final UniformRandomProvider copy = copy();
+ performJump();
+ return copy;
+ }
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ protected abstract AbstractXoShiRo128 copy();
+
+ /**
+ * Perform the jump to advance the generator state. Resets the cached state of the generator.
+ */
+ private void performJump() {
+ int s0 = 0;
+ int s1 = 0;
+ int s2 = 0;
+ int s3 = 0;
+ for (final int jc : JUMP_COEFFICIENTS) {
+ for (int b = 0; b < 32; b++) {
+ if ((jc & (1 << b)) != 0) {
+ s0 ^= state0;
+ s1 ^= state1;
+ s2 ^= state2;
+ s3 ^= state3;
+ }
+ next();
+ }
+ }
+ state0 = s0;
+ state1 = s1;
+ state2 = s2;
+ state3 = s3;
+ resetCachedState();
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/IntProvider.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/IntProvider.java
index 3f5e6b9..bdddd61 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/IntProvider.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/IntProvider.java
@@ -46,6 +46,39 @@ public abstract class IntProvider
*/
private int booleanBitMask; // Initialised as 0
+ /**
+ * Creates a new instance.
+ */
+ public IntProvider() {
+ super();
+ }
+
+ /**
+ * Creates a new instance copying the state from the source.
+ *
+ * <p>This provides base functionality to allow a generator to create a copy, for example
+ * for use in the {@link org.apache.commons.rng.JumpableUniformRandomProvider
+ * JumpableUniformRandomProvider} interface.
+ *
+ * @param source Source to copy.
+ */
+ protected IntProvider(IntProvider source) {
+ booleanSource = source.booleanSource;
+ booleanBitMask = source.booleanBitMask;
+ }
+
+ /**
+ * Reset the cached state used in the default implementation of {@link #nextBoolean()}.
+ *
+ * <p>This should be used when the state is no longer valid, for example after a jump
+ * performed for the {@link org.apache.commons.rng.JumpableUniformRandomProvider
+ * JumpableUniformRandomProvider} interface.</p>
+ */
+ protected void resetCachedState() {
+ booleanSource = 0;
+ booleanBitMask = 0;
+ }
+
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128Plus.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128Plus.java
index d49a5b1..8929973 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128Plus.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128Plus.java
@@ -55,6 +55,15 @@ public class XoShiRo128Plus extends AbstractXoShiRo128 {
super(seed0, seed1, seed2, seed3);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoShiRo128Plus(XoShiRo128Plus source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public int next() {
@@ -73,4 +82,16 @@ public class XoShiRo128Plus extends AbstractXoShiRo128 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoShiRo128Plus copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoShiRo128Plus(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128StarStar.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128StarStar.java
index 84668a8..7334c1b 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128StarStar.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source32/XoShiRo128StarStar.java
@@ -55,6 +55,15 @@ public class XoShiRo128StarStar extends AbstractXoShiRo128 {
super(seed0, seed1, seed2, seed3);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoShiRo128StarStar(XoShiRo128StarStar source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public int next() {
@@ -73,4 +82,16 @@ public class XoShiRo128StarStar extends AbstractXoShiRo128 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoShiRo128StarStar copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoShiRo128StarStar(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoRoShiRo128.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoRoShiRo128.java
index 3e9bfab..e6c5592 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoRoShiRo128.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoRoShiRo128.java
@@ -17,6 +17,8 @@
package org.apache.commons.rng.core.source64;
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.core.util.NumberFactory;
/**
@@ -27,9 +29,13 @@ import org.apache.commons.rng.core.util.NumberFactory;
*
* @since 1.3
*/
-abstract class AbstractXoRoShiRo128 extends LongProvider {
+abstract class AbstractXoRoShiRo128 extends LongProvider implements JumpableUniformRandomProvider {
/** Size of the state vector. */
private static final int SEED_SIZE = 2;
+ /** The coefficients for the jump function. */
+ private static final long[] JUMP_COEFFICIENTS = {
+ 0xdf900294d8f554a5L, 0x170865df4b3201fcL
+ };
// State is maintained using variables rather than an array for performance
@@ -69,6 +75,17 @@ abstract class AbstractXoRoShiRo128 extends LongProvider {
}
/**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected AbstractXoRoShiRo128(AbstractXoRoShiRo128 source) {
+ super(source);
+ state0 = source.state0;
+ state1 = source.state1;
+ }
+
+ /**
* Copies the state from the array into the generator state.
*
* @param state the new state
@@ -94,4 +111,47 @@ abstract class AbstractXoRoShiRo128 extends LongProvider {
super.setStateInternal(c[1]);
}
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>The jump size is the equivalent of 2<sup>64</sup>
+ * calls to {@link UniformRandomProvider#nextLong() nextLong()}. It can provide
+ * up to 2<sup>64</sup> non-overlapping subsequences.</p>
+ */
+ @Override
+ public UniformRandomProvider jump() {
+ final UniformRandomProvider copy = copy();
+ performJump(JUMP_COEFFICIENTS);
+ return copy;
+ }
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ protected abstract AbstractXoRoShiRo128 copy();
+
+ /**
+ * Perform the jump to advance the generator state. Resets the cached state of the generator.
+ *
+ * @param jumpCoefficients Jump coefficients.
+ */
+ private void performJump(long[] jumpCoefficients) {
+ long s0 = 0;
+ long s1 = 0;
+ for (final long jc : jumpCoefficients) {
+ for (int b = 0; b < 64; b++) {
+ if ((jc & (1L << b)) != 0) {
+ s0 ^= state0;
+ s1 ^= state1;
+ }
+ next();
+ }
+ }
+ state0 = s0;
+ state1 = s1;
+ resetCachedState();
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo256.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo256.java
index 677e1a6..da6972f 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo256.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo256.java
@@ -17,6 +17,8 @@
package org.apache.commons.rng.core.source64;
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.core.util.NumberFactory;
/**
@@ -27,9 +29,13 @@ import org.apache.commons.rng.core.util.NumberFactory;
*
* @since 1.3
*/
-abstract class AbstractXoShiRo256 extends LongProvider {
+abstract class AbstractXoShiRo256 extends LongProvider implements JumpableUniformRandomProvider {
/** Size of the state vector. */
private static final int SEED_SIZE = 4;
+ /** The coefficients for the jump function. */
+ private static final long[] JUMP_COEFFICIENTS = {
+ 0x180ec6d33cfd0abaL, 0xd5a61266f0c9392cL, 0xa9582618e03fc9aaL, 0x39abdc4529b1661cL
+ };
// State is maintained using variables rather than an array for performance
@@ -77,6 +83,19 @@ abstract class AbstractXoShiRo256 extends LongProvider {
}
/**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected AbstractXoShiRo256(AbstractXoShiRo256 source) {
+ super(source);
+ state0 = source.state0;
+ state1 = source.state1;
+ state2 = source.state2;
+ state3 = source.state3;
+ }
+
+ /**
* Copies the state from the array into the generator state.
*
* @param state the new state
@@ -105,4 +124,53 @@ abstract class AbstractXoShiRo256 extends LongProvider {
super.setStateInternal(c[1]);
}
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>The jump size is the equivalent of 2<sup>128</sup>
+ * calls to {@link UniformRandomProvider#nextLong() nextLong()}. It can provide
+ * up to 2<sup>128</sup> non-overlapping subsequences.</p>
+ */
+ @Override
+ public UniformRandomProvider jump() {
+ final UniformRandomProvider copy = copy();
+ performJump(JUMP_COEFFICIENTS);
+ return copy;
+ }
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ protected abstract AbstractXoShiRo256 copy();
+
+ /**
+ * Perform the jump to advance the generator state. Resets the cached state of the generator.
+ *
+ * @param jumpCoefficients Jump coefficients.
+ */
+ private void performJump(long[] jumpCoefficients) {
+ long s0 = 0;
+ long s1 = 0;
+ long s2 = 0;
+ long s3 = 0;
+ for (final long jc : jumpCoefficients) {
+ for (int b = 0; b < 64; b++) {
+ if ((jc & (1L << b)) != 0) {
+ s0 ^= state0;
+ s1 ^= state1;
+ s2 ^= state2;
+ s3 ^= state3;
+ }
+ next();
+ }
+ }
+ state0 = s0;
+ state1 = s1;
+ state2 = s2;
+ state3 = s3;
+ resetCachedState();
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo512.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo512.java
index fbcbce7..a654a2d 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo512.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/AbstractXoShiRo512.java
@@ -17,6 +17,8 @@
package org.apache.commons.rng.core.source64;
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.core.util.NumberFactory;
/**
@@ -27,9 +29,14 @@ import org.apache.commons.rng.core.util.NumberFactory;
*
* @since 1.3
*/
-abstract class AbstractXoShiRo512 extends LongProvider {
+abstract class AbstractXoShiRo512 extends LongProvider implements JumpableUniformRandomProvider {
/** Size of the state vector. */
private static final int SEED_SIZE = 8;
+ /** The coefficients for the jump function. */
+ private static final long[] JUMP_COEFFICIENTS = {
+ 0x33ed89b6e7a353f9L, 0x760083d7955323beL, 0x2837f2fbb5f22faeL, 0x4b8c5674d309511cL,
+ 0xb11ac47a7ba28c25L, 0xf1be7667092bcc1cL, 0x53851efdb6df0aafL, 0x1ebbc8b23eaf25dbL
+ };
// State is maintained using variables rather than an array for performance
@@ -82,7 +89,7 @@ abstract class AbstractXoShiRo512 extends LongProvider {
* @param seed7 Initial seed element 7.
*/
AbstractXoShiRo512(long seed0, long seed1, long seed2, long seed3,
- long seed4, long seed5, long seed6, long seed7) {
+ long seed4, long seed5, long seed6, long seed7) {
state0 = seed0;
state1 = seed1;
state2 = seed2;
@@ -94,6 +101,23 @@ abstract class AbstractXoShiRo512 extends LongProvider {
}
/**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected AbstractXoShiRo512(AbstractXoShiRo512 source) {
+ super(source);
+ state0 = source.state0;
+ state1 = source.state1;
+ state2 = source.state2;
+ state3 = source.state3;
+ state4 = source.state4;
+ state5 = source.state5;
+ state6 = source.state6;
+ state7 = source.state7;
+ }
+
+ /**
* Copies the state from the array into the generator state.
*
* @param state the new state
@@ -127,4 +151,63 @@ abstract class AbstractXoShiRo512 extends LongProvider {
super.setStateInternal(c[1]);
}
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>The jump size is the equivalent of 2<sup>256</sup>
+ * calls to {@link UniformRandomProvider#nextLong() nextLong()}. It can provide
+ * up to 2<sup>256</sup> non-overlapping subsequences.</p>
+ */
+ @Override
+ public UniformRandomProvider jump() {
+ final UniformRandomProvider copy = copy();
+ performJump();
+ return copy;
+ }
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ protected abstract AbstractXoShiRo512 copy();
+
+ /**
+ * Perform the jump to advance the generator state. Resets the cached state of the generator.
+ */
+ private void performJump() {
+ long s0 = 0;
+ long s1 = 0;
+ long s2 = 0;
+ long s3 = 0;
+ long s4 = 0;
+ long s5 = 0;
+ long s6 = 0;
+ long s7 = 0;
+ for (final long jc : JUMP_COEFFICIENTS) {
+ for (int b = 0; b < 64; b++) {
+ if ((jc & (1L << b)) != 0) {
+ s0 ^= state0;
+ s1 ^= state1;
+ s2 ^= state2;
+ s3 ^= state3;
+ s4 ^= state4;
+ s5 ^= state5;
+ s6 ^= state6;
+ s7 ^= state7;
+ }
+ next();
+ }
+ }
+ state0 = s0;
+ state1 = s1;
+ state2 = s2;
+ state3 = s3;
+ state4 = s4;
+ state5 = s5;
+ state6 = s6;
+ state7 = s7;
+ resetCachedState();
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/LongProvider.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/LongProvider.java
index 764a596..44188f6 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/LongProvider.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/LongProvider.java
@@ -56,6 +56,44 @@ public abstract class LongProvider
/** Flag to indicate an int source has been cached. */
private boolean cachedIntSource; // Initialised as false
+ /**
+ * Creates a new instance.
+ */
+ public LongProvider() {
+ super();
+ }
+
+ /**
+ * Creates a new instance copying the state from the source.
+ *
+ * <p>This provides base functionality to allow a generator to create a copy, for example
+ * for use in the {@link org.apache.commons.rng.JumpableUniformRandomProvider
+ * JumpableUniformRandomProvider} interface.
+ *
+ * @param source Source to copy.
+ */
+ protected LongProvider(LongProvider source) {
+ booleanSource = source.booleanSource;
+ booleanBitMask = source.booleanBitMask;
+ intSource = source.intSource;
+ cachedIntSource = source.cachedIntSource;
+ }
+
+ /**
+ * Reset the cached state used in the default implementation of {@link #nextBoolean()}
+ * and {@link #nextInt()}.
+ *
+ * <p>This should be used when the state is no longer valid, for example after a jump
+ * performed for the {@link org.apache.commons.rng.JumpableUniformRandomProvider
+ * JumpableUniformRandomProvider} interface.</p>
+ */
+ protected void resetCachedState() {
+ booleanSource = 0L;
+ booleanBitMask = 0L;
+ intSource = 0L;
+ cachedIntSource = false;
+ }
+
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128Plus.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128Plus.java
index 3b764c8..28f9745 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128Plus.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128Plus.java
@@ -54,6 +54,15 @@ public class XoRoShiRo128Plus extends AbstractXoRoShiRo128 {
super(seed0, seed1);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoRoShiRo128Plus(XoRoShiRo128Plus source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public long next() {
@@ -67,4 +76,16 @@ public class XoRoShiRo128Plus extends AbstractXoRoShiRo128 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoRoShiRo128Plus copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoRoShiRo128Plus(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStar.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStar.java
index e19a9e9..bb1c37f 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStar.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStar.java
@@ -53,6 +53,15 @@ public class XoRoShiRo128StarStar extends AbstractXoRoShiRo128 {
super(seed0, seed1);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoRoShiRo128StarStar(XoRoShiRo128StarStar source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public long next() {
@@ -66,4 +75,16 @@ public class XoRoShiRo128StarStar extends AbstractXoRoShiRo128 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoRoShiRo128StarStar copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoRoShiRo128StarStar(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256Plus.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256Plus.java
index 56572c9..ab3780e 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256Plus.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256Plus.java
@@ -55,6 +55,15 @@ public class XoShiRo256Plus extends AbstractXoShiRo256 {
super(seed0, seed1, seed2, seed3);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoShiRo256Plus(XoShiRo256Plus source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public long next() {
@@ -73,4 +82,16 @@ public class XoShiRo256Plus extends AbstractXoShiRo256 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoShiRo256Plus copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoShiRo256Plus(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256StarStar.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256StarStar.java
index f6b34ad..09dc960 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256StarStar.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo256StarStar.java
@@ -54,6 +54,15 @@ public class XoShiRo256StarStar extends AbstractXoShiRo256 {
super(seed0, seed1, seed2, seed3);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoShiRo256StarStar(XoShiRo256StarStar source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public long next() {
@@ -72,4 +81,16 @@ public class XoShiRo256StarStar extends AbstractXoShiRo256 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoShiRo256StarStar copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoShiRo256StarStar(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512Plus.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512Plus.java
index 324b0f5..fae83c5 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512Plus.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512Plus.java
@@ -61,6 +61,15 @@ public class XoShiRo512Plus extends AbstractXoShiRo512 {
super(seed0, seed1, seed2, seed3, seed4, seed5, seed6, seed7);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoShiRo512Plus(XoShiRo512Plus source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public long next() {
@@ -83,4 +92,16 @@ public class XoShiRo512Plus extends AbstractXoShiRo512 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoShiRo512Plus copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoShiRo512Plus(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512StarStar.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512StarStar.java
index 3906a67..342cd5e 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512StarStar.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XoShiRo512StarStar.java
@@ -60,6 +60,15 @@ public class XoShiRo512StarStar extends AbstractXoShiRo512 {
super(seed0, seed1, seed2, seed3, seed4, seed5, seed6, seed7);
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XoShiRo512StarStar(XoShiRo512StarStar source) {
+ super(source);
+ }
+
/** {@inheritDoc} */
@Override
public long next() {
@@ -82,4 +91,16 @@ public class XoShiRo512StarStar extends AbstractXoShiRo512 {
return result;
}
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ @Override
+ protected XoShiRo512StarStar copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XoShiRo512StarStar(this);
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024Star.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024Star.java
index 5858052..0b732c2 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024Star.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024Star.java
@@ -18,6 +18,9 @@
package org.apache.commons.rng.core.source64;
import java.util.Arrays;
+
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.core.util.NumberFactory;
/**
@@ -30,9 +33,16 @@ import org.apache.commons.rng.core.util.NumberFactory;
* @see <a href="https://en.wikipedia.org/wiki/Xorshift">Xorshift (Wikipedia)</a>
* @since 1.0
*/
-public class XorShift1024Star extends LongProvider {
+public class XorShift1024Star extends LongProvider implements JumpableUniformRandomProvider {
/** Size of the state vector. */
private static final int SEED_SIZE = 16;
+ /** The coefficients for the jump function. */
+ private static final long[] JUMP_COEFFICIENTS = {
+ 0x84242f96eca9c41dL, 0xa3c65b8776f96855L, 0x5b34a39f070b5837L, 0x4489affce4f31a1eL,
+ 0x2ffeeb0a48316f40L, 0xdc2d9891fe68c022L, 0x3659132bb12fea70L, 0xaac17d8efa43cab8L,
+ 0xc4cb815590989b13L, 0x5ee975283d71c93bL, 0x691548c86c1bd540L, 0x7910c41d10a1e6a5L,
+ 0x0b5fc64563b3e2a8L, 0x047f7684e9fc949dL, 0xb99181f2d8f685caL, 0x284600e3f30e38c3L
+ };
/** State. */
private final long[] state = new long[SEED_SIZE];
/** The multiplier for the XorShift1024 algorithm. */
@@ -66,6 +76,18 @@ public class XorShift1024Star extends LongProvider {
this.multiplier = multiplier;
}
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XorShift1024Star(XorShift1024Star source) {
+ super(source);
+ System.arraycopy(source.state, 0, state, 0, SEED_SIZE);
+ multiplier = source.multiplier;
+ index = source.index;
+ }
+
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
@@ -109,4 +131,50 @@ public class XorShift1024Star extends LongProvider {
state[index] = s1 ^ s0 ^ (s1 >>> 11) ^ (s0 >>> 30); // b,c
return state[index] * multiplier;
}
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>The jump size is the equivalent of 2<sup>512</sup>
+ * calls to {@link UniformRandomProvider#nextLong() nextLong()}. It can provide
+ * up to 2<sup>512</sup> non-overlapping subsequences.</p>
+ */
+ @Override
+ public UniformRandomProvider jump() {
+ final UniformRandomProvider copy = copy();
+ performJump();
+ return copy;
+ }
+
+ /**
+ * Create a copy.
+ *
+ * @return the copy
+ */
+ protected XorShift1024Star copy() {
+ // This exists to ensure the jump function returns
+ // the correct class type. It should not be public.
+ return new XorShift1024Star(this);
+ }
+
+ /**
+ * Perform the jump to advance the generator state. Resets the cached state of the generator.
+ */
+ private void performJump() {
+ final long[] newState = new long[SEED_SIZE];
+ for (final long jc : JUMP_COEFFICIENTS) {
+ for (int b = 0; b < 64; b++) {
+ if ((jc & (1L << b)) != 0) {
+ for (int i = 0; i < SEED_SIZE; i++) {
+ newState[i] ^= state[(i + index) & 15];
+ }
+ }
+ next();
+ }
+ }
+ for (int j = 0; j < 16; j++) {
+ state[(j + index) & 15] = newState[j];
+ }
+ resetCachedState();
+ }
}
diff --git a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024StarPhi.java b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024StarPhi.java
index a51d462..da49105 100644
--- a/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024StarPhi.java
+++ b/commons-rng-core/src/main/java/org/apache/commons/rng/core/source64/XorShift1024StarPhi.java
@@ -43,4 +43,21 @@ public class XorShift1024StarPhi extends XorShift1024Star {
public XorShift1024StarPhi(long[] seed) {
super(seed, 0x9e3779b97f4a7c13L);
}
+
+ /**
+ * Creates a copy instance.
+ *
+ * @param source Source to copy.
+ */
+ protected XorShift1024StarPhi(XorShift1024StarPhi source) {
+ super(source);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected XorShift1024StarPhi copy() {
+ // This exists to ensure the jump function performed in the super class returns
+ // the correct class type. It should not be public.
+ return new XorShift1024StarPhi(this);
+ }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java
index 2c3806d..2eb409f 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java
@@ -18,10 +18,14 @@
package org.apache.commons.rng.core;
import org.junit.Assert;
+import org.junit.Assume;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.RandomProviderState;
+import org.apache.commons.rng.RestorableUniformRandomProvider;
import org.apache.commons.rng.UniformRandomProvider;
/**
@@ -35,24 +39,145 @@ public class RandomAssert {
* @param rng Random generator.
*/
public static void assertEquals(int[] expected, UniformRandomProvider rng) {
+ assertEquals("Value at position ", expected, rng);
+ }
+
+ /**
+ * Assert that the random generator produces the expected output.
+ *
+ * @param expected Expected output.
+ * @param rng Random generator.
+ */
+ public static void assertEquals(long[] expected, UniformRandomProvider rng) {
+ assertEquals("Value at position ", expected, rng);
+ }
+
+ /**
+ * Assert that the random generator produces the expected output.
+ * The message prefix is prepended to the array index for the assertion message.
+ *
+ * @param messagePrefix Message prefix.
+ * @param expected Expected output.
+ * @param rng Random generator.
+ */
+ private static void assertEquals(String messagePrefix, int[] expected, UniformRandomProvider rng) {
for (int i = 0; i < expected.length; i++) {
- Assert.assertEquals("Value at position " + i, expected[i], rng.nextInt());
+ Assert.assertEquals(messagePrefix + i, expected[i], rng.nextInt());
}
}
/**
* Assert that the random generator produces the expected output.
+ * The message prefix is prepended to the array index for the assertion message.
*
+ * @param messagePrefix Message prefix.
* @param expected Expected output.
* @param rng Random generator.
*/
- public static void assertEquals(long[] expected, UniformRandomProvider rng) {
+ private static void assertEquals(String messagePrefix, long[] expected, UniformRandomProvider rng) {
for (int i = 0; i < expected.length; i++) {
- Assert.assertEquals("Value at position " + i, expected[i], rng.nextLong());
+ Assert.assertEquals(messagePrefix + i, expected[i], rng.nextLong());
}
}
/**
+ * Assert that the random generator satisfies the contract of the
+ * {@link JumpableUniformRandomProvider#jump()} function.
+ *
+ * <ul>
+ * <li>The jump returns a copy instance. This is asserted to be a different object
+ * of the same class type as the input.
+ * <li>The copy instance outputs the expected sequence for the current state of the input generator.
+ * This is asserted using the {@code expectedBefore} sequence.
+ * <li>The input instance outputs the expected sequence for an advanced state.
+ * This is asserted using the {@code expectedAfter} sequence.
+ * <ul>
+ *
+ * @param expectedBefore Expected output before the jump.
+ * @param expectedAfter Expected output after the jump.
+ * @param rng Random generator.
+ */
+ public static void assertJumpEquals(int[] expectedBefore,
+ int[] expectedAfter,
+ JumpableUniformRandomProvider rng) {
+ final UniformRandomProvider copy = rng.jump();
+ Assert.assertNotSame("The copy instance should be a different object", rng, copy);
+ Assert.assertEquals("The copy instance should be the same class", rng.getClass(), copy.getClass());
+ assertEquals("Pre-jump value at position ", expectedBefore, copy);
+ assertEquals("Post-jump value at position ", expectedAfter, rng);
+ }
+
+ /**
+ * Assert that the random generator satisfies the contract of the
+ * {@link JumpableUniformRandomProvider#jump()} function.
+ *
+ * <ul>
+ * <li>The jump returns a copy instance. This is asserted to be a different object
+ * of the same class type as the input.
+ * <li>The copy instance outputs the expected sequence for the current state of the input generator.
+ * This is asserted using the {@code expectedBefore} sequence.
+ * <li>The input instance outputs the expected sequence for an advanced state.
+ * This is asserted using the {@code expectedAfter} sequence.
+ * <ul>
+ *
+ * @param expectedBefore Expected output before the jump.
+ * @param expectedAfter Expected output after the jump.
+ * @param rng Random generator.
+ */
+ public static void assertJumpEquals(long[] expectedBefore,
+ long[] expectedAfter,
+ JumpableUniformRandomProvider rng) {
+ final UniformRandomProvider copy = rng.jump();
+ Assert.assertNotSame("The copy instance should be a different object", rng, copy);
+ Assert.assertEquals("The copy instance should be the same class", rng.getClass(), copy.getClass());
+ assertEquals("Pre-jump value at position ", expectedBefore, copy);
+ assertEquals("Post-jump value at position ", expectedAfter, rng);
+ }
+
+ /**
+ * Assert that the random generator state of the copy instance returned from the
+ * jump function matches the input state.
+ *
+ * <p>The generator must be a {@link RestorableUniformRandomProvider} and return
+ * an instance of {@link RandomProviderDefaultState}.</p>
+ *
+ * <p>The input generator is sampled using methods in the
+ * {@link UniformRandomProvider} interface, the state is saved and a jump is
+ * performed. The states from the pre-jump generator and the returned copy
+ * instance must match.</p>
+ *
+ * <p>This test targets any cached state of the default implementation of a generator
+ * in {@link org.apache.commons.rng.core.source32.IntProvider IntProvider} and
+ * {@link org.apache.commons.rng.core.source64.LongProvider LongProvider}
+ * such as the state cached for the nextBoolean() and nextInt() functions.</p>
+ *
+ * @param rng Random generator.
+ */
+ public static void assertJumpUsingState(JumpableUniformRandomProvider rng) {
+ Assume.assumeTrue("Not a restorable RNG", rng instanceof RestorableUniformRandomProvider);
+
+ // Exercise the generator.
+ // This calls nextInt() an odd number of times so the default
+ // implementation of LongProvider should have cached a state for nextInt().
+ for (int i = 0; i < 3; i++) {
+ rng.nextInt();
+ rng.nextLong();
+ rng.nextBoolean();
+ }
+
+ final RandomProviderState preJumpState = ((RestorableUniformRandomProvider) rng).saveState();
+ Assume.assumeTrue("Not a recognised state", preJumpState instanceof RandomProviderDefaultState);
+
+ final UniformRandomProvider copy = rng.jump();
+ Assert.assertNotSame("The copy instance should be a different object", rng, copy);
+
+ final RandomProviderState copyState = ((RestorableUniformRandomProvider)copy).saveState();
+ final RandomProviderDefaultState expected = (RandomProviderDefaultState) preJumpState;
+ final RandomProviderDefaultState actual = (RandomProviderDefaultState) copyState;
+ Assert.assertArrayEquals(expected.getState(), actual.getState());
+ }
+
+ /**
* Assert that the two random generators produce the same output for
* {@link UniformRandomProvider#nextInt()} over the given number of cycles.
*
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java
index e45ac98..4fad812 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java
@@ -23,30 +23,44 @@ public class XoShiRo128PlusTest {
/** The size of the array seed. */
private static final int SEED_SIZE = 4;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoshiro128plus.c
- */
- final int[] seed = {
- 0x012de1ba, 0xa5a818b8, 0xb124ea2b, 0x18e03749,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoshiro128plus.c
+ */
+
+ private static final int[] SEED = {
+ 0x012de1ba, 0xa5a818b8, 0xb124ea2b, 0x18e03749,
+ };
- final int[] expectedSequence = {
- 0x1a0e1903, 0xfde55c35, 0xddb16b2e, 0xab949ac5,
- 0xb5519fea, 0xc6a97473, 0x1f0403d9, 0x1bb46995,
- 0x79c99a12, 0xe447ebce, 0xa8c31d78, 0x54d8bbe3,
- 0x4984a039, 0xb411e932, 0x9c1f2c5e, 0x5f53c469,
- 0x7f333552, 0xb368c7a1, 0xa57b8e66, 0xb29a9444,
- 0x5c389bfa, 0x8e7d3758, 0xfe17a1bb, 0xcd0aad57,
- 0xde83c4bb, 0x1402339d, 0xb557a080, 0x4f828bc9,
- 0xde14892d, 0xbba8eaed, 0xab62ebbb, 0x4ad959a4,
- 0x3c6ee9c7, 0x4f6a6fd3, 0xd5785eed, 0x1a0227d1,
- 0x81314acb, 0xfabdfb97, 0x7e1b7e90, 0x57544e23,
- };
+ private static final int[] EXPECTED_SEQUENCE = {
+ 0x1a0e1903, 0xfde55c35, 0xddb16b2e, 0xab949ac5,
+ 0xb5519fea, 0xc6a97473, 0x1f0403d9, 0x1bb46995,
+ 0x79c99a12, 0xe447ebce, 0xa8c31d78, 0x54d8bbe3,
+ 0x4984a039, 0xb411e932, 0x9c1f2c5e, 0x5f53c469,
+ 0x7f333552, 0xb368c7a1, 0xa57b8e66, 0xb29a9444,
+ 0x5c389bfa, 0x8e7d3758, 0xfe17a1bb, 0xcd0aad57,
+ 0xde83c4bb, 0x1402339d, 0xb557a080, 0x4f828bc9,
+ 0xde14892d, 0xbba8eaed, 0xab62ebbb, 0x4ad959a4,
+ 0x3c6ee9c7, 0x4f6a6fd3, 0xd5785eed, 0x1a0227d1,
+ 0x81314acb, 0xfabdfb97, 0x7e1b7e90, 0x57544e23,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoShiRo128Plus(seed));
+ private static final int[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0x65ddc942, 0x7e7c4d6b, 0x6745a785, 0x40897788,
+ 0xfb60ce92, 0x121f2ee0, 0xd000bae8, 0x52b3ebfc,
+ 0x62fc3720, 0xf880f092, 0x7753c1ab, 0x1e76a627,
+ 0xe5de31e8, 0xc7b1503f, 0xa5557a66, 0x37b2b2cd,
+ 0x656dde58, 0xdd5f1b93, 0xba61298b, 0xbd5d1ce2,
+ 0xea4a5a73, 0x0f10981d, 0xc207a68c, 0x1897adca,
+ 0x4d729b07, 0xf0115ee0, 0x953d9e4b, 0x3608e61c,
+ 0x0c14c065, 0xf2ed7579, 0xcd96ef9b, 0xdb62d117,
+ 0x844e4713, 0x763a8a76, 0x9ad37470, 0x211e4883,
+ 0xc8682b75, 0xb1831941, 0xf0c50a84, 0x7321dc33,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo128Plus(SEED));
}
@Test
@@ -62,16 +76,23 @@ public class XoShiRo128PlusTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoShiRo128Plus(new int[] { 0x012de1ba });
+ new XoShiRo128Plus(new int[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final int[] seed = {
- 0x012de1ba, 0xa5a818b8, 0xb124ea2b, 0x18e03749,
- };
- final XoShiRo128Plus rng1 = new XoShiRo128Plus(seed);
- final XoShiRo128Plus rng2 = new XoShiRo128Plus(seed[0], seed[1], seed[2], seed[3]);
- RandomAssert.assertNextIntEquals(seed.length * 2, rng1, rng2);
+ final XoShiRo128Plus rng1 = new XoShiRo128Plus(SEED);
+ final XoShiRo128Plus rng2 = new XoShiRo128Plus(SEED[0], SEED[1], SEED[2], SEED[3]);
+ RandomAssert.assertNextIntEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo128Plus(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoShiRo128Plus(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java
index ea78563..485bcd3 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java
@@ -23,30 +23,44 @@ public class XoShiRo128StarStarTest {
/** The size of the array seed. */
private static final int SEED_SIZE = 4;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoshiro128starstar.c
- */
- final int[] seed = {
- 0x012de1ba, 0xa5a818b8, 0xb124ea2b, 0x18e03749,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoshiro128starstar.c
+ */
+
+ private static final int[] SEED = {
+ 0x012de1ba, 0xa5a818b8, 0xb124ea2b, 0x18e03749,
+ };
- final int[] expectedSequence = {
- 0x8856d912, 0xf2a19a86, 0x7693f66d, 0x23516f86,
- 0x4895054e, 0xf4503fe6, 0x40e04672, 0x99244e34,
- 0xb971815c, 0x3008b82c, 0x0ee73b58, 0x88aad2c6,
- 0x7923f2e9, 0xfde55485, 0x7aed95f5, 0xeb8abb59,
- 0xca78183a, 0x80ecdd68, 0xfd404b06, 0x248b9c9e,
- 0xa2c69c6f, 0x1723b375, 0x879f37b0, 0xe98fd208,
- 0x75de84a9, 0x717d6df8, 0x92cd7bc7, 0x46380167,
- 0x7f08600b, 0x58566f2b, 0x7f781475, 0xe34ec04d,
- 0x6d5ef889, 0xb76ff6d8, 0x501f5df6, 0x4cf70ccb,
- 0xd7375b26, 0x457ea1ab, 0x7439e565, 0x355855af,
- };
+ private static final int[] EXPECTED_SEQUENCE = {
+ 0x8856d912, 0xf2a19a86, 0x7693f66d, 0x23516f86,
+ 0x4895054e, 0xf4503fe6, 0x40e04672, 0x99244e34,
+ 0xb971815c, 0x3008b82c, 0x0ee73b58, 0x88aad2c6,
+ 0x7923f2e9, 0xfde55485, 0x7aed95f5, 0xeb8abb59,
+ 0xca78183a, 0x80ecdd68, 0xfd404b06, 0x248b9c9e,
+ 0xa2c69c6f, 0x1723b375, 0x879f37b0, 0xe98fd208,
+ 0x75de84a9, 0x717d6df8, 0x92cd7bc7, 0x46380167,
+ 0x7f08600b, 0x58566f2b, 0x7f781475, 0xe34ec04d,
+ 0x6d5ef889, 0xb76ff6d8, 0x501f5df6, 0x4cf70ccb,
+ 0xd7375b26, 0x457ea1ab, 0x7439e565, 0x355855af,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoShiRo128StarStar(seed));
+ private static final int[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0xab597786, 0x9e11647e, 0x147c0f8e, 0xfe86b079,
+ 0x8cda108b, 0x461f24ad, 0x00204529, 0xdfa240cf,
+ 0xcc697f88, 0x11a49521, 0x5e6eb377, 0xe7dad980,
+ 0xc522beed, 0x54049c0d, 0x5409c7de, 0x22148129,
+ 0x2d7fc96e, 0x288d7114, 0xfb18c495, 0x689c4e2b,
+ 0xd7219504, 0xb2d81d4d, 0xe66c9680, 0xeec149b3,
+ 0x82fad922, 0x49e59804, 0x7be8f245, 0xbc193d57,
+ 0xa542f0d5, 0x07474d51, 0xff3c7b3d, 0x2eda9beb,
+ 0xca7657a3, 0xcf58554d, 0x5fe25af7, 0x5beb7d19,
+ 0x58339082, 0x6f7ac9ed, 0xf07faa96, 0x7348dcbf,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo128StarStar(SEED));
}
@Test
@@ -62,16 +76,23 @@ public class XoShiRo128StarStarTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoShiRo128StarStar(new int[] { 0x012de1ba });
+ new XoShiRo128StarStar(new int[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final int[] seed = {
- 0x012de1ba, 0xa5a818b8, 0xb124ea2b, 0x18e03749,
- };
- final XoShiRo128StarStar rng1 = new XoShiRo128StarStar(seed);
- final XoShiRo128StarStar rng2 = new XoShiRo128StarStar(seed[0], seed[1], seed[2], seed[3]);
- RandomAssert.assertNextIntEquals(seed.length * 2, rng1, rng2);
+ final XoShiRo128StarStar rng1 = new XoShiRo128StarStar(SEED);
+ final XoShiRo128StarStar rng2 = new XoShiRo128StarStar(SEED[0], SEED[1], SEED[2], SEED[3]);
+ RandomAssert.assertNextIntEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP , new XoShiRo128StarStar(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoShiRo128StarStar(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java
index b742800..0dc5666 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java
@@ -20,33 +20,47 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XoRoShiRo128PlusTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 2;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoroshiro128plus.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoroshiro128plus.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L,
+ };
- final long[] expectedSequence = {
- 0xa6d5fa73b796e607L, 0xd419031a381fea2eL, 0x28938b88b4972f52L, 0x032793a0d51c1a27L,
- 0x50001cd69cc5b006L, 0x44bbf571167cb7f0L, 0x172f6a2f093b2befL, 0xe642c831f1e4f7bfL,
- 0xcec4e4b5d448032aL, 0xc0164992807cbd59L, 0xb96ff06c68515410L, 0x5288e0312a0aae72L,
- 0x79a891c387d3be2eL, 0x6c52f6f710db553bL, 0x2ce6f6b1946862b3L, 0x87eb1e1b24b47f11L,
- 0x9f7c3511c5f23bcfL, 0x3254897533dcd1abL, 0x89d56ad217fbd1adL, 0x70f6b269f815f6e6L,
- 0xe8ee60efadfdb8c4L, 0x09286db69fdd232bL, 0xf440882651fc19e8L, 0x6356fea018cc26cdL,
- 0xf692282b43fcb0c2L, 0xef3f084929119babL, 0x355efbf5bedeb114L, 0x6cf5089c2acc96ddL,
- 0x819c19e480f0bfd1L, 0x414d12ff4082e261L, 0xc9a33a52545dd374L, 0x4675247e6fe89b3cL,
- 0x069f2e55cea155baL, 0x1e8d1dcf349746b8L, 0xdf32e487bdd74523L, 0xa544710cae2ad7cdL,
- 0xf5ac505e74fe049dL, 0xf039e289da4cdf7eL, 0x0a6fbebe9122529cL, 0x880c51e0915031a3L,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0xa6d5fa73b796e607L, 0xd419031a381fea2eL, 0x28938b88b4972f52L, 0x032793a0d51c1a27L,
+ 0x50001cd69cc5b006L, 0x44bbf571167cb7f0L, 0x172f6a2f093b2befL, 0xe642c831f1e4f7bfL,
+ 0xcec4e4b5d448032aL, 0xc0164992807cbd59L, 0xb96ff06c68515410L, 0x5288e0312a0aae72L,
+ 0x79a891c387d3be2eL, 0x6c52f6f710db553bL, 0x2ce6f6b1946862b3L, 0x87eb1e1b24b47f11L,
+ 0x9f7c3511c5f23bcfL, 0x3254897533dcd1abL, 0x89d56ad217fbd1adL, 0x70f6b269f815f6e6L,
+ 0xe8ee60efadfdb8c4L, 0x09286db69fdd232bL, 0xf440882651fc19e8L, 0x6356fea018cc26cdL,
+ 0xf692282b43fcb0c2L, 0xef3f084929119babL, 0x355efbf5bedeb114L, 0x6cf5089c2acc96ddL,
+ 0x819c19e480f0bfd1L, 0x414d12ff4082e261L, 0xc9a33a52545dd374L, 0x4675247e6fe89b3cL,
+ 0x069f2e55cea155baL, 0x1e8d1dcf349746b8L, 0xdf32e487bdd74523L, 0xa544710cae2ad7cdL,
+ 0xf5ac505e74fe049dL, 0xf039e289da4cdf7eL, 0x0a6fbebe9122529cL, 0x880c51e0915031a3L,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoRoShiRo128Plus(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0xb715ad9cb572030eL, 0x10634f817a8f69b1L, 0xe871b367a8f9c567L, 0x3096f4ceb23198cdL,
+ 0xf5b09c8734d26da9L, 0x58ba83f779a2549cL, 0xb6c54c8ea9fc672bL, 0x87bb9766ff20834dL,
+ 0x2686d4a93b9bb8a7L, 0xababdb798931fbfbL, 0xc9ce83b35259eb39L, 0xe2314c9488d44131L,
+ 0x5841497fb6fe3a62L, 0x00ecd78f2eba1e81L, 0x4aed6d184b3ada35L, 0xb33681cb7e39c9d0L,
+ 0x911498e07cb3d3ceL, 0xea92a7dfb98aa971L, 0x5db49f2f3f22321cL, 0x4982bae495d875f4L,
+ 0xa436167ccfb3a982L, 0x646b0fe680176bb2L, 0x8312610f7e93a41fL, 0xa67a4d13d12cb264L,
+ 0xf22330689f003fa8L, 0xfa0d7f3712db37beL, 0x409b34496c4a847cL, 0x9ac1b246a47e2a17L,
+ 0x6006078c0c743c74L, 0x457ef921811029ecL, 0xd6d9f58851583575L, 0xabbdd4ac3c49239bL,
+ 0xc07444095ef29743L, 0x75a2eb7c74f95d6eL, 0xd0ead6726a91ada9L, 0x9749e96908129418L,
+ 0x83ae5b12eb343545L, 0x10828fde12decab5L, 0x6952d51f130505b7L, 0x9b6bd81fbe064f54L,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoRoShiRo128Plus(SEED));
}
@Test
@@ -62,16 +76,23 @@ public class XoRoShiRo128PlusTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoRoShiRo128Plus(new long[] { 0x012de1babb3c4104L });
+ new XoRoShiRo128Plus(new long[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L,
- };
- final XoRoShiRo128Plus rng1 = new XoRoShiRo128Plus(seed);
- final XoRoShiRo128Plus rng2 = new XoRoShiRo128Plus(seed[0], seed[1]);
- RandomAssert.assertNextLongEquals(seed.length * 2, rng1, rng2);
+ final XoRoShiRo128Plus rng1 = new XoRoShiRo128Plus(SEED);
+ final XoRoShiRo128Plus rng2 = new XoRoShiRo128Plus(SEED[0], SEED[1]);
+ RandomAssert.assertNextLongEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoRoShiRo128Plus(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoRoShiRo128Plus(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java
index ef9cd13..9c6df2c 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java
@@ -20,33 +20,47 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XoRoShiRo128StarStarTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 2;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoroshiro128starstar.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xorshift.di.unimi.it/xorshift1024star.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L
+ };
- final long[] expectedSequence = {
- 0x8856e974cbb6da12L, 0xd1704f3601beb952L, 0x368a027941bc61e7L, 0x882b24dcfa3ada58L,
- 0xfa8dafb3363143fbL, 0x2eb9417a5dcf7654L, 0xed8722e0a73e975bL, 0x435fff57a631d485L,
- 0x954f1ad2377632b8L, 0x9aa2f4dcba28ab71L, 0xaca10369f96ac911L, 0x968088e7277d0369L,
- 0x662e442ae32c42b4L, 0xe1cd476f71dd058eL, 0xb462a3c2bbb650f8L, 0x74749215e8c07d08L,
- 0x1629f3cb1a671dbbL, 0x3636dcc702eadf55L, 0x97ae682e61cb3f57L, 0xfdf8fc5ea9541f3bL,
- 0x2dfdb23d99c34accL, 0x68bef4f41a8f4113L, 0x5cd03dc43f7af892L, 0xdc2184abe0565da1L,
- 0x1dfaece40d9f96d0L, 0x7d7b19285818ab71L, 0xedea7fd3a0e47018L, 0x23542ee7ed294823L,
- 0x1719f2b97bfc26c4L, 0x2c7b7e288b399818L, 0x49fa00786a1f5ad9L, 0xd97cdfbe81700be2L,
- 0x557480baa4d9e5b2L, 0x840a0403c0e85d92L, 0xb4d5c6b2dc19dab2L, 0xdf1b570e3bf1cf1bL,
- 0x26d1ac9455ccc75fL, 0xdcc0e5fe06d1e231L, 0x5164b7650568120eL, 0x5fa82f6598483607L,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0x8856e974cbb6da12L, 0xd1704f3601beb952L, 0x368a027941bc61e7L, 0x882b24dcfa3ada58L,
+ 0xfa8dafb3363143fbL, 0x2eb9417a5dcf7654L, 0xed8722e0a73e975bL, 0x435fff57a631d485L,
+ 0x954f1ad2377632b8L, 0x9aa2f4dcba28ab71L, 0xaca10369f96ac911L, 0x968088e7277d0369L,
+ 0x662e442ae32c42b4L, 0xe1cd476f71dd058eL, 0xb462a3c2bbb650f8L, 0x74749215e8c07d08L,
+ 0x1629f3cb1a671dbbL, 0x3636dcc702eadf55L, 0x97ae682e61cb3f57L, 0xfdf8fc5ea9541f3bL,
+ 0x2dfdb23d99c34accL, 0x68bef4f41a8f4113L, 0x5cd03dc43f7af892L, 0xdc2184abe0565da1L,
+ 0x1dfaece40d9f96d0L, 0x7d7b19285818ab71L, 0xedea7fd3a0e47018L, 0x23542ee7ed294823L,
+ 0x1719f2b97bfc26c4L, 0x2c7b7e288b399818L, 0x49fa00786a1f5ad9L, 0xd97cdfbe81700be2L,
+ 0x557480baa4d9e5b2L, 0x840a0403c0e85d92L, 0xb4d5c6b2dc19dab2L, 0xdf1b570e3bf1cf1bL,
+ 0x26d1ac9455ccc75fL, 0xdcc0e5fe06d1e231L, 0x5164b7650568120eL, 0x5fa82f6598483607L,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoRoShiRo128StarStar(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0xbfc83ba4fd4868deL, 0x3f3eed826e632fddL, 0x9dff0e4eeebb7d32L, 0x686d1cc4eabb9535L,
+ 0xc091c73d7fbf9d0fL, 0x1042f833a9e605c8L, 0x525ef7b2826c2f23L, 0xe550c19eaaf09c9cL,
+ 0x091b0069cde91826L, 0x0cd7b89fce47625dL, 0x51f7596cfccd79d2L, 0xf36137464d58d44aL,
+ 0xc41979c626c4523cL, 0x6fe485d7bc4c268bL, 0x70d606b170542c89L, 0xb2a1ebcaa0b1411eL,
+ 0x4fec797dbbdeac3eL, 0x55c95cc08792d434L, 0x10e8fa257142e24aL, 0x6a7203a3c55725dfL,
+ 0x4c5606f2b8a65adbL, 0x5fc275ff7c58e74fL, 0x52272729918e8ac7L, 0xd495b534244c4ad2L,
+ 0x74be6afb953ce5aeL, 0xe61156ee003e41c9L, 0x5098c77788c9bf25L, 0xde679d7898225baaL,
+ 0x3568366f6aefe488L, 0x2afe2420f9f9dbccL, 0x1ca0bcb15f1d1accL, 0xf1677c09f3df59e1L,
+ 0x45dadcac4957d8d0L, 0xc46265d2810fe48eL, 0xa9234384080ec825L, 0x4a4e054ced918e13L,
+ 0xa9b19565638b0e2bL, 0x755bf81250abd6c1L, 0x2b8ba00b2714bf8fL, 0x5e165740374e0fa6L,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoRoShiRo128StarStar(SEED));
}
@Test
@@ -62,16 +76,23 @@ public class XoRoShiRo128StarStarTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoRoShiRo128StarStar(new long[] { 0x012de1babb3c4104L });
+ new XoRoShiRo128StarStar(new long[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L,
- };
- final XoRoShiRo128StarStar rng1 = new XoRoShiRo128StarStar(seed);
- final XoRoShiRo128StarStar rng2 = new XoRoShiRo128StarStar(seed[0], seed[1]);
- RandomAssert.assertNextLongEquals(seed.length * 2, rng1, rng2);
+ final XoRoShiRo128StarStar rng1 = new XoRoShiRo128StarStar(SEED);
+ final XoRoShiRo128StarStar rng2 = new XoRoShiRo128StarStar(SEED[0], SEED[1]);
+ RandomAssert.assertNextLongEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoRoShiRo128StarStar(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoRoShiRo128StarStar(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java
index aafa163..fc99ec2 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java
@@ -20,33 +20,47 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XoShiRo256PlusTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 4;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoshiro256plus.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoshiro256plus.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
+ };
- final long[] expectedSequence = {
- 0x1a0e1903ef150886L, 0x08b605f47abc5d75L, 0xd82176096ac9be31L, 0x8fbf2af9b4fa5405L,
- 0x9ab074b448171964L, 0xfd68cc83ab4360aaL, 0xf431f7c0c8dc6f2bL, 0xc04430be08212638L,
- 0xc1ad670648f1da03L, 0x3eb70d38796ba24aL, 0x0e474d0598251ed2L, 0xf9b6b3b56482566bL,
- 0x3d11e529ae07a7c8L, 0x3b195f84f4db17e7L, 0x09d62e817b8223e2L, 0x89dc4db9cd625509L,
- 0x52e04793fe977846L, 0xc052428d6d7d17cdL, 0x6fd6f8da306b10efL, 0x64a7996ba5cc80aaL,
- 0x03abf59b95a1ef20L, 0xc5a82fc3cfb50234L, 0x0d401229eabb2d39L, 0xb537b249f70bd18aL,
- 0x1af1b703753fcf4dL, 0xb84648c1945d9ccbL, 0x1d321bea673e1f66L, 0x93d4445b268f305fL,
- 0xc046cfa36d89a312L, 0x8cc2d55bbf778790L, 0x1d668b0a3d329cc7L, 0x81b6d533dfcf82deL,
- 0x9ca1c49a18537b16L, 0x68e55c4054e0cb72L, 0x06ed1956cb69afc6L, 0x4871e696449da910L,
- 0xcfbd7a145066d46eL, 0x10131cb15004b62dL, 0x489c91a322bca3b6L, 0x8ec95fa9bef73e66L,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0x1a0e1903ef150886L, 0x08b605f47abc5d75L, 0xd82176096ac9be31L, 0x8fbf2af9b4fa5405L,
+ 0x9ab074b448171964L, 0xfd68cc83ab4360aaL, 0xf431f7c0c8dc6f2bL, 0xc04430be08212638L,
+ 0xc1ad670648f1da03L, 0x3eb70d38796ba24aL, 0x0e474d0598251ed2L, 0xf9b6b3b56482566bL,
+ 0x3d11e529ae07a7c8L, 0x3b195f84f4db17e7L, 0x09d62e817b8223e2L, 0x89dc4db9cd625509L,
+ 0x52e04793fe977846L, 0xc052428d6d7d17cdL, 0x6fd6f8da306b10efL, 0x64a7996ba5cc80aaL,
+ 0x03abf59b95a1ef20L, 0xc5a82fc3cfb50234L, 0x0d401229eabb2d39L, 0xb537b249f70bd18aL,
+ 0x1af1b703753fcf4dL, 0xb84648c1945d9ccbL, 0x1d321bea673e1f66L, 0x93d4445b268f305fL,
+ 0xc046cfa36d89a312L, 0x8cc2d55bbf778790L, 0x1d668b0a3d329cc7L, 0x81b6d533dfcf82deL,
+ 0x9ca1c49a18537b16L, 0x68e55c4054e0cb72L, 0x06ed1956cb69afc6L, 0x4871e696449da910L,
+ 0xcfbd7a145066d46eL, 0x10131cb15004b62dL, 0x489c91a322bca3b6L, 0x8ec95fa9bef73e66L,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoShiRo256Plus(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0x894cd8014fa285abL, 0x9737ec9aba91e4b6L, 0xf53b956d74db413aL, 0x6fb0350e20edef6bL,
+ 0x1babe425f938088fL, 0x04f33708a2103773L, 0x03a3f59f511629dfL, 0x9d7323fd9cc8f542L,
+ 0x8df0f8083323117bL, 0x9097a2cc69730c34L, 0x54e01393f7e1c5f6L, 0x14971cb42dce9e33L,
+ 0x6ee4f7da32d287feL, 0x36124f300901b735L, 0x71726514f0341ccaL, 0xbdd6ff5845590a93L,
+ 0x75982d4223903b23L, 0x75e88dbec205937cL, 0x82fa1ef5ed2d3ff5L, 0x49983b880a0758b8L,
+ 0x8d3d74acd90595ccL, 0x1176ea450c32b01fL, 0xfddac8dca767aee0L, 0xbd8226c3f021dcfdL,
+ 0xf95c1aead608a5f9L, 0xc7bd37c9a128d4f2L, 0x8abc94eb440371ceL, 0x4f86410df47f6928L,
+ 0xd2d3479afe5730feL, 0xa7e02f6550aa6668L, 0x5f8b8630e9f5814eL, 0xe8c605350467cdccL,
+ 0xecc91d6be68b5d11L, 0xbe9382f9d9e9e205L, 0xb512c7b80ca731f1L, 0x5125f56b47a89007L,
+ 0x6d98bfd64342222bL, 0x7244f91ff7efc522L, 0xbcf26439fef5555fL, 0xce657c86d81455ceL,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo256Plus(SEED));
}
@Test
@@ -62,16 +76,23 @@ public class XoShiRo256PlusTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoShiRo256Plus(new long[] { 0x012de1babb3c4104L });
+ new XoShiRo256Plus(new long[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- };
- final XoShiRo256Plus rng1 = new XoShiRo256Plus(seed);
- final XoShiRo256Plus rng2 = new XoShiRo256Plus(seed[0], seed[1], seed[2], seed[3]);
- RandomAssert.assertNextLongEquals(seed.length * 2, rng1, rng2);
+ final XoShiRo256Plus rng1 = new XoShiRo256Plus(SEED);
+ final XoShiRo256Plus rng2 = new XoShiRo256Plus(SEED[0], SEED[1], SEED[2], SEED[3]);
+ RandomAssert.assertNextLongEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo256Plus(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoShiRo256Plus(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java
index db6fc72..7aaa19a 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java
@@ -20,33 +20,47 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XoShiRo256StarStarTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 4;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoshiro256starstar.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoshiro256starstar.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
+ };
- final long[] expectedSequence = {
- 0x462c422df780c48eL, 0xa82f1f6031c183e6L, 0x8a113820e8d2ca8dL, 0x1ac7023a26534958L,
- 0xac8e41d0101e109cL, 0x46e34bc13edd63c4L, 0x3a26776adcd665c3L, 0x9ac6c9bea8fc518cL,
- 0x1cef0aa07cc738c4L, 0x5136a5f070244b1dL, 0x12e2e12edee691ffL, 0x28942b20799b71b4L,
- 0xbe2d5c4267af2469L, 0x9dbec53728b2b9b7L, 0x893cf86611b14a96L, 0x712c226c79f066d6L,
- 0x1a8a11ef81d2ac60L, 0x28171739ef8f2f46L, 0x073baa93525f8b1dL, 0xa73c7f3cb93df678L,
- 0xae5633ab977a3531L, 0x25314041ba2d047eL, 0x31e6819dea142672L, 0x9479fa694f4c2965L,
- 0xde5b771a968472b7L, 0xf0501965d9eeb4a3L, 0xef25a2a8ec90b911L, 0x1f58f71a75392659L,
- 0x32d9547188781f3cL, 0x2d13b036ccf65bc0L, 0x289f9cc038dd952fL, 0x6ae2d5231e50824aL,
- 0x75651acfb42ab170L, 0x7369aeb4f10056cfL, 0x0297ed632a97cf75L, 0x19f534c778015b72L,
- 0x5d1d111c5ff182a8L, 0x861cdfe8e8014b96L, 0x07c6071e08112c83L, 0x15601582dcf4e4feL,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0x462c422df780c48eL, 0xa82f1f6031c183e6L, 0x8a113820e8d2ca8dL, 0x1ac7023a26534958L,
+ 0xac8e41d0101e109cL, 0x46e34bc13edd63c4L, 0x3a26776adcd665c3L, 0x9ac6c9bea8fc518cL,
+ 0x1cef0aa07cc738c4L, 0x5136a5f070244b1dL, 0x12e2e12edee691ffL, 0x28942b20799b71b4L,
+ 0xbe2d5c4267af2469L, 0x9dbec53728b2b9b7L, 0x893cf86611b14a96L, 0x712c226c79f066d6L,
+ 0x1a8a11ef81d2ac60L, 0x28171739ef8f2f46L, 0x073baa93525f8b1dL, 0xa73c7f3cb93df678L,
+ 0xae5633ab977a3531L, 0x25314041ba2d047eL, 0x31e6819dea142672L, 0x9479fa694f4c2965L,
+ 0xde5b771a968472b7L, 0xf0501965d9eeb4a3L, 0xef25a2a8ec90b911L, 0x1f58f71a75392659L,
+ 0x32d9547188781f3cL, 0x2d13b036ccf65bc0L, 0x289f9cc038dd952fL, 0x6ae2d5231e50824aL,
+ 0x75651acfb42ab170L, 0x7369aeb4f10056cfL, 0x0297ed632a97cf75L, 0x19f534c778015b72L,
+ 0x5d1d111c5ff182a8L, 0x861cdfe8e8014b96L, 0x07c6071e08112c83L, 0x15601582dcf4e4feL,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoShiRo256StarStar(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0xb416bd07926c6735L, 0x2f91faf5c6c9f79aL, 0x538d25a148318bc1L, 0x79ffea0eb76500e6L,
+ 0x7b74b0513602a5e1L, 0xdc114ef0bb881ac5L, 0xa0845293613f458bL, 0xb650a96e30f09819L,
+ 0xbd2aeb7eb2ac1a6aL, 0x724e2d39d21b00baL, 0x4b38be1deb8553caL, 0xd83f40c399601212L,
+ 0x97aba644588c210aL, 0x5caa9f64a83047b6L, 0x36ade013e70660abL, 0xf1bf69a51790aadaL,
+ 0x4c25aad6aac062ddL, 0x072e1ab91c2ec7c1L, 0x9343a09f5f5eec61L, 0xdcdd0baaaa38bce7L,
+ 0x0c0ea0bcd389f16aL, 0x0765633fee36d533L, 0xfba7f80666c43a76L, 0x896323052d851b9cL,
+ 0x60bdd013e4a0a3f3L, 0x244be4b11b49ca4cL, 0x1513dcbe57a23089L, 0x809e9476dd32f1baL,
+ 0x09e914013550ced8L, 0x68873250d4a070b9L, 0x0c7709d63a915660L, 0x97014b396d121b71L,
+ 0xc50b646fe0f40c95L, 0x4edff941823be25cL, 0x5310e5528d79fa55L, 0xb7353ccef26265e9L,
+ 0x3346bda5d2ac2d7dL, 0xbeab7520abd736f1L, 0x7195e9c9f28eac6aL, 0x64d959048b71d87bL,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo256StarStar(SEED));
}
@Test
@@ -62,16 +76,23 @@ public class XoShiRo256StarStarTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoShiRo256StarStar(new long[] { 0x012de1babb3c4104L });
+ new XoShiRo256StarStar(new long[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- };
- final XoShiRo256StarStar rng1 = new XoShiRo256StarStar(seed);
- final XoShiRo256StarStar rng2 = new XoShiRo256StarStar(seed[0], seed[1], seed[2], seed[3]);
- RandomAssert.assertNextLongEquals(seed.length * 2, rng1, rng2);
+ final XoShiRo256StarStar rng1 = new XoShiRo256StarStar(SEED);
+ final XoShiRo256StarStar rng2 = new XoShiRo256StarStar(SEED[0], SEED[1], SEED[2], SEED[3]);
+ RandomAssert.assertNextLongEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo256StarStar(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoShiRo256StarStar(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java
index 4a798d6..0e505bf 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java
@@ -20,34 +20,48 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XoShiRo512PlusTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 8;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoshiro512plus.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoshiro512plus.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
+ 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
+ };
- final long[] expectedSequence = {
- 0xb252cbe62b5b8a97L, 0xa4aaec677f60aaa2L, 0x1c8bd694b50fd00eL, 0x02753e0294233973L,
- 0xbfec0be86d152e2dL, 0x5b9cd7265f320e98L, 0xf8ec45eccc703724L, 0x83fcbefa0359b3c1L,
- 0xbd27fcdb7e79265dL, 0x88934227d8bf3cf0L, 0x99e1e79384f40371L, 0xe7e7fd0af2014912L,
- 0xebdd19cbcd35745dL, 0x218994e1747243eeL, 0x80628718e5d310daL, 0x88ba1395debd989cL,
- 0x72e025c0928c6f55L, 0x51400eaa050bbb0aL, 0x72542ad3e7fe29e9L, 0x3a3355b9dcb9c8b0L,
- 0x2f6618f3df6126f4L, 0x34307608d886d40fL, 0x34f5a22e98fe3375L, 0x558f6560d08b9ec3L,
- 0xae78928bcb041d6cL, 0xe7afe32a7caf4587L, 0x22dcfb5ca129d4bdL, 0x7c5a41864a6f2cf6L,
- 0xbe1186add0fe46a7L, 0xd019fabc10dc96a5L, 0xafa642ef6837d342L, 0xdc4924811f62cf03L,
- 0xdeb486ccebccf747L, 0xd827b16c9189f637L, 0xf1aab3c3c690a71dL, 0x6551214a7f04a2a5L,
- 0x44b8edb239f2a141L, 0xb840cb37cfbeab59L, 0x0e9558adc0987ca2L, 0xc60442d5ff290606L,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0xb252cbe62b5b8a97L, 0xa4aaec677f60aaa2L, 0x1c8bd694b50fd00eL, 0x02753e0294233973L,
+ 0xbfec0be86d152e2dL, 0x5b9cd7265f320e98L, 0xf8ec45eccc703724L, 0x83fcbefa0359b3c1L,
+ 0xbd27fcdb7e79265dL, 0x88934227d8bf3cf0L, 0x99e1e79384f40371L, 0xe7e7fd0af2014912L,
+ 0xebdd19cbcd35745dL, 0x218994e1747243eeL, 0x80628718e5d310daL, 0x88ba1395debd989cL,
+ 0x72e025c0928c6f55L, 0x51400eaa050bbb0aL, 0x72542ad3e7fe29e9L, 0x3a3355b9dcb9c8b0L,
+ 0x2f6618f3df6126f4L, 0x34307608d886d40fL, 0x34f5a22e98fe3375L, 0x558f6560d08b9ec3L,
+ 0xae78928bcb041d6cL, 0xe7afe32a7caf4587L, 0x22dcfb5ca129d4bdL, 0x7c5a41864a6f2cf6L,
+ 0xbe1186add0fe46a7L, 0xd019fabc10dc96a5L, 0xafa642ef6837d342L, 0xdc4924811f62cf03L,
+ 0xdeb486ccebccf747L, 0xd827b16c9189f637L, 0xf1aab3c3c690a71dL, 0x6551214a7f04a2a5L,
+ 0x44b8edb239f2a141L, 0xb840cb37cfbeab59L, 0x0e9558adc0987ca2L, 0xc60442d5ff290606L,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoShiRo512Plus(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0xda8c2f51c0a12fedL, 0xcc63a107350b8d8bL, 0x3730965c235cdc8bL, 0xdff53b55412bf8d4L,
+ 0xa75dca084c1a404eL, 0x395c5e03c3d51b84L, 0x0c57783cfb429d7bL, 0x402c0857310c0804L,
+ 0x5fb34f057266575aL, 0x196b0694db94ee83L, 0x31ce1b0c4d40a337L, 0x1f21143738a48e84L,
+ 0x4c00bde2f7d7184fL, 0xaad1564500e3b773L, 0xba2729da2d1bb5d7L, 0xcd1e33914dd13ac3L,
+ 0xf98130cc1b0053baL, 0x44eb6a48353a1e5eL, 0x490ae7ce04dfeda3L, 0xb553106ef217b297L,
+ 0xc073ae69eb507d0bL, 0xa056894e1deea79cL, 0xef69db4765dc1479L, 0x8575bf9f4686ab44L,
+ 0x35cbaf0c0fb38f4bL, 0xfa30396425d7f722L, 0x312f12282a479019L, 0x40d7ae6d2b24254eL,
+ 0xa370e089e50b34d6L, 0x5f364b5ae2a36a00L, 0x0a923136b57bb730L, 0x8e46536fce01229cL,
+ 0x3b2c38bc61116bb6L, 0x3f933d48f4a99c53L, 0x6e0b6ef2a27cd0ddL, 0xb53409e3aa42274aL,
+ 0xb0389318ac95388fL, 0x12c69799c7c33350L, 0x7e37dbd8210b480cL, 0xf3ab8bf173c83485L,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo512Plus(SEED));
}
@Test
@@ -63,18 +77,24 @@ public class XoShiRo512PlusTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoShiRo512Plus(new long[] { 0x012de1babb3c4104L });
+ new XoShiRo512Plus(new long[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
- };
- final XoShiRo512Plus rng1 = new XoShiRo512Plus(seed);
- final XoShiRo512Plus rng2 = new XoShiRo512Plus(seed[0], seed[1], seed[2], seed[3],
- seed[4], seed[5], seed[6], seed[7]);
- RandomAssert.assertNextLongEquals(seed.length * 2, rng1, rng2);
+ final XoShiRo512Plus rng1 = new XoShiRo512Plus(SEED);
+ final XoShiRo512Plus rng2 = new XoShiRo512Plus(SEED[0], SEED[1], SEED[2], SEED[3],
+ SEED[4], SEED[5], SEED[6], SEED[7]);
+ RandomAssert.assertNextLongEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo512Plus(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoShiRo512Plus(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java
index 9ec79ee..cbc2082 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java
@@ -20,34 +20,48 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XoShiRo512StarStarTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 8;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xoshiro.di.unimi.it/xoshiro512starstar.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xoshiro.di.unimi.it/xoshiro512starstar.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
+ 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
+ };
- final long[] expectedSequence = {
- 0x462c422df780c48eL, 0xa82f1f6031c183e6L, 0x60559add0e1e369aL, 0xf956a2b900083a8dL,
- 0x0e5c039df1576573L, 0x2f35cef71b14aa24L, 0x5809ea8aa1d5a045L, 0x3e695e3189ccf9bdL,
- 0x1eb940ee4bcb1a08L, 0x78b72a0927bd9257L, 0xe1a8e8d6dc64600bL, 0x3993bff6e1378a4bL,
- 0x439161ee3b5d5cc8L, 0xac6ca2359fe7f321L, 0xc4238c5785d320e2L, 0x75cf64526530aed5L,
- 0x679241ffc120e2b1L, 0xded30a8f20b24c73L, 0xff8ac62cff0deb9bL, 0xe63a25973df23c45L,
- 0x74742f9096c56401L, 0xc573afa2368288acL, 0x9b1048cf2daf9f9dL, 0xe7d9720c2f51ca5fL,
- 0x38a21e1f7a441cedL, 0x78835d75a9bd17a6L, 0xeb64167a723de35fL, 0x9455dd663e40620cL,
- 0x88693a769f203ed1L, 0xea5f0997a281cffcL, 0x2662b83f835f3273L, 0x5e90efde2150ed04L,
- 0xd481b14551c8f8d9L, 0xf2e4d714a0ab22d7L, 0xdfb1a8f0637a2013L, 0x8cd8d8c353640028L,
- 0xb4ce3b66785e0cc6L, 0xa51386e09b6ab734L, 0xfeac4151ac4a3f8dL, 0x0e5679853ab5180bL,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0x462c422df780c48eL, 0xa82f1f6031c183e6L, 0x60559add0e1e369aL, 0xf956a2b900083a8dL,
+ 0x0e5c039df1576573L, 0x2f35cef71b14aa24L, 0x5809ea8aa1d5a045L, 0x3e695e3189ccf9bdL,
+ 0x1eb940ee4bcb1a08L, 0x78b72a0927bd9257L, 0xe1a8e8d6dc64600bL, 0x3993bff6e1378a4bL,
+ 0x439161ee3b5d5cc8L, 0xac6ca2359fe7f321L, 0xc4238c5785d320e2L, 0x75cf64526530aed5L,
+ 0x679241ffc120e2b1L, 0xded30a8f20b24c73L, 0xff8ac62cff0deb9bL, 0xe63a25973df23c45L,
+ 0x74742f9096c56401L, 0xc573afa2368288acL, 0x9b1048cf2daf9f9dL, 0xe7d9720c2f51ca5fL,
+ 0x38a21e1f7a441cedL, 0x78835d75a9bd17a6L, 0xeb64167a723de35fL, 0x9455dd663e40620cL,
+ 0x88693a769f203ed1L, 0xea5f0997a281cffcL, 0x2662b83f835f3273L, 0x5e90efde2150ed04L,
+ 0xd481b14551c8f8d9L, 0xf2e4d714a0ab22d7L, 0xdfb1a8f0637a2013L, 0x8cd8d8c353640028L,
+ 0xb4ce3b66785e0cc6L, 0xa51386e09b6ab734L, 0xfeac4151ac4a3f8dL, 0x0e5679853ab5180bL,
+ };
- RandomAssert.assertEquals(expectedSequence, new XoShiRo512StarStar(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0x49738e6a1dc6cfe4L, 0x20d43df324825b53L, 0x901311368abdf6ffL, 0x5b6a89ae30e497cfL,
+ 0xf39563a09132cd18L, 0x31617c165823312dL, 0xf661249f2e13379aL, 0x83182e7f15ea1d74L,
+ 0x2138679c77623fe3L, 0x659ea7f79918b8edL, 0x95d1cd36efefe94aL, 0xdca9a32638633311L,
+ 0x29e61a381e2d6cd7L, 0xe77e58a6f50d890eL, 0x2bd956f2c3efb142L, 0xf7ac562caac34825L,
+ 0x211db4255861df4bL, 0x0631b9f14d2c23f5L, 0x3fd2f6b40055cee4L, 0x07303eb9aba24a7bL,
+ 0x3edb03a893e24a16L, 0x82d9065956477f0aL, 0x4ff3574b1ae46dd4L, 0xaaf0f48c44668055L,
+ 0x2e778b8218a3fe10L, 0xe29fe50ff75a3fd4L, 0x5ab758438572ba1cL, 0x94bb2aca7d056186L,
+ 0x7699c4588a722dc4L, 0x131fd3c8d477a06aL, 0xc87f6eb21f8d91b8L, 0x5a273a9c0a89e24fL,
+ 0xa4466c28e147be23L, 0x877e97af45d42bbcL, 0x07f0c9e5e1fb133fL, 0x3a2f2422d2a9af03L,
+ 0x2f1f49ee5e1d5207L, 0xafca316bd4672318L, 0x91e9df4fe8cb3cddL, 0x8857a767c3a1d387L,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo512StarStar(SEED));
}
@Test
@@ -63,18 +77,24 @@ public class XoShiRo512StarStarTest {
@Test
public void testConstructorWithoutFullLengthSeed() {
// Hit the case when the input seed is self-seeded when not full length
- new XoShiRo512StarStar(new long[] { 0x012de1babb3c4104L });
+ new XoShiRo512StarStar(new long[] {SEED[0]});
}
@Test
public void testElementConstructor() {
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
- };
- final XoShiRo512StarStar rng1 = new XoShiRo512StarStar(seed);
- final XoShiRo512StarStar rng2 = new XoShiRo512StarStar(seed[0], seed[1], seed[2], seed[3],
- seed[4], seed[5], seed[6], seed[7]);
- RandomAssert.assertNextLongEquals(seed.length * 2, rng1, rng2);
+ final XoShiRo512StarStar rng1 = new XoShiRo512StarStar(SEED);
+ final XoShiRo512StarStar rng2 = new XoShiRo512StarStar(SEED[0], SEED[1], SEED[2], SEED[3],
+ SEED[4], SEED[5], SEED[6], SEED[7]);
+ RandomAssert.assertNextLongEquals(SEED.length * 2, rng1, rng2);
+ }
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo512StarStar(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XoShiRo512StarStar(SEED));
}
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java
index 988ece4..ba0ce99 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java
@@ -20,36 +20,50 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XorShift1024StarPhiTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 16;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xorshift.di.unimi.it/xorshift1024star.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
- 0x7bf121347c06677fL, 0x4fd0c88d25db5ccbL, 0x99af3be9ebe0a272L, 0x94f2b33b74d0bdcbL,
- 0x24b5d9d7a00a3140L, 0x79d983d781a34a3cL, 0x582e4a84d595f5ecL, 0x7316fe8b0f606d20L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xorshift.di.unimi.it/xorshift1024star.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
+ 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
+ 0x7bf121347c06677fL, 0x4fd0c88d25db5ccbL, 0x99af3be9ebe0a272L, 0x94f2b33b74d0bdcbL,
+ 0x24b5d9d7a00a3140L, 0x79d983d781a34a3cL, 0x582e4a84d595f5ecL, 0x7316fe8b0f606d20L,
+ };
- final long[] expectedSequence = {
- 0xc9351be6ae9af4bbL, 0x2696a1a51e3040cbL, 0xdcbbc38b838b4be8L, 0xc989eee03351a25cL,
- 0xc4ad829b653ada72L, 0x1cff4000cc0118dfL, 0x988f3aaf7bfb2852L, 0x3a621d4d5fb27bf2L,
- 0x0153d81cf33ff4a7L, 0x8a1b5adb974750c1L, 0x182799e238df6de2L, 0x92d9bda951cd6377L,
- 0x601f077d2a659728L, 0x90536cc64ad5bc49L, 0x5d99d9e84e3d7fa9L, 0xfc66f4610240613aL,
- 0x0ff67da640cdd6b6L, 0x973c7a6afbb41751L, 0x5089cb5236ac1b5bL, 0x7ed6edc1e4d7e261L,
- 0x3e37630df0c00b63L, 0x49ec234a0d03bcc4L, 0x2bcbe2fa4b80fa33L, 0xbaafc47b960baefaL,
- 0x1855fa47be98c84fL, 0x8d59cb57e34a73e0L, 0x256b15bb001bf641L, 0x28ad378895f5615dL,
- 0x865547335ba2a571L, 0xfefe4c356e154585L, 0xeb87f7a74e076680L, 0x990d2f5d1e60b914L,
- 0x3bf0f6864688af2fL, 0x8c6304df9b945d58L, 0x63bc09c335b63666L, 0x1038139f53734ad2L,
- 0xf41b58faf5680868L, 0xa50ba830813c163bL, 0x7dc1ca503ae39817L, 0xea3d0f2f37f5ce95L,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0xc9351be6ae9af4bbL, 0x2696a1a51e3040cbL, 0xdcbbc38b838b4be8L, 0xc989eee03351a25cL,
+ 0xc4ad829b653ada72L, 0x1cff4000cc0118dfL, 0x988f3aaf7bfb2852L, 0x3a621d4d5fb27bf2L,
+ 0x0153d81cf33ff4a7L, 0x8a1b5adb974750c1L, 0x182799e238df6de2L, 0x92d9bda951cd6377L,
+ 0x601f077d2a659728L, 0x90536cc64ad5bc49L, 0x5d99d9e84e3d7fa9L, 0xfc66f4610240613aL,
+ 0x0ff67da640cdd6b6L, 0x973c7a6afbb41751L, 0x5089cb5236ac1b5bL, 0x7ed6edc1e4d7e261L,
+ 0x3e37630df0c00b63L, 0x49ec234a0d03bcc4L, 0x2bcbe2fa4b80fa33L, 0xbaafc47b960baefaL,
+ 0x1855fa47be98c84fL, 0x8d59cb57e34a73e0L, 0x256b15bb001bf641L, 0x28ad378895f5615dL,
+ 0x865547335ba2a571L, 0xfefe4c356e154585L, 0xeb87f7a74e076680L, 0x990d2f5d1e60b914L,
+ 0x3bf0f6864688af2fL, 0x8c6304df9b945d58L, 0x63bc09c335b63666L, 0x1038139f53734ad2L,
+ 0xf41b58faf5680868L, 0xa50ba830813c163bL, 0x7dc1ca503ae39817L, 0xea3d0f2f37f5ce95L,
+ };
- RandomAssert.assertEquals(expectedSequence, new XorShift1024StarPhi(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0x07afdab6d38bddd2L, 0x7bb8f1495d6aaa58L, 0x00f583e9eb57bf12L, 0x694e972ba626f7b6L,
+ 0x0f7017b991b531dbL, 0x702fc8e6791b530cL, 0xf62322eab2db2526L, 0xe6bdc2cffeeae3ffL,
+ 0xa0cb7cb78c2e3918L, 0x53fa4d1ee744ee74L, 0x5f0bcdebaf4b4af0L, 0xec23017af16e9040L,
+ 0x2d1119530d4f4e06L, 0x75b721c9942eea60L, 0x6aab166dbc9d553bL, 0xcfa59b433d647154L,
+ 0x687a4f5aa4bfd161L, 0xcc954692756486f1L, 0xcfa57a42ae5e8285L, 0xe290ecfae5d74436L,
+ 0x0adb47de60db796fL, 0xee4e161668406ee0L, 0xe7f5beb82ec63004L, 0x5ee1ed818be7d7c0L,
+ 0xb1aa1517d646c3c3L, 0x31ab29451adf8b7dL, 0x2612a880abf60efdL, 0xa7679f88450d8d9cL,
+ 0xee3b07f323a85a69L, 0xac7e0039bb81e9a5L, 0x5b454710e237ab6dL, 0xdd6c4ac09653d161L,
+ 0xc03e09a39f5e8c24L, 0x4a8352f76f7c3e94L, 0xebeb6e56c67fc377L, 0x3726d52cb3cda75bL,
+ 0x3f6c00e368b97361L, 0xc49b806ba04c8ef4L, 0xf396608b186fdf27L, 0xe0c7f13ba319779fL,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XorShift1024StarPhi(SEED));
}
@Test
@@ -61,4 +75,14 @@ public class XorShift1024StarPhiTest {
public void testConstructorWithSingleBitSeedIsFunctional() {
RandomAssert.assertLongArrayConstructorWithSingleBitSeedIsFunctional(XorShift1024StarPhi.class, SEED_SIZE);
}
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XorShift1024StarPhi(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XorShift1024StarPhi(SEED));
+ }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java
index 10a8e1d..69367f7 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java
@@ -20,36 +20,50 @@ import org.apache.commons.rng.core.RandomAssert;
import org.junit.Test;
public class XorShift1024StarTest {
- /** The size of the array seed. */
+ /** The size of the array SEED. */
private static final int SEED_SIZE = 16;
- @Test
- public void testReferenceCode() {
- /*
- * Data from running the executable compiled from the author's C code:
- * http://xorshift.di.unimi.it/xorshift1024star.c
- */
- final long[] seed = {
- 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
- 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
- 0x7bf121347c06677fL, 0x4fd0c88d25db5ccbL, 0x99af3be9ebe0a272L, 0x94f2b33b74d0bdcbL,
- 0x24b5d9d7a00a3140L, 0x79d983d781a34a3cL, 0x582e4a84d595f5ecL, 0x7316fe8b0f606d20L,
- };
+ /*
+ * Data from running the executable compiled from the author's C code:
+ * http://xorshift.di.unimi.it/xorshift1024star.c
+ */
+
+ private static final long[] SEED = {
+ 0x012de1babb3c4104L, 0xa5a818b8fc5aa503L, 0xb124ea2b701f4993L, 0x18e0374933d8c782L,
+ 0x2af8df668d68ad55L, 0x76e56f59daa06243L, 0xf58c016f0f01e30fL, 0x8eeafa41683dbbf4L,
+ 0x7bf121347c06677fL, 0x4fd0c88d25db5ccbL, 0x99af3be9ebe0a272L, 0x94f2b33b74d0bdcbL,
+ 0x24b5d9d7a00a3140L, 0x79d983d781a34a3cL, 0x582e4a84d595f5ecL, 0x7316fe8b0f606d20L,
+ };
- final long[] expectedSequence = {
- 0xd85e9fc0855614cdL, 0xaf4965c9c1ac6a3dL, 0x067da398791111d8L, 0x2771c41db58d7644L,
- 0xf71a471e1ac2b03eL, 0x953449ae275f7409L, 0x8aa570c72de0af5eL, 0xae59db2acdae32beL,
- 0x3d46f316b8f97301L, 0x72dc8399b7a70957L, 0xf5624d788b3b6f4eL, 0xb7a79275f6c0e7b1L,
- 0xf79354208377d498L, 0x0e5d2f2ac2b4f28fL, 0x0f8f57edc8aa802fL, 0x5e918ea72ece0c36L,
- 0xeeb8dbdb00ac7a5aL, 0xf16f88dfef0d6047L, 0x1244c29e0e0d8d2dL, 0xaa94f1cc42691eb7L,
- 0xd06425dd329e5de5L, 0x968b1c2e016f159cL, 0x6aadff7055065295L, 0x3bce2efcb0d00876L,
- 0xb28d5b69ad8fb719L, 0x1e4040c451376920L, 0x6b0801a8a00de7d7L, 0x891ba2cbe2a4675bL,
- 0x6355008481852527L, 0x7a47bcd9960126f3L, 0x07f72fcd4ebe3580L, 0x4658b29c126840ccL,
- 0xdc7b36d3037c7539L, 0x9e30aab0410122e8L, 0x7215126e0fce932aL, 0xda63f12a489fc8deL,
- 0x769997671b2a0158L, 0xfa9cd84e0ffc174dL, 0x34df1cd959dca211L, 0xccea41a33ec1f763L,
- };
+ private static final long[] EXPECTED_SEQUENCE = {
+ 0xd85e9fc0855614cdL, 0xaf4965c9c1ac6a3dL, 0x067da398791111d8L, 0x2771c41db58d7644L,
+ 0xf71a471e1ac2b03eL, 0x953449ae275f7409L, 0x8aa570c72de0af5eL, 0xae59db2acdae32beL,
+ 0x3d46f316b8f97301L, 0x72dc8399b7a70957L, 0xf5624d788b3b6f4eL, 0xb7a79275f6c0e7b1L,
+ 0xf79354208377d498L, 0x0e5d2f2ac2b4f28fL, 0x0f8f57edc8aa802fL, 0x5e918ea72ece0c36L,
+ 0xeeb8dbdb00ac7a5aL, 0xf16f88dfef0d6047L, 0x1244c29e0e0d8d2dL, 0xaa94f1cc42691eb7L,
+ 0xd06425dd329e5de5L, 0x968b1c2e016f159cL, 0x6aadff7055065295L, 0x3bce2efcb0d00876L,
+ 0xb28d5b69ad8fb719L, 0x1e4040c451376920L, 0x6b0801a8a00de7d7L, 0x891ba2cbe2a4675bL,
+ 0x6355008481852527L, 0x7a47bcd9960126f3L, 0x07f72fcd4ebe3580L, 0x4658b29c126840ccL,
+ 0xdc7b36d3037c7539L, 0x9e30aab0410122e8L, 0x7215126e0fce932aL, 0xda63f12a489fc8deL,
+ 0x769997671b2a0158L, 0xfa9cd84e0ffc174dL, 0x34df1cd959dca211L, 0xccea41a33ec1f763L,
+ };
- RandomAssert.assertEquals(expectedSequence, new XorShift1024Star(seed));
+ private static final long[] EXPECTED_SEQUENCE_AFTER_JUMP = {
+ 0x65d54201f5acfddeL, 0x6fde36eb1f6a0de8L, 0x4bb549d952f83a9eL, 0x8a450adce576715aL,
+ 0xb031eca9597292adL, 0xf37e0e06b835d614L, 0x26bfeba6b6a6066aL, 0xd3e5bc247e11b3e9L,
+ 0x17efb0eaa881e128L, 0x17b53d5adf9c0c6cL, 0xcf40e97397cf3b90L, 0xaa9c9cc35ba0f5c0L,
+ 0x531285c99a04b28aL, 0x868bac37b6520ea0L, 0x8532f89936f0c04dL, 0x46d686a34dafce8cL,
+ 0xca15a5750af797b7L, 0x83cc94eb061c67a7L, 0xea90f3d41c3da1f3L, 0x18b74852ce1150daL,
+ 0x193e6b8e68eea0f9L, 0x6ac72b7aa768f620L, 0xf302fae8b5f1705cL, 0x7cfbedcfa8626240L,
+ 0x46a5a5fb00c3ee85L, 0xde6d0648b997303bL, 0x56ae91e7655900bbL, 0xab5031aa9f399904L,
+ 0x8a97889ade2a276fL, 0x1b9faa106ffce5d3L, 0xab648350c8f58ecbL, 0x713bfb795f4397b7L,
+ 0x2935361aa09ab73cL, 0xb5b425a0382d3f4cL, 0x8253cb35cdc787b1L, 0x9bad73436171212dL,
+ 0x1d9c3fd0fcf525b7L, 0x5c0b302408af77ecL, 0x8e92e2d9a37b8481L, 0x8f3c06c39295f749L,
+ };
+
+ @Test
+ public void testReferenceCode() {
+ RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XorShift1024Star(SEED));
}
@Test
@@ -61,4 +75,14 @@ public class XorShift1024StarTest {
public void testConstructorWithSingleBitSeedIsFunctional() {
RandomAssert.assertLongArrayConstructorWithSingleBitSeedIsFunctional(XorShift1024Star.class, SEED_SIZE);
}
+
+ @Test
+ public void testJump() {
+ RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XorShift1024Star(SEED));
+ }
+
+ @Test
+ public void testJumpUsingState() {
+ RandomAssert.assertJumpUsingState(new XorShift1024Star(SEED));
+ }
}
[commons-rng] 03/06: RNG-97: Move common tests to
JumpableProvidersParametricTest.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git
commit c030d858076cc106213831cb8361d1f342bf26a2
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 10 12:46:41 2019 +0100
RNG-97: Move common tests to JumpableProvidersParametricTest.
Add test that the default state in IntProvider and LongProvider is reset
after a jump.
---
.../rng/core/JumpableProvidersParametricTest.java | 209 +++++++++++++++++++++
.../org/apache/commons/rng/core/ProvidersList.java | 29 +++
.../org/apache/commons/rng/core/RandomAssert.java | 43 -----
.../rng/core/source32/XoShiRo128PlusTest.java | 5 -
.../rng/core/source32/XoShiRo128StarStarTest.java | 5 -
.../rng/core/source64/XoRoShiRo128PlusTest.java | 5 -
.../core/source64/XoRoShiRo128StarStarTest.java | 5 -
.../rng/core/source64/XoShiRo256PlusTest.java | 5 -
.../rng/core/source64/XoShiRo256StarStarTest.java | 5 -
.../rng/core/source64/XoShiRo512PlusTest.java | 5 -
.../rng/core/source64/XoShiRo512StarStarTest.java | 5 -
.../rng/core/source64/XorShift1024StarPhiTest.java | 5 -
.../rng/core/source64/XorShift1024StarTest.java | 5 -
13 files changed, 238 insertions(+), 93 deletions(-)
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/JumpableProvidersParametricTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/JumpableProvidersParametricTest.java
new file mode 100644
index 0000000..ec517e6
--- /dev/null
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/JumpableProvidersParametricTest.java
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.rng.core;
+
+import org.junit.Assert;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import java.util.Arrays;
+
+import org.apache.commons.rng.JumpableUniformRandomProvider;
+import org.apache.commons.rng.RandomProviderState;
+import org.apache.commons.rng.RestorableUniformRandomProvider;
+import org.apache.commons.rng.UniformRandomProvider;
+import org.apache.commons.rng.core.source32.IntProvider;
+import org.apache.commons.rng.core.source64.LongProvider;
+
+/**
+ * Tests which all {@link JumpableUniformRandomProvider} generators must pass.
+ */
+@RunWith(value = Parameterized.class)
+public class JumpableProvidersParametricTest {
+ /** The size of the state for the IntProvider. */
+ private static final int intProviderStateSize;
+ /** The size of the state for the LongProvider. */
+ private static final int longProviderStateSize;
+
+ static {
+ intProviderStateSize = new State32Generator().getStateSize();
+ longProviderStateSize = new State64Generator().getStateSize();
+ }
+
+ /** RNG under test. */
+ private final JumpableUniformRandomProvider generator;
+
+ /**
+ * Initializes generator instance.
+ *
+ * @param rng RNG to be tested.
+ */
+ public JumpableProvidersParametricTest(JumpableUniformRandomProvider rng) {
+ generator = rng;
+ }
+
+ /**
+ * Gets the list of Jumpable generators.
+ *
+ * @return the list
+ */
+ @Parameters(name = "{index}: data={0}")
+ public static Iterable<JumpableUniformRandomProvider[]> getList() {
+ return ProvidersList.listJumpable();
+ }
+
+ /**
+ * Test that the random generator returned from the jump is a new instance of the same class.
+ */
+ @Test
+ public void testJumpReturnsACopy() {
+ final UniformRandomProvider copy = generator.jump();
+ Assert.assertNotSame("The copy instance should be a different object", generator, copy);
+ Assert.assertEquals("The copy instance should be the same class", generator.getClass(), copy.getClass());
+ }
+
+ /**
+ * Test that the random generator state of the copy instance returned from the jump
+ * function matches the input state.
+ *
+ * <p>The generator must be a {@link RestorableUniformRandomProvider} and return an
+ * instance of {@link RandomProviderDefaultState}.</p>
+ *
+ * <p>The input generator is sampled using methods in the
+ * {@link UniformRandomProvider} interface, the state is saved and a jump is
+ * performed. The states from the pre-jump generator and the returned copy instance
+ * must match.</p>
+ *
+ * <p>This test targets any cached state of the default implementation of a generator
+ * in {@link IntProvider} and {@link LongProvider} such as the state cached for the
+ * nextBoolean() and nextInt() functions.</p>
+ */
+ @Test
+ public void testJumpCopyMatchesPreJumpState() {
+ Assume.assumeTrue("Not a restorable RNG", generator instanceof RestorableUniformRandomProvider);
+
+ for (int repeats = 0; repeats < 2; repeats++) {
+ // Exercise the generator.
+ // This calls nextInt() once so the default implementation of LongProvider
+ // should have cached a state for nextInt() in one of the two repeats.
+ // Calls nextBoolean() to ensure a cached state in one of the two repeats.
+ generator.nextInt();
+ generator.nextBoolean();
+
+ final RandomProviderState preJumpState = ((RestorableUniformRandomProvider) generator).saveState();
+ Assume.assumeTrue("Not a recognised state", preJumpState instanceof RandomProviderDefaultState);
+
+ final UniformRandomProvider copy = generator.jump();
+
+ final RandomProviderState copyState = ((RestorableUniformRandomProvider) copy).saveState();
+ final RandomProviderDefaultState expected = (RandomProviderDefaultState) preJumpState;
+ final RandomProviderDefaultState actual = (RandomProviderDefaultState) copyState;
+ Assert.assertArrayEquals("The copy instance state should match the state of the original",
+ expected.getState(), actual.getState());
+ }
+ }
+
+ /**
+ * Test that a jump resets the state of the default implementation of a generator in
+ * {@link IntProvider} and {@link LongProvider}.
+ */
+ @Test
+ public void testJumpResetsDefaultState() {
+ if (generator instanceof IntProvider) {
+ assertJumpResetsDefaultState(intProviderStateSize);
+ } else if (generator instanceof LongProvider) {
+ assertJumpResetsDefaultState(longProviderStateSize);
+ }
+ }
+
+ /**
+ * Assert the jump resets the specified number of bytes of the state. The bytes are
+ * checked from the end of the saved state.
+ *
+ * <p>This is intended to check the default state of the base implementation of
+ * {@link IntProvider} and {@link LongProvider} is reset.</p>
+ *
+ * @param stateSize the state size
+ */
+ private void assertJumpResetsDefaultState(int stateSize) {
+ final byte[] expected = new byte[stateSize];
+ for (int repeats = 0; repeats < 2; repeats++) {
+ // Exercise the generator.
+ // This calls nextInt() once so the default implementation of LongProvider
+ // should have cached a state for nextInt() in one of the two repeats.
+ // Calls nextBoolean() to ensure a cached state in one of the two repeats.
+ generator.nextInt();
+ generator.nextBoolean();
+
+ generator.jump();
+
+ // An Int/LongProvider so must be a RestorableUniformRandomProvider
+ final RandomProviderState postJumpState = ((RestorableUniformRandomProvider) generator).saveState();
+ final byte[] actual = ((RandomProviderDefaultState) postJumpState).getState();
+
+ Assume.assumeTrue("Implementation has removed default state", actual.length >= stateSize);
+
+ // The implementation requires that any sub-class state is prepended to the
+ // state thus the default state is at the end.
+ final byte[] defaultState = Arrays.copyOfRange(actual, actual.length - stateSize, actual.length);
+ Assert.assertArrayEquals("The jump should reset the default state to zero", expected, defaultState);
+ }
+ }
+
+ /**
+ * Dummy class for checking the state size of the IntProvider.
+ */
+ static class State32Generator extends IntProvider {
+ /** {@inheritDoc} */
+ @Override
+ public int next() {
+ return 0;
+ }
+
+ /**
+ * Gets the state size. This captures the state size of the IntProvider.
+ *
+ * @return the state size
+ */
+ int getStateSize() {
+ return getStateInternal().length;
+ }
+ }
+
+ /**
+ * Dummy class for checking the state size of the LongProvider.
+ */
+ static class State64Generator extends LongProvider {
+ /** {@inheritDoc} */
+ @Override
+ public long next() {
+ return 0;
+ }
+
+ /**
+ * Gets the state size. This captures the state size of the LongProvider.
+ *
+ * @return the state size
+ */
+ int getStateSize() {
+ return getStateInternal().length;
+ }
+ }
+}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/ProvidersList.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/ProvidersList.java
index de58d21..163fd09 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/ProvidersList.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/ProvidersList.java
@@ -47,6 +47,7 @@ import org.apache.commons.rng.core.source64.XoShiRo256StarStar;
import org.apache.commons.rng.core.source64.XoShiRo512Plus;
import org.apache.commons.rng.core.source64.XoShiRo512StarStar;
import org.apache.commons.rng.core.source64.MersenneTwister64;
+import org.apache.commons.rng.JumpableUniformRandomProvider;
import org.apache.commons.rng.RestorableUniformRandomProvider;
/**
@@ -68,6 +69,9 @@ public class ProvidersList {
/** List of 64-bits based RNGs. */
private static final List<RestorableUniformRandomProvider[]> LIST64 =
new ArrayList<RestorableUniformRandomProvider[]>();
+ /** List of {@link JumpableUniformRandomProvider} RNGs. */
+ private static final List<JumpableUniformRandomProvider[]> LIST_JUMP =
+ new ArrayList<JumpableUniformRandomProvider[]>();
static {
// External generator for creating a random seed.
@@ -111,6 +115,12 @@ public class ProvidersList {
// Complete list.
LIST.addAll(LIST32);
LIST.addAll(LIST64);
+ // Dynamically identify the Jumpable RNGs
+ for (RestorableUniformRandomProvider[] rng : LIST) {
+ if (rng[0] instanceof JumpableUniformRandomProvider) {
+ add(LIST_JUMP, (JumpableUniformRandomProvider) rng[0]);
+ }
+ }
} catch (Exception e) {
System.err.println("Unexpected exception while creating the list of generators: " + e);
e.printStackTrace(System.err);
@@ -133,6 +143,15 @@ public class ProvidersList {
}
/**
+ * Helper to statisfy Junit requirement that each parameter set contains
+ * the same number of objects.
+ */
+ private static void add(List<JumpableUniformRandomProvider[]> list,
+ JumpableUniformRandomProvider rng) {
+ list.add(new JumpableUniformRandomProvider[] { rng });
+ }
+
+ /**
* Subclasses that are "parametric" tests can forward the call to
* the "@Parameters"-annotated method to this method.
*
@@ -161,4 +180,14 @@ public class ProvidersList {
public static Iterable<RestorableUniformRandomProvider[]> list64() {
return Collections.unmodifiableList(LIST64);
}
+
+ /**
+ * Subclasses that are "parametric" tests can forward the call to
+ * the "@Parameters"-annotated method to this method.
+ *
+ * @return the list of {@link JumpableUniformRandomProvider} generators.
+ */
+ public static Iterable<JumpableUniformRandomProvider[]> listJumpable() {
+ return Collections.unmodifiableList(LIST_JUMP);
+ }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java
index 2eb409f..b3743ce 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/RandomAssert.java
@@ -135,49 +135,6 @@ public class RandomAssert {
}
/**
- * Assert that the random generator state of the copy instance returned from the
- * jump function matches the input state.
- *
- * <p>The generator must be a {@link RestorableUniformRandomProvider} and return
- * an instance of {@link RandomProviderDefaultState}.</p>
- *
- * <p>The input generator is sampled using methods in the
- * {@link UniformRandomProvider} interface, the state is saved and a jump is
- * performed. The states from the pre-jump generator and the returned copy
- * instance must match.</p>
- *
- * <p>This test targets any cached state of the default implementation of a generator
- * in {@link org.apache.commons.rng.core.source32.IntProvider IntProvider} and
- * {@link org.apache.commons.rng.core.source64.LongProvider LongProvider}
- * such as the state cached for the nextBoolean() and nextInt() functions.</p>
- *
- * @param rng Random generator.
- */
- public static void assertJumpUsingState(JumpableUniformRandomProvider rng) {
- Assume.assumeTrue("Not a restorable RNG", rng instanceof RestorableUniformRandomProvider);
-
- // Exercise the generator.
- // This calls nextInt() an odd number of times so the default
- // implementation of LongProvider should have cached a state for nextInt().
- for (int i = 0; i < 3; i++) {
- rng.nextInt();
- rng.nextLong();
- rng.nextBoolean();
- }
-
- final RandomProviderState preJumpState = ((RestorableUniformRandomProvider) rng).saveState();
- Assume.assumeTrue("Not a recognised state", preJumpState instanceof RandomProviderDefaultState);
-
- final UniformRandomProvider copy = rng.jump();
- Assert.assertNotSame("The copy instance should be a different object", rng, copy);
-
- final RandomProviderState copyState = ((RestorableUniformRandomProvider)copy).saveState();
- final RandomProviderDefaultState expected = (RandomProviderDefaultState) preJumpState;
- final RandomProviderDefaultState actual = (RandomProviderDefaultState) copyState;
- Assert.assertArrayEquals(expected.getState(), actual.getState());
- }
-
- /**
* Assert that the two random generators produce the same output for
* {@link UniformRandomProvider#nextInt()} over the given number of cycles.
*
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java
index 4fad812..80dd21e 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128PlusTest.java
@@ -90,9 +90,4 @@ public class XoShiRo128PlusTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo128Plus(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoShiRo128Plus(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java
index 485bcd3..bd5b6ab 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source32/XoShiRo128StarStarTest.java
@@ -90,9 +90,4 @@ public class XoShiRo128StarStarTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP , new XoShiRo128StarStar(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoShiRo128StarStar(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java
index 0dc5666..2b27694 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java
@@ -90,9 +90,4 @@ public class XoRoShiRo128PlusTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoRoShiRo128Plus(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoRoShiRo128Plus(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java
index 9c6df2c..776e1a6 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128StarStarTest.java
@@ -90,9 +90,4 @@ public class XoRoShiRo128StarStarTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoRoShiRo128StarStar(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoRoShiRo128StarStar(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java
index fc99ec2..a61eda9 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256PlusTest.java
@@ -90,9 +90,4 @@ public class XoShiRo256PlusTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo256Plus(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoShiRo256Plus(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java
index 7aaa19a..c4c6e55 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo256StarStarTest.java
@@ -90,9 +90,4 @@ public class XoShiRo256StarStarTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo256StarStar(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoShiRo256StarStar(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java
index 0e505bf..448065d 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512PlusTest.java
@@ -92,9 +92,4 @@ public class XoShiRo512PlusTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo512Plus(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoShiRo512Plus(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java
index cbc2082..d472312 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoShiRo512StarStarTest.java
@@ -92,9 +92,4 @@ public class XoShiRo512StarStarTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo512StarStar(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XoShiRo512StarStar(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java
index ba0ce99..f9a1fce 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarPhiTest.java
@@ -80,9 +80,4 @@ public class XorShift1024StarPhiTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XorShift1024StarPhi(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XorShift1024StarPhi(SEED));
- }
}
diff --git a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java
index 69367f7..5aa4b04 100644
--- a/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java
+++ b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XorShift1024StarTest.java
@@ -80,9 +80,4 @@ public class XorShift1024StarTest {
public void testJump() {
RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XorShift1024Star(SEED));
}
-
- @Test
- public void testJumpUsingState() {
- RandomAssert.assertJumpUsingState(new XorShift1024Star(SEED));
- }
}
[commons-rng] 01/06: RNG-97: Define the
JumpableUniformRandomProvider interface.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git
commit b05d7552a869a3aecb6c53c9579ea673de989284
Author: Alex Herbert <ah...@apache.org>
AuthorDate: Sun Jun 9 13:37:37 2019 +0100
RNG-97: Define the JumpableUniformRandomProvider interface.
---
.../commons/rng/JumpableUniformRandomProvider.java | 41 ++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java b/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java
new file mode 100644
index 0000000..59646d8
--- /dev/null
+++ b/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.rng;
+
+/**
+ * Applies to generators that can be advanced a large number of
+ * steps of the output sequence in a single operation.
+ *
+ * @since 1.3
+ */
+public interface JumpableUniformRandomProvider extends UniformRandomProvider {
+ /**
+ * Creates a copy of the UniformRandomProvider and then advances the
+ * state of the current instance. The copy is returned.
+ *
+ * <p>The current state will be advanced in a single operation by the equivalent of a
+ * number of sequential calls to a method that updates the state of the provider. The
+ * size of the jump is implementation-dependent.</p>
+ *
+ * <p>Repeat invocations of this method will create a series of generators
+ * that are uniformly spaced at intervals of the output sequence. Each generator provides
+ * non-overlapping output for the length of the jump for use in parallel computations.</p>
+ *
+ * @return A copy of the current state.
+ */
+ UniformRandomProvider jump();
+}
[commons-rng] 04/06: Merge branch 'feature-RNG-97'
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git
commit 28c4f4140f5c0458371aae0e82cdab88a3fd6c0f
Merge: b95eed5 c030d85
Author: Alex Herbert <ah...@apache.org>
AuthorDate: Mon Jun 10 20:54:36 2019 +0100
Merge branch 'feature-RNG-97'
.../commons/rng/JumpableUniformRandomProvider.java | 41 ++++
.../rng/core/source32/AbstractXoShiRo128.java | 68 ++++++-
.../commons/rng/core/source32/IntProvider.java | 33 ++++
.../commons/rng/core/source32/XoShiRo128Plus.java | 21 +++
.../rng/core/source32/XoShiRo128StarStar.java | 21 +++
.../rng/core/source64/AbstractXoRoShiRo128.java | 62 +++++-
.../rng/core/source64/AbstractXoShiRo256.java | 70 ++++++-
.../rng/core/source64/AbstractXoShiRo512.java | 87 ++++++++-
.../commons/rng/core/source64/LongProvider.java | 38 ++++
.../rng/core/source64/XoRoShiRo128Plus.java | 21 +++
.../rng/core/source64/XoRoShiRo128StarStar.java | 21 +++
.../commons/rng/core/source64/XoShiRo256Plus.java | 21 +++
.../rng/core/source64/XoShiRo256StarStar.java | 21 +++
.../commons/rng/core/source64/XoShiRo512Plus.java | 21 +++
.../rng/core/source64/XoShiRo512StarStar.java | 21 +++
.../rng/core/source64/XorShift1024Star.java | 70 ++++++-
.../rng/core/source64/XorShift1024StarPhi.java | 17 ++
.../rng/core/JumpableProvidersParametricTest.java | 209 +++++++++++++++++++++
.../org/apache/commons/rng/core/ProvidersList.java | 29 +++
.../org/apache/commons/rng/core/RandomAssert.java | 88 ++++++++-
.../rng/core/source32/XoShiRo128PlusTest.java | 74 +++++---
.../rng/core/source32/XoShiRo128StarStarTest.java | 74 +++++---
.../rng/core/source64/XoRoShiRo128PlusTest.java | 76 +++++---
.../core/source64/XoRoShiRo128StarStarTest.java | 76 +++++---
.../rng/core/source64/XoShiRo256PlusTest.java | 76 +++++---
.../rng/core/source64/XoShiRo256StarStarTest.java | 76 +++++---
.../rng/core/source64/XoShiRo512PlusTest.java | 81 ++++----
.../rng/core/source64/XoShiRo512StarStarTest.java | 81 ++++----
.../rng/core/source64/XorShift1024StarPhiTest.java | 71 ++++---
.../rng/core/source64/XorShift1024StarTest.java | 71 ++++---
30 files changed, 1431 insertions(+), 305 deletions(-)
[commons-rng] 05/06: Typo: remove hyphen.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-rng.git
commit 089ba39ba7b1694c5e6f2ca091169871dffea425
Author: Alex Herbert <ah...@apache.org>
AuthorDate: Mon Jun 10 20:55:40 2019 +0100
Typo: remove hyphen.
---
.../main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java b/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java
index 59646d8..0d9bfa7 100644
--- a/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java
+++ b/commons-rng-client-api/src/main/java/org/apache/commons/rng/JumpableUniformRandomProvider.java
@@ -29,7 +29,7 @@ public interface JumpableUniformRandomProvider extends UniformRandomProvider {
*
* <p>The current state will be advanced in a single operation by the equivalent of a
* number of sequential calls to a method that updates the state of the provider. The
- * size of the jump is implementation-dependent.</p>
+ * size of the jump is implementation dependent.</p>
*
* <p>Repeat invocations of this method will create a series of generators
* that are uniformly spaced at intervals of the output sequence. Each generator provides