Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## umontreal.iro.lecuyer.rng
Interface RandomStream

All Known Subinterfaces:
  CloneableRandomStream, PointSetIterator

All Known Implementing Classes:
  AntitheticStream, BakerTransformedStream, CycleBasedPointSet.CycleBasedPointSetIterator, CycleBasedPointSetBase2.CycleBasedPointSetBase2Iterator, F2NL607, GenF2w32, LFSR113, LFSR258, MRG31k3p, MRG32k3a, MRG32k3aL, MT19937, RandMrg, RandomStreamBase, RandomStreamWithCache, RandRijndael, TruncatedRandomStream, WELL1024, WELL512, WELL607

    public interface RandomStream

This interface defines the basic structures to handle multiple streams of uniform (pseudo)random numbers and convenient tools to move around within and across these streams. The actual random number generators (RNGs) are provided in classes that implement this `RandomStream` interface. Each stream of random numbers is an object of the class that implements this interface, and can be viewed as a virtual random number generator.

For each type of base RNG (i.e., each implementation of the `RandomStream` interface), the full period of the generator is cut into adjacent streams (or segments) of length Z, and each of these streams is partitioned into V substreams of length W, where Z = VW. The values of V and W depend on the specific RNG, but are usually larger than 250. Thus, the distance Z between the starting points of two successive streams provided by an RNG usually exceeds 2100. The initial seed of the RNG is the starting point of the first stream. It has a default value for each type of RNG, but this initial value can be changed by calling `setPackageSeed` for the corresponding class. Each time a new `RandomStream` is created, its starting point (initial seed) is computed automatically, Z steps ahead of the starting point of the previously created stream of the same type, and its current state is set equal to this starting point.

For each stream, one can advance by one step and generate one value, or go ahead to the beginning of the next substream within this stream, or go back to the beginning of the current substream, or to the beginning of the stream, or jump ahead or back by an arbitrary number of steps. Denote by Cg the current state of a stream g, Ig its initial state, Bg the state at the beginning of the current substream, and Ng the state at the beginning of the next substream. The form of the state of a stream depends on its type. For example, the state of a stream of class `MRG32k3a` is a vector of six 32-bit integers represented internally as floating-point numbers (in `double`).

The methods for manipulating the streams and generating random numbers are implemented differently for each type of RNG. The methods whose formal parameter types do not depend on the RNG type are specified in the interface `RandomStream`. The others (e.g., for setting the seeds) are given only in the classes that implement the specific RNG types.

Methods for generating random variates from non-uniform distributions are provided in the `randvar` package.

Method Summary
`void` | `nextArrayOfDouble(double[] u, int start, int n)` Generates `n` (pseudo)random numbers from the uniform distribution and stores them into the array `u` starting at index `start`.
`void` | `nextArrayOfInt(int i, int j, int[] u, int start, int n)` Generates `n` (pseudo)random numbers from the discrete uniform distribution over the integers {i, i + 1,..., j}, using this stream and stores the result in the array `u` starting at index `start`.
`double` | `nextDouble()` Returns a (pseudo)random number from the uniform distribution over the interval [0, 1), using this stream, after advancing its state by one step.
`int` | `nextInt(int i, int j)` Returns a (pseudo)random number from the discrete uniform distribution over the integers {i, i + 1,..., j}, using this stream.
`void` | `resetNextSubstream()` Reinitializes the stream to the beginning of its next substream: Ng is computed, and Cg and Bg are set to Ng.
`void` | `resetStartStream()` Reinitializes the stream to its initial state Ig: Cg and Bg are set to Ig.
`void` | `resetStartSubstream()` Reinitializes the stream to the beginning of its current substream: Cg is set to Bg.
`String` | `toString()` Returns a string containing the current state of this stream.

Method Detail

### resetStartStream

    void resetStartStream()

  Reinitializes the stream to its initial state Ig: Cg and Bg are set to Ig.

### resetStartSubstream

    void resetStartSubstream()

  Reinitializes the stream to the beginning of its current substream: Cg is set to Bg.

### resetNextSubstream

    void resetNextSubstream()

  Reinitializes the stream to the beginning of its next substream: Ng is computed, and Cg and Bg are set to Ng.

### toString

    String toString()

  Returns a string containing the current state of this stream.

  Overrides:
    `toString` in class `Object`
  Returns:
    the state of the generator formated as a string

### nextDouble

    double nextDouble()

  Returns a (pseudo)random number from the uniform distribution over the interval [0, 1), using this stream, after advancing its state by one step.

  Returns:
    the next generated uniform

### nextArrayOfDouble

    void nextArrayOfDouble(double[] u,
                           int start,
                           int n)

  Generates `n` (pseudo)random numbers from the uniform distribution and stores them into the array `u` starting at index `start`.

  Parameters:
    `u` - array that will contain the generated uniforms
    `start` - starting index, in the array `u`, to write uniforms from
    `n` - number of uniforms to generate

### nextInt

    int nextInt(int i,
                int j)

  Returns a (pseudo)random number from the discrete uniform distribution over the integers {i, i + 1,..., j}, using this stream. (Calls `nextDouble` once.)

  Parameters:
    `i` - smallest integer that can be generated
    `j` - greatest integer that can be generated
  Returns:
    the generated integer

### nextArrayOfInt

    void nextArrayOfInt(int i,
                        int j,
                        int[] u,
                        int start,
                        int n)

  Generates `n` (pseudo)random numbers from the discrete uniform distribution over the integers {i, i + 1,..., j}, using this stream and stores the result in the array `u` starting at index `start`. (Calls `nextInt` `n` times.)

  Parameters:
    `i` - smallest integer that can be generated
    `j` - greatest integer that can be generated
    `u` - array that will contain the generated values
    `start` - starting index, in the array `u`, to write integers from
    `n` - number of values being generated

Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

To submit a bug or ask questions, send an e-mail to Pierre L'Ecuyer.