jdk-sandbox: comparison src/java.base/share/classes/java/util/random/RandomGenerator.java

equal deleted inserted replaced

-:6a4be8bf8990
+:7cb325557832
 import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
 /**
-* The {@link RandomGenerator} interface is designed to provide a common protocol for objects
+* The {@link RandomGenerator} interface is designed to provide a common protocol for objects that
-* that generate random or (more typically) pseudorandom sequences of numbers (or Boolean values).
+* generate random or (more typically) pseudorandom sequences of numbers (or Boolean values). Such a
-* Such a sequence may be obtained by either repeatedly invoking a method that returns a single
+* sequence may be obtained by either repeatedly invoking a method that returns a single
 * (pseudo)randomly chosen value, or by invoking a method that returns a stream of (pseudo)randomly
 * chosen values.
 * <p>
 * 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
 * 2<sup>&minus;<i>w</i></sup>; if an explicit range is specified, then the chosen number is
 * computationally scaled and translated so as to appear to have been chosen from that range.
 * <p>
 * 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 (pseudo)randomly chosen value.  For example, if
-* {@code r} implements {@link RandomGenerator}, then the method call {@code r.ints(100)}
+* {@code r} implements {@link RandomGenerator}, then the method call {@code r.ints(100)} returns a
-* returns a stream of 100 {@code int} values.  These are not necessarily the exact same values that
+* stream of 100 {@code int} values.  These are not necessarily the exact same values that would
-* would have been returned if instead {@code r.nextInt()} had been called 100 times; all that is
+* have been returned if instead {@code r.nextInt()} had been called 100 times; all that is
 * guaranteed is that each value in the stream is chosen in a similar (pseudo)random manner from the
 * same range.
 * <p>
-* Every object that implements the {@link RandomGenerator} interface is assumed to contain a
+* Every object that implements the {@link RandomGenerator} interface is assumed to contain a finite
-* finite amount of state.  Using such an object to generate a pseudorandomly chosen value alters
+* amount of state.  Using such an object to generate a pseudorandomly chosen value alters its
-* its state.  The number of distinct possible states of such an object is called its
+* state.  The number of distinct possible states of such an object is called its
 * <i>period</i>.  (Some implementations of the {@link RandomGenerator} 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.)
 * <p>
-* As a rule, objects that implement the {@link RandomGenerator} interface need not be
+* As a rule, objects that implement the {@link RandomGenerator} interface need not be thread-safe.
-* thread-safe.  It is recommended that multithreaded applications use either {@link
+* It is recommended that multithreaded applications use either {@link ThreadLocalRandom} or
-* ThreadLocalRandom} or (preferably) pseudorandom number generators that implement the {@link
+* (preferably) pseudorandom number generators that implement the {@link SplittableGenerator} or
-* SplittableGenerator} or {@link JumpableGenerator} interface.
+* {@link JumpableGenerator} interface.
 * <p>
 * To implement this interface, a class only needs to provide concrete definitions for the methods
 * {@code nextLong()} and {@code period()}. Default implementations are provided for all other
 * methods (but it may be desirable to override some of them, especially {@code nextInt()} if the
 * underlying algorithm is {@code int}-based). Moerover, it may be preferable instead to implement
-* another interface such as {@link JumpableGenerator} or {@link LeapableGenerator}, or to extend an abstract
+* another interface such as {@link JumpableGenerator} or {@link LeapableGenerator}, or to extend an
-* class such as {@link AbstractSplittableGenerator} or {@link AbstractArbitrarilyJumpableGenerator}.
+* abstract class such as {@link AbstractSplittableGenerator} or {@link
+* AbstractArbitrarilyJumpableGenerator}.
 * <p>
 * Objects that implement {@link RandomGenerator} are typically not cryptographically secure.
 * Consider instead using {@link java.security.SecureRandom} to get a cryptographically secure
 * pseudorandom number generator for use by security-sensitive applications.  Note, however, that
-* {@code java.security.SecureRandom} does implement the {@link RandomGenerator} interface, so
+* {@code java.security.SecureRandom} does implement the {@link RandomGenerator} interface, so that
-* that instances of {@code java.security.SecureRandom} may be used interchangeably with other types
+* instances of {@code java.security.SecureRandom} may be used interchangeably with other types of
-* of pseudorandom generators in applications that do not require a secure generator.
+* pseudorandom generators in applications that do not require a secure generator.
 *
 * @since 14
 */
 public interface RandomGenerator {
 */
 Xoshiro256StarStar("Xoshiro256StarStar");
 private String name;
-Algorithm(String name) {
+private Algorithm(String name) {
 this.name = name;
 }
 public String toString() {
 return name;
+}
+/**
+* Returns an instance of {@link RandomGenerator} that utilizes this algorithm.
+*
+* @return An instance of {@link RandomGenerator}
+*/
+public RandomGenerator instance() {
+return RandomGeneratorFactory.of(name, RandomGenerator.class);
+}
+/**
+* Returns a {@link RandomGeneratorFactory} that can produce instances
+* of {@link RandomGenerator} that utilizes this algorithm.
+*
+* @return {@link RandomGeneratorFactory} of {@link RandomGenerator}
+*/
+public RandomGeneratorFactory<RandomGenerator> factory() {
+return RandomGeneratorFactory.factoryOf(name, RandomGenerator.class);
 }
 }
 /**
 * Returns an instance of {@link RandomGenerator} that utilizes the
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link RandomGenerator} that utilizes the {@code name} algorithm.
 *
 * @param name  Name of random number generator algorithm
 *
-* @return Factory of {@link RandomGenerator}
+* @return {@link RandomGeneratorFactory} of {@link RandomGenerator}
 */
 public static RandomGeneratorFactory<RandomGenerator> factoryOf(String name) {
 Objects.requireNonNull(name);
 return RandomGeneratorFactory.factoryOf(name, RandomGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link RandomGenerator} that utilizes the specified {@code algorithm}.
 *
 * @param algorithm  Random number generator algorithm
 *
-* @return Factory of {@link RandomGenerator}
+* @return {@link RandomGeneratorFactory} of {@link RandomGenerator}
 */
 public static RandomGeneratorFactory<RandomGenerator> factoryOf(Algorithm algorithm) {
 Objects.requireNonNull(algorithm);
 return RandomGeneratorFactory.factoryOf(algorithm.toString(), RandomGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link StreamableGenerator} that utilizes the {@code name} algorithm.
 *
 * @param name  Name of random number generator algorithm
 *
-* @return Factory of {@link StreamableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link StreamableGenerator}
 */
 public static RandomGeneratorFactory<StreamableGenerator> factoryOf(String name) {
 Objects.requireNonNull(name);
 return RandomGeneratorFactory.factoryOf(name, StreamableGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link StreamableGenerator} that utilizes the specified {@code algorithm}.
 *
 * @param algorithm  Random number generator algorithm
 *
-* @return Factory of {@link StreamableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link StreamableGenerator}
 */
 public static RandomGeneratorFactory<StreamableGenerator> factoryOf(Algorithm algorithm) {
 Objects.requireNonNull(algorithm);
 return RandomGeneratorFactory.factoryOf(algorithm.toString(), StreamableGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link SplittableGenerator} that utilizes the {@code name} algorithm.
 *
 * @param name  Name of random number generator algorithm
 *
-* @return Factory of {@link SplittableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link SplittableGenerator}
 */
 public static RandomGeneratorFactory<SplittableGenerator> factoryOf(String name) {
 Objects.requireNonNull(name);
 return RandomGeneratorFactory.factoryOf(name, SplittableGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link SplittableGenerator} that utilizes the specified {@code algorithm}.
 *
 * @param algorithm  Random number generator algorithm
 *
-* @return Factory of {@link SplittableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link SplittableGenerator}
 */
 public static RandomGeneratorFactory<SplittableGenerator> factoryOf(Algorithm algorithm) {
 Objects.requireNonNull(algorithm);
 return RandomGeneratorFactory.factoryOf(algorithm.toString(), SplittableGenerator.class);
 }
 return this.splits(streamSize).map(x -> (RandomGenerator)x);
 }
 }
 /**
-* This interface is designed to provide a common protocol for objects that generate pseudorandom
+* This interface is designed to provide a common protocol for objects that generate
-* sequences of numbers (or Boolean values) and furthermore can easily <i>jump</i> forward (by a
+* pseudorandom sequences of numbers (or Boolean values) and furthermore can easily <i>jump</i>
-* fixed amount) to a distant point in the state cycle.
+* forward (by a fixed amount) to a distant point in the state cycle.
 * <p>
-* Ideally, all {@link JumpableGenerator} objects produced by iterative jumping from a single original
+* Ideally, all {@link JumpableGenerator} objects produced by iterative jumping from a single
-* {@link JumpableGenerator} object are statistically independent of one another and individually uniform.
+* original {@link JumpableGenerator} object are statistically independent of one another and
-* In practice, one must settle for some approximation to independence and uniformity.  In
+* individually uniform. In practice, one must settle for some approximation to independence and
-* particular, a specific implementation may assume that each generator in a stream produced by the
+* uniformity.  In particular, a specific implementation may assume that each generator in a
-* {@code jumps} method is used to produce a number of values no larger than either 2<sup>64</sup>
+* stream produced by the {@code jumps} method is used to produce a number of values no larger
-* or the square root of its period.  Implementors are advised to use algorithms whose period is at
+* than either 2<sup>64</sup> or the square root of its period.  Implementors are advised to use
-* least 2<sup>127</sup>.
+* algorithms whose period is at least 2<sup>127</sup>.
 * <p>
 * Methods are provided to perform a single jump operation and also to produce a stream of
 * generators produced from the original by iterative copying and jumping of internal state.  A
-* typical strategy for a multithreaded application is to create a single {@link JumpableGenerator}
+* typical strategy for a multithreaded application is to create a single {@link
-* object, calls its {@code jumps} method exactly once, and then parcel out generators from the
+* JumpableGenerator} object, calls its {@code jumps} method exactly once, and then parcel out
-* resulting stream, one to each thread.  It is generally not a good idea to call {@code jump} on a
+* generators from the resulting stream, one to each thread.  It is generally not a good idea to
-* generator that was itself produced by the {@code jumps} method, because the result may be a
+* call {@code jump} on a generator that was itself produced by the {@code jumps} method,
-* generator identical to another generator already produce by that call to the {@code jumps}
+* because the result may be a generator identical to another generator already produce by that
-* method. For this reason, the return type of the {@code jumps} method is {@code
+* call to the {@code jumps} method. For this reason, the return type of the {@code jumps}
-* Stream<RandomGenerator>} rather than {@code Stream<JumpableGenerator>}, even though the actual
+* method is {@code Stream<RandomGenerator>} rather than {@code Stream<JumpableGenerator>}, even
-* generator objects in that stream likely do also implement the {@link JumpableGenerator} interface.
+* though the actual generator objects in that stream likely do also implement the {@link
-* <p>
+* JumpableGenerator} interface.
-* An implementation of the {@link JumpableGenerator} interface must provide concrete definitions for the
+* <p>
-* methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code copy()}, {@code jump()},
+* An implementation of the {@link JumpableGenerator} interface must provide concrete
-* and {@code defaultJumpDistance()}. Default implementations are provided for all other methods.
+* definitions for the methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code
-* <p>
+* copy()}, {@code jump()}, and {@code defaultJumpDistance()}. Default implementations are
-* Objects that implement {@link JumpableGenerator} are typically not cryptographically secure.  Consider
+* provided for all other methods.
-* instead using {@link java.security.SecureRandom} to get a cryptographically secure pseudo-random
+* <p>
-* number generator for use by security-sensitive applications.
+* Objects that implement {@link JumpableGenerator} are typically not cryptographically secure.
+* Consider instead using {@link java.security.SecureRandom} to get a cryptographically secure
+* pseudo-random number generator for use by security-sensitive applications.
 *
 * @since 14
 */
 public interface JumpableGenerator extends StreamableGenerator {
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link JumpableGenerator} that utilizes the {@code name} algorithm.
 *
 * @param name  Name of random number generator algorithm
 *
-* @return Factory of {@link JumpableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link JumpableGenerator}
 */
 public static RandomGeneratorFactory<JumpableGenerator> factoryOf(String name) {
 Objects.requireNonNull(name);
 return RandomGeneratorFactory.factoryOf(name, JumpableGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link JumpableGenerator} that utilizes the specified {@code algorithm}.
 *
 * @param algorithm  Random number generator algorithm
 *
-* @return Factory of {@link JumpableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link JumpableGenerator}
 */
 public static RandomGeneratorFactory<JumpableGenerator> factoryOf(Algorithm algorithm) {
 Objects.requireNonNull(algorithm);
 return RandomGeneratorFactory.factoryOf(algorithm.toString(), JumpableGenerator.class);
 }
 }
 }
 /**
-* This interface is designed to provide a common protocol for objects that generate sequences of
+* This interface is designed to provide a common protocol for objects that generate sequences
-* pseudorandom numbers (or Boolean values) and furthermore can easily not only jump but also
+* of pseudorandom numbers (or Boolean values) and furthermore can easily not only jump but
+* also
 * <i>leap</i> to a very distant point in the state cycle.
 * <p>
-* Typically one will construct a series of {@link LeapableGenerator} objects by iterative leaping from a
+* Typically one will construct a series of {@link LeapableGenerator} objects by iterative
-* single original {@link LeapableGenerator} object, and then for each such object produce a subseries of
+* leaping from a single original {@link LeapableGenerator} object, and then for each such
-* objects by iterative jumping.  There is little conceptual difference between leaping and jumping,
+* object produce a subseries of objects by iterative jumping.  There is little conceptual
-* but typically a leap will be a very long jump in the state cycle (perhaps distance
+* difference between leaping and jumping, but typically a leap will be a very long jump in the
-* 2<sup>128</sup> or so).
+* state cycle (perhaps distance 2<sup>128</sup> or so).
 * <p>
-* Ideally, all {@link LeapableGenerator} objects produced by iterative leaping and jumping from a single
+* Ideally, all {@link LeapableGenerator} objects produced by iterative leaping and jumping from
-* original {@link LeapableGenerator} object are statistically independent of one another and individually
+* a single original {@link LeapableGenerator} object are statistically independent of one
-* uniform. In practice, one must settle for some approximation to independence and uniformity.  In
+* another and individually uniform. In practice, one must settle for some approximation to
-* particular, a specific implementation may assume that each generator in a stream produced by the
+* independence and uniformity.  In particular, a specific implementation may assume that each
-* {@code leaps} method is used to produce (by jumping) a number of objects no larger than
+* generator in a stream produced by the {@code leaps} method is used to produce (by jumping) a
-* 2<sup>64</sup>.  Implementors are advised to use algorithms whose period is at least
+* number of objects no larger than 2<sup>64</sup>.  Implementors are advised to use algorithms
-* 2<sup>191</sup>.
+* whose period is at least 2<sup>191</sup>.
 * <p>
 * Methods are provided to perform a single leap operation and also to produce a stream of
-* generators produced from the original by iterative copying and leaping of internal state.  The
+* generators produced from the original by iterative copying and leaping of internal state.
-* generators produced must implement the {@link JumpableGenerator} interface but need not also implement
+* The generators produced must implement the {@link JumpableGenerator} interface but need not
-* the {@link LeapableGenerator} interface.  A typical strategy for a multithreaded application is to
+* also implement the {@link LeapableGenerator} interface.  A typical strategy for a
-* create a single {@link LeapableGenerator} object, calls its {@code leaps} method exactly once, and then
+* multithreaded application is to create a single {@link LeapableGenerator} object, calls its
-* parcel out generators from the resulting stream, one to each thread.  Then the {@code jumps}
+* {@code leaps} method exactly once, and then parcel out generators from the resulting stream,
-* method of each such generator be called to produce a substream of generator objects.
+* one to each thread.  Then the {@code jumps} method of each such generator be called to
-* <p>
+* produce a substream of generator objects.
-* An implementation of the {@link LeapableGenerator} interface must provide concrete definitions for the
+* <p>
-* methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code copy()}, {@code jump()},
+* An implementation of the {@link LeapableGenerator} interface must provide concrete
-* {@code defaultJumpDistance()}, {@code leap()}, and {@code defaultLeapDistance()}. Default
+* definitions for the methods {@code nextInt()}, {@code nextLong}, {@code period()},
-* implementations are provided for all other methods.
+* {@code copy()}, {@code jump()}, {@code defaultJumpDistance()}, {@code leap()},
-* <p>
+* and {@code defaultLeapDistance()}. Default implementations are provided for all other
-* Objects that implement {@link LeapableGenerator} are typically not cryptographically secure.  Consider
+* methods.
-* instead using {@link java.security.SecureRandom} to get a cryptographically secure pseudo-random
+* <p>
-* number generator for use by security-sensitive applications.
+* Objects that implement {@link LeapableGenerator} are typically not cryptographically secure.
+* Consider instead using {@link java.security.SecureRandom} to get a cryptographically secure
+* pseudo-random number generator for use by security-sensitive applications.
 *
 * @since 14
 */
 public interface LeapableGenerator extends JumpableGenerator {
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link LeapableGenerator} that utilizes the {@code name} algorithm.
 *
 * @param name  Name of random number generator algorithm
 *
-* @return Factory of {@link LeapableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link LeapableGenerator}
 */
 public static RandomGeneratorFactory<LeapableGenerator> factoryOf(String name) {
 Objects.requireNonNull(name);
 return RandomGeneratorFactory.factoryOf(name, LeapableGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link LeapableGenerator} that utilizes the specified {@code algorithm}.
 *
 * @param algorithm  Random number generator algorithm
 *
-* @return Factory of {@link LeapableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link LeapableGenerator}
 */
 public static RandomGeneratorFactory<LeapableGenerator> factoryOf(Algorithm algorithm) {
 Objects.requireNonNull(algorithm);
 return RandomGeneratorFactory.factoryOf(algorithm.toString(), LeapableGenerator.class);
 }
 }
 }
 /**
-* This interface is designed to provide a common protocol for objects that generate sequences of
+* This interface is designed to provide a common protocol for objects that generate sequences
-* pseudorandom numbers (or Boolean values) and furthermore can easily <i>jump</i> to an arbitrarily
+* of pseudorandom numbers (or Boolean values) and furthermore can easily <i>jump</i> to an
-* specified distant point in the state cycle.
+* arbitrarily specified distant point in the state cycle.
 * <p>
-* Ideally, all {@link ArbitrarilyJumpableGenerator} objects produced by iterative jumping from a single
+* Ideally, all {@link ArbitrarilyJumpableGenerator} objects produced by iterative jumping from
-* original {@link ArbitrarilyJumpableGenerator} object are statistically independent of one another and
+* a single original {@link ArbitrarilyJumpableGenerator} object are statistically independent
-* individually uniform, provided that they do not traverse overlapping portions of the state cycle.
+* of one another and individually uniform, provided that they do not traverse overlapping
-*  In practice, one must settle for some approximation to independence and uniformity.  In
+* portions of the state cycle. In practice, one must settle for some approximation to
-* particular, a specific implementation may assume that each generator in a stream produced by the
+* independence and uniformity.  In particular, a specific implementation may assume that each
-* {@code jumps} method is used to produce a number of values no larger than the jump distance
+* generator in a stream produced by the {@code jumps} method is used to produce a number of
-* specified.  Implementors are advised to use algorithms whose period is at least 2<sup>127</sup>.
+* values no larger than the jump distance specified.  Implementors are advised to use
-* <p>
+* algorithms whose period is at least 2<sup>127</sup>.
-* For many applications, it suffices to jump forward by a power of two or some small multiple of a
+* <p>
-* power of two, but this power of two may not be representable as a {@code long} value.  To avoid
+* For many applications, it suffices to jump forward by a power of two or some small multiple
-* the use of {@link java.math.BigInteger} values as jump distances, {@code double} values are used
+* of a power of two, but this power of two may not be representable as a {@code long} value.
-* instead.
+* To avoid the use of {@link java.math.BigInteger} values as jump distances, {@code double}
+* values are used instead.
 * <p>
 * Methods are provided to perform a single jump operation and also to produce a stream of
 * generators produced from the original by iterative copying and jumping of internal state.  A
-* typical strategy for a multithreaded application is to create a single {@link
+* typical strategy for a multithreaded application is to create a single
-* ArbitrarilyJumpableGenerator} object, call its {@code jumps} method exactly once, and then parcel out
+* {@link ArbitrarilyJumpableGenerator} object, call its {@code jumps} method exactly once, and
-* generators from the resulting stream, one to each thread.  However, each generator produced also
+* then parcel out generators from the resulting stream, one to each thread.  However, each
-* has type {@link ArbitrarilyJumpableGenerator}; with care, different jump distances can be used to
+* generator produced also has type {@link ArbitrarilyJumpableGenerator}; with care, different
-* traverse the entire state cycle in various ways.
+* jump distances can be used to traverse the entire state cycle in various ways.
 * <p>
 * An implementation of the {@link ArbitrarilyJumpableGenerator} interface must provide concrete
-* definitions for the methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code
+* definitions for the methods {@code nextInt()}, {@code nextLong}, {@code period()},
-* copy()}, {@code jump(double)}, {@code defaultJumpDistance()}, and {@code defaultLeapDistance()}.
+* {@code copy()}, {@code jump(double)}, {@code defaultJumpDistance()}, and
-* Default implementations are provided for all other methods. Perhaps the most convenient way to
+* {@code defaultLeapDistance()}. Default implementations are provided for all other methods.
-* implement this interface is to extend the abstract class {@link ArbitrarilyJumpableGenerator}, which
+* Perhaps the most convenient way to implement this interface is to extend the abstract class
-* provides spliterator-based implementations of the methods {@code ints}, {@code longs}, {@code
+* {@link ArbitrarilyJumpableGenerator}, which provides spliterator-based implementations of the
-* doubles}, {@code rngs}, {@code jumps}, and {@code leaps}.
+* methods {@code ints}, {@code longs}, {@code doubles}, {@code rngs}, {@code jumps}, and
-* <p>
+* {@code leaps}.
-* Objects that implement {@link ArbitrarilyJumpableGenerator} are typically not cryptographically secure.
+* <p>
-* Consider instead using {@link java.security.SecureRandom} to get a cryptographically secure
+* Objects that implement {@link ArbitrarilyJumpableGenerator} are typically not
-* pseudo-random number generator for use by security-sensitive applications.
+* cryptographically secure. Consider instead using {@link java.security.SecureRandom} to get a
+* cryptographically secure pseudo-random number generator for use by security-sensitive
+* applications.
 *
 * @since 14
 */
 public interface ArbitrarilyJumpableGenerator extends LeapableGenerator {
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link ArbitrarilyJumpableGenerator} that utilizes the {@code name} algorithm.
 *
 * @param name  Name of random number generator algorithm
 *
-* @return Factory of {@link ArbitrarilyJumpableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link ArbitrarilyJumpableGenerator}
 */
 public static RandomGeneratorFactory<ArbitrarilyJumpableGenerator> factoryOf(String name) {
 Objects.requireNonNull(name);
 return RandomGeneratorFactory.factoryOf(name, ArbitrarilyJumpableGenerator.class);
 }
 * Returns a {@link RandomGeneratorFactory} that can produce instances
 * of {@link ArbitrarilyJumpableGenerator} that utilizes the specified {@code algorithm}.
 *
 * @param algorithm  Random number generator algorithm
 *
-* @return Factory of {@link ArbitrarilyJumpableGenerator}
+* @return {@link RandomGeneratorFactory} of {@link ArbitrarilyJumpableGenerator}
 */
 public static RandomGeneratorFactory<ArbitrarilyJumpableGenerator> factoryOf(Algorithm algorithm) {
 Objects.requireNonNull(algorithm);
 return RandomGeneratorFactory.factoryOf(algorithm.toString(), ArbitrarilyJumpableGenerator.class);
 }
 * that returned by method {@code defaultJumpDistance()}.
 */
 default void jump() { jump(defaultJumpDistance()); }
 /**
-* Returns an effectively unlimited stream of new pseudorandom number generators, each of which
+* Returns an effectively unlimited stream of new pseudorandom number generators, each of
-* implements the {@link ArbitrarilyJumpableGenerator} interface, produced by jumping copies of this
+* which implements the {@link ArbitrarilyJumpableGenerator} interface, produced by jumping
-* generator by different integer multiples of the specified jump distance.
+* copies of this generator by different integer multiples of the specified jump distance.
 *
 * @param distance a distance to jump forward within the state cycle
 *
 * @return a stream of objects that implement the {@link RandomGenerator} interface
 *
 return Stream.generate(() -> copyAndJump(distance)).sequential();
 }
 /**
 * Returns a stream producing the given {@code streamSize} number of new pseudorandom number
-* generators, each of which implements the {@link ArbitrarilyJumpableGenerator} interface, produced
+* generators, each of which implements the {@link ArbitrarilyJumpableGenerator} interface,
-* by jumping copies of this generator by different integer multiples of the specified jump
+* produced by jumping copies of this generator by different integer multiples of the
-* distance.
+* specified jump distance.
 *
 * @param streamSize the number of generators to generate
 * @param distance   a distance to jump forward within the state cycle
 *
 * @return a stream of objects that implement the {@link RandomGenerator} interface
 return jumps(distance).limit(streamSize);
 }
 /**
 * Alter the state of this pseudorandom number generator so as to jump forward a very large,
-* fixed distance (typically 2<sup>128</sup> or more) within its state cycle.  The distance used
+* fixed distance (typically 2<sup>128</sup> or more) within its state cycle.  The distance
-* is that returned by method {@code defaultJLeapDistance()}.
+* used is that returned by method {@code defaultJLeapDistance()}.
 */
 default void leap() { jump(defaultLeapDistance()); }
 /**
 * Copy this generator, jump this generator forward, then return the copy.

branch	JDK-8193209-branch
changeset 57684	7cb325557832
parent 57671	6a4be8bf8990
child 57940	7e791393cc4d