This is an R re-implementation of Pierre L'Ecuyer's ‘RngStreams’ multiple streams of pseudo-random numbers.

```
nextRNGStream(seed)
nextRNGSubStream(seed)
```clusterSetRNGStream(cl = NULL, iseed)
mc.reset.stream()

seed

An integer vector of length 7 as given by
`.Random.seed`

when the `"L'Ecuyer-CMRG"` RNG is in use.
See `RNG`

for the valid values.

cl

A cluster from this package or package snow, or (if
`NULL`

) the registered cluster.

iseed

An integer to be supplied to `set.seed`

, or
`NULL`

not to set reproducible seeds.

For `nextRNGStream`

and `nextRNGSubStream`

,
a value which can be assigned to `.Random.seed`

.

The ‘RngStream’ interface works with (potentially) multiple streams of pseudo-random numbers: this is particularly suitable for working with parallel computations since each task can be assigned a separate RNG stream.

This uses as its underlying generator `RNGkind("L'Ecuyer-CMRG")`

,
of L'Ecuyer (1999), which has a seed vector of 6 (signed) integers and a
period of around \(2^{191}\). Each ‘stream’ is a
subsequence of the period of length \(2^{127}\) which is in
turn divided into ‘substreams’ of length \(2^{76}\).

The idea of L'Ecuyer *et al* (2002) is to use a separate stream
for each of the parallel computations (which ensures that the random
numbers generated never get into to sync) and the parallel
computations can themselves use substreams if required. The original
interface stores the original seed of the first stream, the original
seed of the current stream and the current seed: this could be
implemented in R, but it is as easy to work by saving the relevant
values of `.Random.seed`

: see the examples.

`clusterSetRNGStream`

selects the `"L'Ecuyer-CMRG"`

RNG and
then distributes streams to the members of a cluster, optionally
setting the seed of the streams by `set.seed(iseed)`

(otherwise
they are set from the current seed of the master process: after
selecting the L'Ecuyer generator).

Calling `mc.reset.stream()`

after setting the L'Ecuyer random
number generator and seed makes runs from
`mcparallel(mc.set.seed = TRUE)`

reproducible. This is
done internally in `mclapply`

and `pvec`

.
(Note that it does not set the seed in the master process, so does not
affect the fallback-to-serial versions of these functions.)

L'Ecuyer, P. (1999).
Good parameters and implementations for combined multiple recursive
random number generators.
*Operations Research*, **47**, 159--164.
10.1287/opre.47.1.159.

L'Ecuyer, P., Simard, R., Chen, E. J. and Kelton, W. D. (2002).
An object-oriented random-number package with many long streams
and substreams.
*Operations Research*, **50**, 1073--1075.
10.1287/opre.50.6.1073.358.

`RNG`

for fuller details of R's built-in random number
generators.

The vignette for package parallel.

```
# NOT RUN {
RNGkind("L'Ecuyer-CMRG")
set.seed(123)
(s <- .Random.seed)
## do some work involving random numbers.
nextRNGStream(s)
nextRNGSubStream(s)
# }
```

Run the code above in your browser using DataCamp Workspace