Class AbstractXoShiRo512

All Implemented Interfaces:
RandomLongSource, JumpableUniformRandomProvider, LongJumpableUniformRandomProvider, RestorableUniformRandomProvider, UniformRandomProvider
Direct Known Subclasses:
XoShiRo512Plus, XoShiRo512PlusPlus, XoShiRo512StarStar

abstract class AbstractXoShiRo512 extends LongProvider implements LongJumpableUniformRandomProvider
This abstract class is a base for algorithms from the Xor-Shift-Rotate family of 64-bit generators with 512-bits of state.
Since:
1.3
See Also:
  • Field Details

    • SEED_SIZE

      private static final int SEED_SIZE
      Size of the state vector.
      See Also:
    • JUMP_COEFFICIENTS

      private static final long[] JUMP_COEFFICIENTS
      The coefficients for the jump function.
    • LONG_JUMP_COEFFICIENTS

      private static final long[] LONG_JUMP_COEFFICIENTS
      The coefficients for the long jump function.
    • state0

      protected long state0
      State 0 of the generator.
    • state1

      protected long state1
      State 1 of the generator.
    • state2

      protected long state2
      State 2 of the generator.
    • state3

      protected long state3
      State 3 of the generator.
    • state4

      protected long state4
      State 4 of the generator.
    • state5

      protected long state5
      State 5 of the generator.
    • state6

      protected long state6
      State 6 of the generator.
    • state7

      protected long state7
      State 7 of the generator.
  • Constructor Details

    • AbstractXoShiRo512

      AbstractXoShiRo512(long[] seed)
      Creates a new instance.
      Parameters:
      seed - Initial seed. If the length is larger than 8, only the first 8 elements will be used; if smaller, the remaining elements will be automatically set. A seed containing all zeros will create a non-functional generator.
    • AbstractXoShiRo512

      AbstractXoShiRo512(long seed0, long seed1, long seed2, long seed3, long seed4, long seed5, long seed6, long seed7)
      Creates a new instance using an 8 element seed. A seed containing all zeros will create a non-functional generator.
      Parameters:
      seed0 - Initial seed element 0.
      seed1 - Initial seed element 1.
      seed2 - Initial seed element 2.
      seed3 - Initial seed element 3.
      seed4 - Initial seed element 4.
      seed5 - Initial seed element 5.
      seed6 - Initial seed element 6.
      seed7 - Initial seed element 7.
    • AbstractXoShiRo512

      protected AbstractXoShiRo512(AbstractXoShiRo512 source)
      Creates a copy instance.
      Parameters:
      source - Source to copy.
  • Method Details

    • setState

      private void setState(long[] state)
      Copies the state from the array into the generator state.
      Parameters:
      state - the new state
    • getStateInternal

      protected byte[] getStateInternal()
      Creates a snapshot of the RNG state.
      Overrides:
      getStateInternal in class LongProvider
      Returns:
      the internal state.
    • setStateInternal

      protected void setStateInternal(byte[] s)
      Resets the RNG to the given state.
      Overrides:
      setStateInternal in class LongProvider
      Parameters:
      s - State (previously obtained by a call to BaseProvider.getStateInternal()).
      See Also:
    • next

      public long next()
      Return the next random value.
      Specified by:
      next in interface RandomLongSource
      Returns:
      the next random value.
    • nextOutput

      protected abstract long nextOutput()
      Use the current state to compute the next output from the generator. The output function shall vary with respect to different generators. This method is called from next() before the current state is updated.
      Returns:
      the next output
    • jump

      public UniformRandomProvider jump()
      Creates a copy of the UniformRandomProvider and then advances the state of the current instance. The copy is returned.

      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.

      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.

      The jump size is the equivalent of 2256 calls to nextLong(). It can provide up to 2256 non-overlapping subsequences.

      Specified by:
      jump in interface JumpableUniformRandomProvider
      Returns:
      A copy of the current state.
    • longJump

      public JumpableUniformRandomProvider longJump()
      Creates a copy of the JumpableUniformRandomProvider and then advances the state of the current instance. The copy is returned.

      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 long jump is implementation dependent.

      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 long jump for use in parallel computations.

      The returned copy may be jumped m / n times before overlap with the current instance where m is the long jump length and n is the jump length of the JumpableUniformRandomProvider.jump() method.

      The jump size is the equivalent of 2384 calls to nextLong(). It can provide up to 2128 non-overlapping subsequences of length 2384; each subsequence can provide up to 2128 non-overlapping subsequences of length 2256 using the jump() method.

      Specified by:
      longJump in interface LongJumpableUniformRandomProvider
      Returns:
      A copy of the current state.
    • copy

      protected abstract AbstractXoShiRo512 copy()
      Create a copy.
      Returns:
      the copy
    • performJump

      private void performJump(long[] jumpCoefficients)
      Perform the jump to advance the generator state. Resets the cached state of the generator.
      Parameters:
      jumpCoefficients - Jump coefficients.