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 137b9c62796d6304cfd371901688db853dcf534a Author: Alex Herbert <[email protected]> AuthorDate: Mon Jun 10 22:25:23 2019 +0100 RNG-98: Implement and test LongJumpableUniformRandomProvider. --- .../rng/core/source64/AbstractXoRoShiRo128.java | 23 ++++- .../rng/core/source64/AbstractXoShiRo256.java | 23 ++++- .../rng/core/JumpableProvidersParametricTest.java | 115 +++++++++++++++++++-- .../org/apache/commons/rng/core/RandomAssert.java | 28 +++++ .../rng/core/source64/XoRoShiRo128PlusTest.java | 18 ++++ .../core/source64/XoRoShiRo128StarStarTest.java | 18 ++++ .../rng/core/source64/XoShiRo256PlusTest.java | 18 ++++ .../rng/core/source64/XoShiRo256StarStarTest.java | 18 ++++ 8 files changed, 250 insertions(+), 11 deletions(-) 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 e6c5592..c3e64f7 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 @@ -18,6 +18,7 @@ package org.apache.commons.rng.core.source64; import org.apache.commons.rng.JumpableUniformRandomProvider; +import org.apache.commons.rng.LongJumpableUniformRandomProvider; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.core.util.NumberFactory; @@ -29,13 +30,17 @@ import org.apache.commons.rng.core.util.NumberFactory; * * @since 1.3 */ -abstract class AbstractXoRoShiRo128 extends LongProvider implements JumpableUniformRandomProvider { +abstract class AbstractXoRoShiRo128 extends LongProvider implements LongJumpableUniformRandomProvider { /** 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 }; + /** The coefficients for the long jump function. */ + private static final long[] LONG_JUMP_COEFFICIENTS = { + 0xd2a98b26625eee7bL, 0xdddf9b1090aa7ac1L + }; // State is maintained using variables rather than an array for performance @@ -127,6 +132,22 @@ abstract class AbstractXoRoShiRo128 extends LongProvider implements JumpableUnif } /** + * {@inheritDoc} + * + * <p>The jump size is the equivalent of 2<sup>96</sup> calls to + * {@link UniformRandomProvider#nextLong() nextLong()}. It can provide up to + * 2<sup>32</sup> non-overlapping subsequences of length 2<sup>96</sup>; each + * subsequence can provide up to 2<sup>32</sup> non-overlapping subsequences of + * length 2<sup>64</sup>using the {@link #jump()} method.</p> + */ + @Override + public JumpableUniformRandomProvider longJump() { + final JumpableUniformRandomProvider copy = copy(); + performJump(LONG_JUMP_COEFFICIENTS); + return copy; + } + + /** * Create a copy. * * @return the copy 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 da6972f..af603ca 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 @@ -18,6 +18,7 @@ package org.apache.commons.rng.core.source64; import org.apache.commons.rng.JumpableUniformRandomProvider; +import org.apache.commons.rng.LongJumpableUniformRandomProvider; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.core.util.NumberFactory; @@ -29,13 +30,17 @@ import org.apache.commons.rng.core.util.NumberFactory; * * @since 1.3 */ -abstract class AbstractXoShiRo256 extends LongProvider implements JumpableUniformRandomProvider { +abstract class AbstractXoShiRo256 extends LongProvider implements LongJumpableUniformRandomProvider { /** 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 }; + /** The coefficients for the long jump function. */ + private static final long[] LONG_JUMP_COEFFICIENTS = { + 0x76e15d3efefdcbbfL, 0xc5004e441c522fb3L, 0x77710069854ee241L, 0x39109bb02acbe635L + }; // State is maintained using variables rather than an array for performance @@ -140,6 +145,22 @@ abstract class AbstractXoShiRo256 extends LongProvider implements JumpableUnifor } /** + * {@inheritDoc} + * + * <p>The jump size is the equivalent of 2<sup>192</sup> calls to + * {@link UniformRandomProvider#nextLong() nextLong()}. It can provide up to + * 2<sup>64</sup> non-overlapping subsequences of length 2<sup>192</sup>; each + * subsequence can provide up to 2<sup>64</sup> non-overlapping subsequences of + * length 2<sup>128</sup>using the {@link #jump()} method.</p> + */ + @Override + public JumpableUniformRandomProvider longJump() { + final JumpableUniformRandomProvider copy = copy(); + performJump(LONG_JUMP_COEFFICIENTS); + return copy; + } + + /** * Create a copy. * * @return the copy 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 index ec517e6..4372787 100644 --- 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 @@ -26,6 +26,7 @@ import org.junit.runners.Parameterized.Parameters; import java.util.Arrays; import org.apache.commons.rng.JumpableUniformRandomProvider; +import org.apache.commons.rng.LongJumpableUniformRandomProvider; import org.apache.commons.rng.RandomProviderState; import org.apache.commons.rng.RestorableUniformRandomProvider; import org.apache.commons.rng.UniformRandomProvider; @@ -70,17 +71,83 @@ public class JumpableProvidersParametricTest { } /** + * Gets the function using the {@link JumpableUniformRandomProvider#jump()} method. + * + * @return the jump function + */ + private TestJumpFunction getJumpFunction() { + return new TestJumpFunction() { + @Override + public UniformRandomProvider jump() { + return generator.jump(); + } + }; + } + + /** + * Gets the function using the {@link LongJumpableUniformRandomProvider#longJump()} method. + * + * @return the jump function + */ + private TestJumpFunction getLongJumpFunction() { + Assume.assumeTrue("No long jump function", generator instanceof LongJumpableUniformRandomProvider); + + final LongJumpableUniformRandomProvider rng = (LongJumpableUniformRandomProvider) generator; + return new TestJumpFunction() { + @Override + public UniformRandomProvider jump() { + return rng.longJump(); + } + }; + } + + /** * 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(); + assertJumpReturnsACopy(getJumpFunction()); + } + + /** + * Test that the random generator returned from the long jump is a new instance of the same class. + */ + @Test + public void testLongJumpReturnsACopy() { + assertJumpReturnsACopy(getLongJumpFunction()); + } + + /** + * Assert that the random generator returned from the jump function is a new instance of the same class. + * + * @param jumpFunction Jump function to test. + */ + private void assertJumpReturnsACopy(TestJumpFunction jumpFunction) { + final UniformRandomProvider copy = jumpFunction.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 + * matches the input state. + */ + @Test + public void testJumpCopyMatchesPreJumpState() { + assertCopyMatchesPreJumpState(getJumpFunction()); + } + + /** + * Test that the random generator state of the copy instance returned from the long jump + * matches the input state. + */ + @Test + public void testLongJumpCopyMatchesPreJumpState() { + assertCopyMatchesPreJumpState(getLongJumpFunction()); + } + + /** + * 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 @@ -94,9 +161,10 @@ public class JumpableProvidersParametricTest { * <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> + * + * @param jumpFunction Jump function to test. */ - @Test - public void testJumpCopyMatchesPreJumpState() { + private void assertCopyMatchesPreJumpState(TestJumpFunction jumpFunction) { Assume.assumeTrue("Not a restorable RNG", generator instanceof RestorableUniformRandomProvider); for (int repeats = 0; repeats < 2; repeats++) { @@ -110,7 +178,7 @@ public class JumpableProvidersParametricTest { final RandomProviderState preJumpState = ((RestorableUniformRandomProvider) generator).saveState(); Assume.assumeTrue("Not a recognised state", preJumpState instanceof RandomProviderDefaultState); - final UniformRandomProvider copy = generator.jump(); + final UniformRandomProvider copy = jumpFunction.jump(); final RandomProviderState copyState = ((RestorableUniformRandomProvider) copy).saveState(); final RandomProviderDefaultState expected = (RandomProviderDefaultState) preJumpState; @@ -127,9 +195,22 @@ public class JumpableProvidersParametricTest { @Test public void testJumpResetsDefaultState() { if (generator instanceof IntProvider) { - assertJumpResetsDefaultState(intProviderStateSize); + assertJumpResetsDefaultState(getJumpFunction(), intProviderStateSize); } else if (generator instanceof LongProvider) { - assertJumpResetsDefaultState(longProviderStateSize); + assertJumpResetsDefaultState(getJumpFunction(), longProviderStateSize); + } + } + + /** + * Test that a long jump resets the state of the default implementation of a generator in + * {@link IntProvider} and {@link LongProvider}. + */ + @Test + public void testLongJumpResetsDefaultState() { + if (generator instanceof IntProvider) { + assertJumpResetsDefaultState(getLongJumpFunction(), intProviderStateSize); + } else if (generator instanceof LongProvider) { + assertJumpResetsDefaultState(getLongJumpFunction(), longProviderStateSize); } } @@ -140,9 +221,10 @@ public class JumpableProvidersParametricTest { * <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 + * @param jumpFunction Jump function to test. + * @param stateSize State size. */ - private void assertJumpResetsDefaultState(int stateSize) { + private void assertJumpResetsDefaultState(TestJumpFunction jumpFunction, int stateSize) { final byte[] expected = new byte[stateSize]; for (int repeats = 0; repeats < 2; repeats++) { // Exercise the generator. @@ -152,7 +234,7 @@ public class JumpableProvidersParametricTest { generator.nextInt(); generator.nextBoolean(); - generator.jump(); + jumpFunction.jump(); // An Int/LongProvider so must be a RestorableUniformRandomProvider final RandomProviderState postJumpState = ((RestorableUniformRandomProvider) generator).saveState(); @@ -206,4 +288,19 @@ public class JumpableProvidersParametricTest { return getStateInternal().length; } } + + /** + * Specify the jump operation to test. + * + * <p>This allows testing {@link JumpableUniformRandomProvider} or + * {@link LongJumpableUniformRandomProvider}.</p> + */ + interface TestJumpFunction { + /** + * Perform the jump and return a pre-jump copy. + * + * @return the pre-jump copy. + */ + UniformRandomProvider 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 76c5293..5bae5a8 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 @@ -24,6 +24,7 @@ import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import org.apache.commons.rng.JumpableUniformRandomProvider; +import org.apache.commons.rng.LongJumpableUniformRandomProvider; import org.apache.commons.rng.RandomProviderState; import org.apache.commons.rng.RestorableUniformRandomProvider; import org.apache.commons.rng.UniformRandomProvider; @@ -135,6 +136,33 @@ public class RandomAssert { } /** + * Assert that the random generator satisfies the contract of the + * {@link LongJumpableUniformRandomProvider#longJump()} function. + * + * <ul> + * <li>The long 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 long jump. + * @param expectedAfter Expected output after the long jump. + * @param rng Random generator. + */ + public static void assertLongJumpEquals(long[] expectedBefore, + long[] expectedAfter, + LongJumpableUniformRandomProvider rng) { + final UniformRandomProvider copy = rng.longJump(); + 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 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/source64/XoRoShiRo128PlusTest.java b/commons-rng-core/src/test/java/org/apache/commons/rng/core/source64/XoRoShiRo128PlusTest.java index 2b27694..0439fb5 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 @@ -58,6 +58,19 @@ public class XoRoShiRo128PlusTest { 0x83ae5b12eb343545L, 0x10828fde12decab5L, 0x6952d51f130505b7L, 0x9b6bd81fbe064f54L, }; + private static final long[] EXPECTED_SEQUENCE_AFTER_LONG_JUMP = { + 0xf569a89f3ee6fa3dL, 0x3c61867cbcc208a8L, 0x95a83b710aa1a57fL, 0xed5c658383559407L, + 0xbb70b6959a82f3b0L, 0x31eab244213fe7beL, 0xe14bb9d50b6b026fL, 0x80716d04b81d5aaaL, + 0x5451ede574559e11L, 0x1aa1d87fdfb78d52L, 0x38e4a2c33f97870fL, 0xf88a98d8376a95b5L, + 0x5b88ec173f131549L, 0x642af091aab9643aL, 0x92edb9171a703919L, 0xf65bd2ac6b1efd62L, + 0xe10b1da6e5b2efafL, 0xf2abec22c6c4170dL, 0xa5b853b7dee402c1L, 0xe45d2ec5e488cac3L, + 0x64f126a2065224d6L, 0x5e4f64edde60e852L, 0xc8dc8819696ef333L, 0x1a9acfaa4a10f22bL, + 0xd75be7f8487d1c52L, 0x7759ec0ea4b8e698L, 0xc36b934a78c463e2L, 0x2c7257c4228f7948L, + 0x0651b8c869027343L, 0xe66b122fec5ca8a1L, 0xe3f8ad0bcf74642dL, 0x08f46e481eec937aL, + 0xccd1c4419af68187L, 0x93396af913995faeL, 0x95ee2988b39a3534L, 0x7da239ae0dd79948L, + 0xa0fdcf90f2e3ab22L, 0xb2e20b2ce7a83f7aL, 0xd1346542947f8b0dL, 0xa95894552bbb2460L, + }; + @Test public void testReferenceCode() { RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoRoShiRo128Plus(SEED)); @@ -90,4 +103,9 @@ public class XoRoShiRo128PlusTest { public void testJump() { RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoRoShiRo128Plus(SEED)); } + + @Test + public void testLongJump() { + RandomAssert.assertLongJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_LONG_JUMP, 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 776e1a6..204ead2 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 @@ -58,6 +58,19 @@ public class XoRoShiRo128StarStarTest { 0xa9b19565638b0e2bL, 0x755bf81250abd6c1L, 0x2b8ba00b2714bf8fL, 0x5e165740374e0fa6L, }; + private static final long[] EXPECTED_SEQUENCE_AFTER_LONG_JUMP = { + 0x77781c11728ccab7L, 0x53ebc2b248baf6bfL, 0x891c834850b9a60aL, 0x3d75b3f460049bc4L, + 0x0ce2e3bec7efd177L, 0xcb3eac404f71e15dL, 0x4d1dd0a773be7287L, 0x2ef0fbefdd874642L, + 0x063a585e07c58b9dL, 0xd5b5174e803858efL, 0x40dfddff6a4743efL, 0xfa4e62e3fb9b2de2L, + 0x66fa3013cb6c4ca0L, 0x5b53086fea56344fL, 0x2ed92fdc75a14297L, 0x0cf92e9456f1e047L, + 0x5455e58538979accL, 0xb4226b69b40f5c89L, 0xe6de8c807f5fdf89L, 0xf9c898bc7c8815cbL, + 0x1c0363d696d06dccL, 0x4d7765ac48833302L, 0x84cf12882a284c7eL, 0x1d19d839c41f08b7L, + 0xec30f743f1fdf8beL, 0x61a7536651dadd56L, 0xff456aeab1bc73cfL, 0x671390bb0e2dcad4L, + 0xb51b533c7dc9cbccL, 0xa78c13a798610f10L, 0xb1cc573c29364864L, 0x23fe45909c9fcd47L, + 0xd17b8d91ad355118L, 0x1dd7b85f071efd1bL, 0x518bf93d445908ccL, 0x31a212d5f4cc8458L, + 0x62b7ffe46b91633eL, 0x079af812760a6633L, 0x596c95fed05028e7L, 0x6277ec5c12ea9677L, + }; + @Test public void testReferenceCode() { RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoRoShiRo128StarStar(SEED)); @@ -90,4 +103,9 @@ public class XoRoShiRo128StarStarTest { public void testJump() { RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoRoShiRo128StarStar(SEED)); } + + @Test + public void testLongJump() { + RandomAssert.assertLongJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_LONG_JUMP, 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 a61eda9..ba47b8e 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 @@ -58,6 +58,19 @@ public class XoShiRo256PlusTest { 0x6d98bfd64342222bL, 0x7244f91ff7efc522L, 0xbcf26439fef5555fL, 0xce657c86d81455ceL, }; + private static final long[] EXPECTED_SEQUENCE_AFTER_LONG_JUMP = { + 0x1cf7608ee3f54c71L, 0xd9ec5faa2133c458L, 0xee0c3c44ac9a4571L, 0x8e6dd93270d03b83L, + 0x44268688ca3c44b2L, 0x07aefb00d1cd925fL, 0x3733c3fe9831692dL, 0x2d2c5df21bfd31b2L, + 0x1253a79c879276c2L, 0xf862b65e4bcb6bcfL, 0xf6dbb01651a1b8b5L, 0x68476e3a6b9bf559L, + 0xb135e7151bafae3eL, 0x6e905be176bb02bfL, 0xa5ee1972ed7e090cL, 0x2cad1fadf7be52d6L, + 0x1a34866325f9ae69L, 0xec4f680ff02209c1L, 0x4f01371b2db5a1c3L, 0x566fb6f85561d4d0L, + 0x75fec1eb21866b41L, 0xfaff7b899909d846L, 0xe9e1bc7229c28446L, 0x63389a9af17857c5L, + 0x07233b15e9f42541L, 0x46e262e3ba5c337cL, 0xfac8e73ae594bbd9L, 0x990562a1cbaf25d8L, + 0xd99269c3ac01c7a0L, 0x20c249266bba8447L, 0x947bf8bc4e0e8deaL, 0xbd69e3c43fa8582aL, + 0x7fb6e0e0d918bba6L, 0x95633e090da85696L, 0x1529c0b55ede291bL, 0x9034b247848dc3beL, + 0x6422cc4a32efeb31L, 0x6334a19977a2fca6L, 0x016a2c7af8cf0eefL, 0x49dab6a0dc871a1cL, + }; + @Test public void testReferenceCode() { RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo256Plus(SEED)); @@ -90,4 +103,9 @@ public class XoShiRo256PlusTest { public void testJump() { RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo256Plus(SEED)); } + + @Test + public void testLongJump() { + RandomAssert.assertLongJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_LONG_JUMP, 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 c4c6e55..dd9d209 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 @@ -58,6 +58,19 @@ public class XoShiRo256StarStarTest { 0x3346bda5d2ac2d7dL, 0xbeab7520abd736f1L, 0x7195e9c9f28eac6aL, 0x64d959048b71d87bL, }; + private static final long[] EXPECTED_SEQUENCE_AFTER_LONG_JUMP = { + 0x01aeb600840f594fL, 0xb658457c13139b18L, 0x45de59065e34c7a1L, 0xee4e2dc3272cbdddL, + 0xab76ae6ad7b58827L, 0x1125e963c7de503dL, 0x262a3e31960c225cL, 0x6959383a6ca6db93L, + 0x162e98220db47855L, 0x8c241774ab03fb0fL, 0xa574997e9135c756L, 0x7d69f1c620f6e354L, + 0xebcaa8a26b1e0d11L, 0x7013a78241c67e80L, 0xd653dc4a68e9f576L, 0x54f483e05528cdeeL, + 0x0f46d76b266f1bdeL, 0xb5364248293168b0L, 0x83328b16fdd08b22L, 0x3c9241622a8ed2d3L, + 0x4fb5158c8ba832e9L, 0x98a540967c042253L, 0xfc215e6a07670358L, 0xafc3ccd56bc029beL, + 0xf0b16f5c1edf807aL, 0x02792082f4adc46fL, 0xe6203988ebcd9f8fL, 0xa3f9c62dc60e3a05L, + 0x9ec363a473ce3affL, 0x2e787e5b4ff29d4dL, 0x89899eb9b705963fL, 0xc9114da1cad45697L, + 0xdb8fc78dc1fb839eL, 0xe537b60ba49474d5L, 0xcffb3215f6208209L, 0xbfdabe221f9c308cL, + 0x3d30cabb172af4b2L, 0xfd64f857f0f3b8d8L, 0x4b554d6b026bf8c1L, 0xf5ebb49acd5d6f24L, + }; + @Test public void testReferenceCode() { RandomAssert.assertEquals(EXPECTED_SEQUENCE, new XoShiRo256StarStar(SEED)); @@ -90,4 +103,9 @@ public class XoShiRo256StarStarTest { public void testJump() { RandomAssert.assertJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_JUMP, new XoShiRo256StarStar(SEED)); } + + @Test + public void testLongJump() { + RandomAssert.assertLongJumpEquals(EXPECTED_SEQUENCE, EXPECTED_SEQUENCE_AFTER_LONG_JUMP, new XoShiRo256StarStar(SEED)); + } }
