Interface RandomGenerator

All Known Subinterfaces:
RandomGenerator.ArbitrarilyJumpableGenerator,RandomGenerator.JumpableGenerator,RandomGenerator.LeapableGenerator,RandomGenerator.SplittableGenerator,RandomGenerator.StreamableGenerator
All Known Implementing Classes:
Random,SecureRandom,SplittableRandom,ThreadLocalRandom
public interfaceRandomGenerator
TheRandomGenerator interface is designed to provide a common protocol for objects that generate random or (more typically) pseudorandom sequences of numbers (or Boolean values). Such a sequence may be obtained by either repeatedly invoking a method that returns a single pseudorandomly chosen value, or by invoking a method that returns a stream of pseudorandomly chosen values.

Ideally, given an implicitly or explicitly specified range of values, each value would be chosen independently and uniformly from that range. In practice, one may have to settle for some approximation to independence and uniformity.

In the case ofint,long, andboolean values, if there is no explicit specification of range, then the range includes all possible values of the type. In the case offloat anddouble values, first a value is always chosen uniformly from the set of 2w values between 0.0 (inclusive) and 1.0 (exclusive), wherew isFloat.PRECISION forfloat values andDouble.PRECISION fordouble values, such that adjacent values differ by 2−w (notice that this set is asubset of the set ofall representable floating-point values between 0.0 (inclusive) and 1.0 (exclusive)); then if an explicit range was specified, then the chosen number is computationally scaled and translated so as to appear to have been chosen approximately uniformly from that explicit range.

Each method that returns a stream produces a stream of values each of which is chosen in the same manner as for a method that returns a single pseudorandomly chosen value. For example, ifr implementsRandomGenerator, then the method callr.ints(100) returns a stream of 100int values. These are not necessarily the exact same values that would have been returned if insteadr.nextInt() had been called 100 times; all that is guaranteed is that each value in the stream is chosen in a similar pseudorandom manner from the same range.

Every object that implements theRandomGenerator interface by using a pseudorandom algorithm is assumed to contain a finite amount of state. Using such an object to generate a pseudorandomly chosen value alters its state by computing a new state as a function of the current state, without reference to any information other than the current state. The number of distinct possible states of such an object is called itsperiod. (Some implementations of theRandomGenerator interface may be truly random rather than pseudorandom, for example relying on the statistical behavior of a physical object to derive chosen values. Such implementations do not have a fixed period.)

As a rule, objects that implement theRandomGenerator interface need not be thread-safe. It is recommended that multithreaded applications use eitherThreadLocalRandom or (preferably) pseudorandom number generators that implement theRandomGenerator.SplittableGenerator orRandomGenerator.JumpableGenerator interface.

Objects that implementRandomGenerator are typically not cryptographically secure. Consider instead usingSecureRandom to get a cryptographically secure pseudorandom number generator for use by security-sensitive applications. Note, however, thatSecureRandom does implement theRandomGenerator interface, so that instances ofSecureRandom may be used interchangeably with other types of pseudorandom generators in applications that do not require a secure generator.

Unless explicit stated otherwise, the use of null for any method argument will cause a NullPointerException.

Since:
17

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Interface
    Description
    static interface 
    This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can easilyjump forward, by an arbitrary amount, to a distant point in the state cycle.
    static interface 
    This interface is designed to provide a common protocol for objects that generate pseudorandom values and can easilyjump forward, by a moderate amount (ex. 264) to a distant point in the state cycle.
    static interface 
    This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can easily not only jump but alsoleap forward, by a large amount (ex. 2128), to a very distant point in the state cycle.
    static interface 
    This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can besplit into two objects (the original one and a new one) each of which obey that same protocol (and therefore can be recursively split indefinitely).
    static interface 
    TheRandomGenerator.StreamableGenerator interface augments theRandomGenerator interface to provide methods that return streams ofRandomGenerator objects.

  • Method Summary

    Modifier and Type
    Method
    Description
    Returns an effectively unlimited stream of pseudorandomly chosendouble values.
    doubles(double randomNumberOrigin, double randomNumberBound)
    Returns an effectively unlimited stream of pseudorandomly chosendouble values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
    doubles(long streamSize)
    Returns a stream producing the givenstreamSize number of pseudorandomly chosendouble values.
    doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
    Returns a stream producing the givenstreamSize number of pseudorandomly chosendouble values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
    equiDoubles(double left, double right, boolean isLeftIncluded, boolean isRightIncluded)
    Returns an effectively unlimited stream of pseudorandomly chosendouble values, where each value is between the specifiedleft boundary and the specifiedright boundary.
    Returns aRandomGenerator meeting the minimal requirement of having analgorithm whose state bits are greater than or equal 64.
    defaultIntStream
    Returns an effectively unlimited stream of pseudorandomly chosenint values.
    defaultIntStream
    ints(int randomNumberOrigin, int randomNumberBound)
    Returns an effectively unlimited stream of pseudorandomly chosenint values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
    defaultIntStream
    ints(long streamSize)
    Returns a stream producing the givenstreamSize number of pseudorandomly chosenint values.
    defaultIntStream
    ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
    Returns a stream producing the givenstreamSize number of pseudorandomly chosenint values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
    default boolean
    Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.
    defaultLongStream
    Returns an effectively unlimited stream of pseudorandomly chosenlong values.
    defaultLongStream
    longs(long streamSize)
    Returns a stream producing the givenstreamSize number of pseudorandomly chosenlong values.
    defaultLongStream
    longs(long randomNumberOrigin, long randomNumberBound)
    Returns an effectively unlimited stream of pseudorandomly chosenlong values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
    defaultLongStream
    longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
    Returns a stream producing the givenstreamSize number of pseudorandomly chosenlong values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
    default boolean
    Returns a pseudorandomly chosenboolean value.
    default void
    nextBytes(byte[] bytes)
    Fills a user-supplied byte array with generated byte values pseudorandomly chosen uniformly from the range of values between -128 (inclusive) and 127 (inclusive).
    default double
    Returns a pseudorandomdouble value between zero (inclusive) and one (exclusive).
    default double
    nextDouble(double bound)
    Returns a pseudorandomly chosendouble value between zero (inclusive) and the specified bound (exclusive).
    default double
    nextDouble(double origin, double bound)
    Returns a pseudorandomly chosendouble value between the specified origin (inclusive) and the specified bound (exclusive).
    default double
    Returns a nonnegativedouble value pseudorandomly chosen from an exponential distribution whose mean is 1.
    default float
    Returns a pseudorandomfloat value between zero (inclusive) and one (exclusive).
    default float
    nextFloat(float bound)
    Returns a pseudorandomly chosenfloat value between zero (inclusive) and the specified bound (exclusive).
    default float
    nextFloat(float origin, float bound)
    Returns a pseudorandomly chosenfloat value between the specified origin (inclusive) and the specified bound (exclusive).
    default double
    Returns adouble value pseudorandomly chosen from a Gaussian (normal) distribution whose mean is 0 and whose standard deviation is 1.
    default double
    nextGaussian(double mean, double stddev)
    Returns adouble value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.
    default int
    Returns a pseudorandomly chosenint value.
    default int
    nextInt(int bound)
    Returns a pseudorandomly chosenint value between zero (inclusive) and the specified bound (exclusive).
    default int
    nextInt(int origin, int bound)
    Returns a pseudorandomly chosenint value between the specified origin (inclusive) and the specified bound (exclusive).
    long
    Returns a pseudorandomly chosenlong value.
    default long
    nextLong(long bound)
    Returns a pseudorandomly chosenlong value between zero (inclusive) and the specified bound (exclusive).
    default long
    nextLong(long origin, long bound)
    Returns a pseudorandomly chosenlong value between the specified origin (inclusive) and the specified bound (exclusive).
    of(String name)
    Returns an instance ofRandomGenerator that utilizes thenamealgorithm.

  • Method Details

    • of

      static RandomGenerator of(String name)
      Returns an instance ofRandomGenerator that utilizes thenamealgorithm.
      Parameters:
      name - Name of random number generatoralgorithm
      Returns:
      An instance ofRandomGenerator
      Throws:
      NullPointerException - if name is null
      IllegalArgumentException - if the named algorithm is not found

    • getDefault

      static RandomGenerator getDefault()
      Returns aRandomGenerator meeting the minimal requirement of having analgorithm whose state bits are greater than or equal 64.
      Implementation Requirements:
      Since algorithms will improve over time, there is no guarantee that this method will return the same algorithm over time.

      The default implementation selects L32X64MixRandom.

      Returns:
      aRandomGenerator

    • isDeprecated

      default boolean isDeprecated()
      Return true if the implementation of RandomGenerator (algorithm) has been marked for deprecation.
      Implementation Requirements:
      The default implementation checks for the @Deprecated annotation.
      Implementation Note:
      Random number generator algorithms evolve over time; new algorithms will be introduced and old algorithms will lose standing. If an older algorithm is deemed unsuitable for continued use, it will be marked as deprecated to indicate that it may be removed at some point in the future.
      Returns:
      true if the implementation of RandomGenerator (algorithm) has been marked for deprecation

    • doubles

      default DoubleStream doubles()
      Returns an effectively unlimited stream of pseudorandomly chosendouble values.
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextDouble().
      Implementation Note:
      It is permitted to implement this method in a manner equivalent todoubles (Long.MAX_VALUE).
      Returns:
      a stream of pseudorandomly chosendouble values

    • doubles

      default DoubleStream doubles(double randomNumberOrigin, double randomNumberBound)
      Returns an effectively unlimited stream of pseudorandomly chosendouble values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextDouble(randomNumberOrigin, randomNumberBound).
      Implementation Note:
      It is permitted to implement this method in a manner equivalent todoubles (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
      Parameters:
      randomNumberOrigin - the least value that can be produced
      randomNumberBound - the upper bound (exclusive) for each value produced
      Returns:
      a stream of pseudorandomly chosendouble values, each between the specified origin (inclusive) and the specified bound (exclusive)
      Throws:
      IllegalArgumentException - ifrandomNumberOrigin is not finite, orrandomNumberBound is not finite, orrandomNumberOrigin is greater than or equal torandomNumberBound

    • doubles

      default DoubleStream doubles(long streamSize)
      Returns a stream producing the givenstreamSize number of pseudorandomly chosendouble values.
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextDouble().
      Parameters:
      streamSize - the number of values to generate
      Returns:
      a stream of pseudorandomly chosendouble values
      Throws:
      IllegalArgumentException - ifstreamSize is less than zero

    • doubles

      default DoubleStream doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
      Returns a stream producing the givenstreamSize number of pseudorandomly chosendouble values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextDouble(randomNumberOrigin, randomNumberBound).
      Parameters:
      streamSize - the number of values to generate
      randomNumberOrigin - the least value that can be produced
      randomNumberBound - the upper bound (exclusive) for each value produced
      Returns:
      a stream of pseudorandomly chosendouble values, each between the specified origin (inclusive) and the specified bound (exclusive)
      Throws:
      IllegalArgumentException - ifstreamSize is less than zero, orrandomNumberOrigin is not finite, orrandomNumberBound is not finite, orrandomNumberOrigin is greater than or equal torandomNumberBound

    • equiDoubles

      default DoubleStream equiDoubles(double left, double right, boolean isLeftIncluded, boolean isRightIncluded)
      Returns an effectively unlimited stream of pseudorandomly chosendouble values, where each value is between the specifiedleft boundary and the specifiedright boundary. Theleft boundary is included as indicated byisLeftIncluded; similarly, theright boundary is included as indicated byisRightIncluded.

      The stream potentially produces all multiplesk δ (k integer) lying in the interval specified by the parameters, where δ > 0 is the smallest number for which all these multiples are exactdoubles. They are therefore all equidistant. The uniformity of the distribution of thedoubles produced by the stream depends on the quality of the underlyingnextLong(long).

      Implementation Requirements:
      The default implementation first determines the δ above. It then computes both the smallest integerkl such thatkl δ liesinside the given interval, and the smallest integern > 0 such that (kl +n) δ liesoutside the interval. Finally, it returns a stream which generates thedoubles according to (kl +nextLong(n)) δ. The stream never produces-0.0, although it may produce0.0 if the specified interval contains 0.
      Parameters:
      left - the left boundary
      right - the right boundary
      isLeftIncluded - whether theleft boundary is included
      isRightIncluded - whether theright boundary is included
      Returns:
      a stream of pseudorandomly chosendouble values, each betweenleft andright, as specified above.
      Throws:
      IllegalArgumentException - ifleft is not finite, orright is not finite, or if the specified interval is empty.
      Since:
      22

    • ints

      default IntStream ints()
      Returns an effectively unlimited stream of pseudorandomly chosenint values.
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextInt().
      Implementation Note:
      It is permitted to implement this method in a manner equivalent toints (Long.MAX_VALUE).
      Returns:
      a stream of pseudorandomly chosenint values

    • ints

      default IntStream ints(int randomNumberOrigin, int randomNumberBound)
      Returns an effectively unlimited stream of pseudorandomly chosenint values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextInt(randomNumberOrigin, randomNumberBound).
      Implementation Note:
      It is permitted to implement this method in a manner equivalent toints (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
      Parameters:
      randomNumberOrigin - the least value that can be produced
      randomNumberBound - the upper bound (exclusive) for each value produced
      Returns:
      a stream of pseudorandomly chosenint values, each between the specified origin (inclusive) and the specified bound (exclusive)
      Throws:
      IllegalArgumentException - ifrandomNumberOrigin is greater than or equal torandomNumberBound

    • ints

      default IntStream ints(long streamSize)
      Returns a stream producing the givenstreamSize number of pseudorandomly chosenint values.
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextInt().
      Parameters:
      streamSize - the number of values to generate
      Returns:
      a stream of pseudorandomly chosenint values
      Throws:
      IllegalArgumentException - ifstreamSize is less than zero

    • ints

      default IntStream ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
      Returns a stream producing the givenstreamSize number of pseudorandomly chosenint values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextInt(randomNumberOrigin, randomNumberBound).
      Parameters:
      streamSize - the number of values to generate
      randomNumberOrigin - the least value that can be produced
      randomNumberBound - the upper bound (exclusive) for each value produced
      Returns:
      a stream of pseudorandomly chosenint values, each between the specified origin (inclusive) and the specified bound (exclusive)
      Throws:
      IllegalArgumentException - ifstreamSize is less than zero, orrandomNumberOrigin is greater than or equal torandomNumberBound

    • longs

      default LongStream longs()
      Returns an effectively unlimited stream of pseudorandomly chosenlong values.
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextLong().
      Implementation Note:
      It is permitted to implement this method in a manner equivalent tolongs (Long.MAX_VALUE).
      Returns:
      a stream of pseudorandomly chosenlong values

    • longs

      default LongStream longs(long randomNumberOrigin, long randomNumberBound)
      Returns an effectively unlimited stream of pseudorandomly chosenlong values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextLong(randomNumberOrigin, randomNumberBound).
      Implementation Note:
      It is permitted to implement this method in a manner equivalent tolongs (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).
      Parameters:
      randomNumberOrigin - the least value that can be produced
      randomNumberBound - the upper bound (exclusive) for each value produced
      Returns:
      a stream of pseudorandomly chosenlong values, each between the specified origin (inclusive) and the specified bound (exclusive)
      Throws:
      IllegalArgumentException - ifrandomNumberOrigin is greater than or equal torandomNumberBound

    • longs

      default LongStream longs(long streamSize)
      Returns a stream producing the givenstreamSize number of pseudorandomly chosenlong values.
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextLong().
      Parameters:
      streamSize - the number of values to generate
      Returns:
      a stream of pseudorandomly chosenlong values
      Throws:
      IllegalArgumentException - ifstreamSize is less than zero

    • longs

      default LongStream longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
      Returns a stream producing the givenstreamSize number of pseudorandomly chosenlong values, where each value is between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation produces a sequential stream that repeatedly callsnextLong(randomNumberOrigin, randomNumberBound).
      Parameters:
      streamSize - the number of values to generate
      randomNumberOrigin - the least value that can be produced
      randomNumberBound - the upper bound (exclusive) for each value produced
      Returns:
      a stream of pseudorandomly chosenlong values, each between the specified origin (inclusive) and the specified bound (exclusive)
      Throws:
      IllegalArgumentException - ifstreamSize is less than zero, orrandomNumberOrigin is greater than or equal torandomNumberBound

    • nextBoolean

      default boolean nextBoolean()
      Returns a pseudorandomly chosenboolean value.

      The default implementation tests the high-order bit (sign bit) of a value produced bynextInt(), on the grounds that some algorithms for pseudorandom number generation produce values whose high-order bits have better statistical quality than the low-order bits.

      Implementation Requirements:
      The default implementation produces a result based on the sign bit of a number generated bynextInt().
      Returns:
      a pseudorandomly chosenboolean value

    • nextBytes

      default void nextBytes(byte[] bytes)
      Fills a user-supplied byte array with generated byte values pseudorandomly chosen uniformly from the range of values between -128 (inclusive) and 127 (inclusive).
      Implementation Requirements:
      The default implementation produces results from repeated calls tonextLong().
      Implementation Note:
      Algorithm used to fill the byte array;
                 void nextBytes(byte[] bytes) {               int i = 0;               int len = bytes.length;               for (int words = len >> 3; words--> 0; ) {                   long rnd = nextLong();                   for (int n = 8; n--> 0; rnd >>>= Byte.SIZE)                       bytes[i++] = (byte)rnd;               }               if (i < len)                   for (long rnd = nextLong(); i < len; rnd >>>= Byte.SIZE)                       bytes[i++] = (byte)rnd;           }
      Parameters:
      bytes - the byte array to fill with pseudorandom bytes
      Throws:
      NullPointerException - if bytes is null

    • nextFloat

      default float nextFloat()
      Returns a pseudorandomfloat value between zero (inclusive) and one (exclusive).
      Implementation Requirements:
      The default implementation uses theFloat.PRECISION high-order bits from a call tonextInt().
      Returns:
      a pseudorandomfloat value between zero (inclusive) and one (exclusive)

    • nextFloat

      default float nextFloat(float bound)
      Returns a pseudorandomly chosenfloat value between zero (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation checks thatbound is a positive finite float. Then invokesnextFloat(), scaling the result so that the final result lies between0.0f (inclusive) andbound (exclusive).
      Parameters:
      bound - the upper bound (exclusive) for the returned value. Must be positive and finite
      Returns:
      a pseudorandomly chosenfloat value between zero (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - ifbound is not both positive and finite

    • nextFloat

      default float nextFloat(float origin, float bound)
      Returns a pseudorandomly chosenfloat value between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation verifies that theorigin andbound are valid then invokesnextFloat() scaling and translating the result to fit betweenorigin andbound (exclusive).
      Parameters:
      origin - the least value that can be returned
      bound - the upper bound (exclusive)
      Returns:
      a pseudorandomly chosenfloat value between the origin (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - iforigin is not finite, orbound is not finite, ororigin is greater than or equal tobound

    • nextDouble

      default double nextDouble()
      Returns a pseudorandomdouble value between zero (inclusive) and one (exclusive).
      Implementation Requirements:
      The default implementation uses theDouble.PRECISION high-order bits from a call tonextLong().
      Returns:
      a pseudorandomdouble value between zero (inclusive) and one (exclusive)

    • nextDouble

      default double nextDouble(double bound)
      Returns a pseudorandomly chosendouble value between zero (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation checks thatbound is a positive finite double. Then invokesnextDouble(), scaling the result so that the final result lies between0.0 (inclusive) andbound (exclusive).
      Parameters:
      bound - the upper bound (exclusive) for the returned value. Must be positive and finite
      Returns:
      a pseudorandomly chosendouble value between zero (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - ifbound is not both positive and finite

    • nextDouble

      default double nextDouble(double origin, double bound)
      Returns a pseudorandomly chosendouble value between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation verifies that theorigin andbound are valid, then invokesnextDouble() scaling and translating the result to fit betweenorigin andbound( exclusive).
      Parameters:
      origin - the least value that can be returned
      bound - the upper bound (exclusive) for the returned value
      Returns:
      a pseudorandomly chosendouble value between the origin (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - iforigin is not finite, orbound is not finite, ororigin is greater than or equal tobound

    • nextInt

      default int nextInt()
      Returns a pseudorandomly chosenint value.
      Implementation Requirements:
      The default implementation uses the 32 high-order bits from a call tonextLong().
      Returns:
      a pseudorandomly chosenint value

    • nextInt

      default int nextInt(int bound)
      Returns a pseudorandomly chosenint value between zero (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation checks thatbound is positive. It then invokesnextInt() one or more times to ensure a uniform distribution in the range 0 (inclusive) tobound (exclusive). It assumes the distribution ofnextInt() to be uniform.
      Parameters:
      bound - the upper bound (exclusive) for the returned value. Must be positive.
      Returns:
      a pseudorandomly chosenint value between zero (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - ifbound is not positive

    • nextInt

      default int nextInt(int origin, int bound)
      Returns a pseudorandomly chosenint value between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation checks thatorigin is less thanbound. It then invokesnextInt() one or more times to ensure a uniform distribution in the rangeorigin (inclusive) tobound (exclusive). It assumes the distribution ofnextInt() to be uniform.
      Parameters:
      origin - the least value that can be returned
      bound - the upper bound (exclusive) for the returned value
      Returns:
      a pseudorandomly chosenint value between the origin (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - iforigin is greater than or equal tobound

    • nextLong

      long nextLong()
      Returns a pseudorandomly chosenlong value.
      Returns:
      a pseudorandomly chosenlong value

    • nextLong

      default long nextLong(long bound)
      Returns a pseudorandomly chosenlong value between zero (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation checks thatbound is positive. It then invokesnextLong() one or more times to ensure a uniform distribution in the range 0 (inclusive) tobound (exclusive). It assumes the distribution ofnextLong() to be uniform.
      Parameters:
      bound - the upper bound (exclusive) for the returned value. Must be positive.
      Returns:
      a pseudorandomly chosenlong value between zero (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - ifbound is not positive

    • nextLong

      default long nextLong(long origin, long bound)
      Returns a pseudorandomly chosenlong value between the specified origin (inclusive) and the specified bound (exclusive).
      Implementation Requirements:
      The default implementation checks thatorigin is less thanbound. It then invokesnextLong() one or more times to ensure a uniform distribution in the rangeorigin (inclusive) tobound (exclusive). It assumes the distribution ofnextLong() to be uniform.
      Parameters:
      origin - the least value that can be returned
      bound - the upper bound (exclusive) for the returned value
      Returns:
      a pseudorandomly chosenlong value between the origin (inclusive) and the bound (exclusive)
      Throws:
      IllegalArgumentException - iforigin is greater than or equal tobound

    • nextGaussian

      default double nextGaussian()
      Returns adouble value pseudorandomly chosen from a Gaussian (normal) distribution whose mean is 0 and whose standard deviation is 1.
      Implementation Requirements:
      The default implementation uses McFarland's fast modified ziggurat algorithm (largely table-driven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
      Returns:
      adouble value pseudorandomly chosen from a Gaussian distribution

    • nextGaussian

      default double nextGaussian(double mean, double stddev)
      Returns adouble value pseudorandomly chosen from a Gaussian (normal) distribution with a mean and standard deviation specified by the arguments.
      Implementation Requirements:
      The default implementation uses McFarland's fast modified ziggurat algorithm (largely table-driven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
      Parameters:
      mean - the mean of the Gaussian distribution to be drawn from
      stddev - the standard deviation (square root of the variance) of the Gaussian distribution to be drawn from
      Returns:
      adouble value pseudorandomly chosen from the specified Gaussian distribution
      Throws:
      IllegalArgumentException - ifstddev is negative

    • nextExponential

      default double nextExponential()
      Returns a nonnegativedouble value pseudorandomly chosen from an exponential distribution whose mean is 1.
      Implementation Requirements:
      The default implementation uses McFarland's fast modified ziggurat algorithm (largely table-driven, with rare cases handled by computation and rejection sampling). Walker's alias method for sampling a discrete distribution also plays a role.
      Returns:
      a nonnegativedouble value pseudorandomly chosen from an exponential distribution