This interface is designed to provide a common protocol for objects that generate sequences of pseudorandom values and can easily not only jump but also

*leap* forward, by a large amount (ex. 2

^{128}), to a very distant point in the state cycle. Typically one will construct a series of

`RandomGenerator.LeapableGenerator`

objects by iterative leaping from a single original

`RandomGenerator.LeapableGenerator`

object, and then for each such object produce a subseries of objects by iterative jumping. There is little conceptual difference between leaping and jumping, but typically a leap will be a very long jump in the state cycle (perhaps distance 2

^{128} or so).

Ideally, all `RandomGenerator.LeapableGenerator`

objects produced by iterative leaping and jumping from a single original `RandomGenerator.LeapableGenerator`

object are statistically independent of one another and individually uniform. In practice, one must settle for some approximation to independence and uniformity. In particular, a specific implementation may assume that each generator in a stream produced by the `leaps`

method is used to produce (by jumping) a number of objects no larger than 2^{64}. Implementors are advised to use algorithms whose period is at least 2^{191}.

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 must implement the `RandomGenerator.JumpableGenerator`

interface but need not also implement the `RandomGenerator.LeapableGenerator`

interface. A typical strategy for a multithreaded application is to create a single `RandomGenerator.LeapableGenerator`

object, calls its `leaps`

method exactly once, and then parcel out generators from the resulting stream, one to each thread. Then the `jump`

() method of each such generator be called to produce a substream of generator objects.

Objects that implement `RandomGenerator.LeapableGenerator`

are typically not cryptographically secure. Consider instead using `SecureRandom`

to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.