# Random {base}

### Description

`.Random.seed`

is an integer vector, containing the random number generator (RNG) **state** for random number generation in R. It can be saved and restored, but should not be altered by the user.

`RNGkind`

is a more friendly interface to query or set the kind of RNG in use.

`RNGversion`

can be used to set the random generators as they were in an earlier R version (for reproducibility).

`set.seed`

is the recommended way to specify seeds.

### Usage

```
.Random.seed <- c(rng.kind, n1, n2, ...)
RNGkind(kind = NULL, normal.kind = NULL)
RNGversion(vstr)
set.seed(seed, kind = NULL, normal.kind = NULL)
```

### Arguments

- kind
- character or
`NULL`

. If`kind`

is a character string, set R's RNG to the kind desired. Use`"default"`

to return to the R default. See ‘Details’ for the interpretation of`NULL`

. - normal.kind
- character string or
`NULL`

. If it is a character string, set the method of Normal generation. Use`"default"`

to return to the R default.`NULL`

makes no change. - seed
- a single value, interpreted as an integer, or
`NULL`

(see ‘Details’). - vstr
- a character string containing a version number, e.g.,
`"1.6.2"`

- rng.kind
- integer code in
`0:k`

for the above`kind`

. - n1, n2, ...
- integers. See the details for how many are required (which depends on
`rng.kind`

).

### Details

The currently available RNG kinds are given below. `kind`

is partially matched to this list. The default is `"Mersenne-Twister"`

.

`"Wichmann-Hill"`

- The seed,
`.Random.seed[-1] == r[1:3]`

is an integer vector of length 3, where each`r[i]`

is in`1:(p[i] - 1)`

, where`p`

is the length 3 vector of primes,`p = (30269, 30307, 30323)`

. The Wichmann--Hill generator has a cycle length of 6.9536e12 (=`prod(p-1)/4`

, see*Applied Statistics*(1984)**33**, 123 which corrects the original article). `"Marsaglia-Multicarry"`

:- A
*multiply-with-carry*RNG is used, as recommended by George Marsaglia in his post to the mailing list ‘sci.stat.math’. It has a period of more than 2^60 and has passed all tests (according to Marsaglia). The seed is two integers (all values allowed). `"Super-Duper"`

:- Marsaglia's famous Super-Duper from the 70's. This is the original version which does
*not*pass the MTUPLE test of the Diehard battery. It has a period of for most initial seeds. The seed is two integers (all values allowed for the first seed: the second must be odd).

We use the implementation by Reeds et al. (1982--84).

The two seeds are the Tausworthe and congruence long integers, respectively. A one-to-one mapping to S's `.Random.seed[1:12]`

is possible but we will not publish one, not least as this generator is **not** exactly the same as that in recent versions of S-PLUS.

`"Mersenne-Twister"`

:`"Knuth-TAOCP-2002"`

:`"Knuth-TAOCP"`

:The 2002 version was not backwards compatible with the earlier version: the initialization of the GFSR from the seed was altered. R did not allow you to choose consecutive seeds, the reported ‘weakness’, and already scrambled the seeds.

Initialization of this generator is done in interpreted R code and so takes a short but noticeable time.

`"L'Ecuyer-CMRG"`

: The 6 elements of the seed are internally regarded as 32-bit unsigned integers. Neither the first three nor the last three should be all zero, and they are limited to less than `4294967087`

and `4294944443`

respectively.

This is not particularly interesting of itself, but provides the basis for the multiple streams used in package parallel.

`"user-supplied"`

:`Random.user`

for details. `normal.kind`

can be `"Kinderman-Ramage"`

, `"Buggy Kinderman-Ramage"`

(not for `set.seed`

), `"Ahrens-Dieter"`

, `"Box-Muller"`

, `"Inversion"`

(the default), or `"user-supplied"`

. (For inversion, see the reference in `qnorm`

.) The Kinderman-Ramage generator used in versions prior to 1.7.1 (now called `"Buggy"`

) had several approximation errors and should only be used for reproduction of old results. The `"Box-Muller"`

generator is stateful as pairs of normals are generated and returned sequentially. The state is reset whenever it is selected (even if it is the current normal generator) and when `kind`

is changed.

`set.seed`

uses a single integer argument to set as many seeds as are required. It is intended as a simple way to get quite different seeds by specifying small integer arguments, and also as a way to get valid seed sets for the more complicated methods (especially `"Mersenne-Twister"`

and `"Knuth-TAOCP"`

). There is no guarantee that different values of `seed`

will seed the RNG differently, although any exceptions would be extremely rare. If called with `seed = NULL`

it re-initializes (see ‘Note’) as if no seed had yet been set.

The use of `kind = NULL`

or `normal.kind = NULL`

in `RNGkind`

or `set.seed`

selects the currently-used generator (including that used in the previous session if the workspace has been restored): if no generator has been used it selects `"default"`

.

### Values

`.Random.seed`

is an `integer`

vector whose first element *codes* the kind of RNG and normal generator. The lowest two decimal digits are in `0:(k-1)`

where `k`

is the number of available RNGs. The hundreds represent the type of normal generator (starting at ` `

).

In the underlying C, `.Random.seed[-1]`

is `unsigned`

; therefore in R `.Random.seed[-1]`

can be negative, due to the representation of an unsigned integer by a signed integer.

`RNGkind`

returns a two-element character vector of the RNG and normal kinds selected *before* the call, invisibly if either argument is not `NULL`

. A type starts a session as the default, and is selected either by a call to `RNGkind`

or by setting `.Random.seed`

in the workspace.

`RNGversion`

returns the same information as `RNGkind`

about the defaults in a specific R version.

`set.seed`

returns `NULL`

, invisibly.

### References

Ahrens, J. H. and Dieter, U. (1973) Extensions of Forsythe's method for random sampling from the normal distribution. *Mathematics of Computation* **27**, 927-937.

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) *The New S Language*. Wadsworth & Brooks/Cole. (`set.seed`

, storing in `.Random.seed`

.)

Box, G. E. P. and Muller, M. E. (1958) A note on the generation of normal random deviates. *Annals of Mathematical Statistics* **29**, 610--611.

De Matteis, A. and Pagnutti, S. (1993) *Long-range Correlation Analysis of the Wichmann-Hill Random Number Generator*, Statist. Comput., **3**, 67--70.

Kinderman, A. J. and Ramage, J. G. (1976) Computer generation of normal random variables. *Journal of the American Statistical Association* **71**, 893-896.

Knuth, D. E. (1997) *The Art of Computer Programming.* Volume 2, third edition.

Source code at http://www-cs-faculty.stanford.edu/~knuth/taocp.html.

Knuth, D. E. (2002) *The Art of Computer Programming.* Volume 2, third edition, ninth printing.

See http://Sunburn.Stanford.EDU/~knuth/news02.html.

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

Marsaglia, G. (1997) *A random number generator for C.* Discussion paper, posting on Usenet newsgroup `sci.stat.math`

on September 29, 1997.

Marsaglia, G. and Zaman, A. (1994) Some portable very-long-period random number generators. *Computers in Physics*, **8**, 117--121.

Matsumoto, M. and Nishimura, T. (1998) Mersenne Twister: A 623-dimensionally equidistributed uniform pseudo-random number generator, *ACM Transactions on Modeling and Computer Simulation*, **8**, 3--30.

Source code at http://www.math.keio.ac.jp/~matumoto/emt.html.

Reeds, J., Hubert, S. and Abrahams, M. (1982--4) C implementation of SuperDuper, University of California at Berkeley. (Personal communication from Jim Reeds to Ross Ihaka.)

Wichmann, B. A. and Hill, I. D. (1982) *Algorithm AS 183: An Efficient and Portable Pseudo-random Number Generator*, Applied Statistics, **31**, 188--190; Remarks: **34**, 198 and **35**, 89.

### Note

Initially, there is no seed; a new one is created from the current time (and since R 2.14.0, the process ID) when one is required. Hence different sessions will give different simulation results, by default. However, the seed might be restored from a previous session if a previously saved workspace is restored.

`.Random.seed`

saves the seed set for the uniform random-number generator, at least for the system generators. It does not necessarily save the state of other generators, and in particular does not save the state of the Box--Muller normal generator. If you want to reproduce work later, call `set.seed`

(preferably with explicit values for `kind`

and `normal.kind`

) rather than set `.Random.seed`

.

The object `.Random.seed`

is only looked for in the user's workspace.

Do not rely on randomness of low-order bits from RNGs. Most of the supplied uniform generators return 32-bit integer values that are converted to doubles, so they take at most 2^32 distinct values and long runs will return duplicated values (Wichmann-Hill is the exception, and all give at least 30 varying bits.)

### See Also

`sample`

for random sampling with and without replacement.

Distributions for functions for random-variate generation from standard distributions.

### Examples

require(stats) ## the default random seed is 626 integers, so only print a few runif(1); .Random.seed[1:6]; runif(1); .Random.seed[1:6] ## If there is no seed, a "random" new one is created: rm(.Random.seed); runif(1); .Random.seed[1:6] ok <- RNGkind() RNGkind("Wich") # (partial string matching on 'kind') ## This shows how 'runif(.)' works for Wichmann-Hill, ## using only R functions: p.WH <- c(30269, 30307, 30323) a.WH <- c( 171, 172, 170) next.WHseed <- function(i.seed = .Random.seed[-1]) { (a.WH * i.seed) %% p.WH } my.runif1 <- function(i.seed = .Random.seed) { ns <- next.WHseed(i.seed[-1]); sum(ns / p.WH) %% 1 } rs <- .Random.seed (WHs <- next.WHseed(rs[-1])) u <- runif(1) stopifnot( next.WHseed(rs[-1]) == .Random.seed[-1], all.equal(u, my.runif1(rs)) ) ## ---- .Random.seed RNGkind("Super") # matches "Super-Duper" RNGkind() .Random.seed # new, corresponding to Super-Duper ## Reset: RNGkind(ok[1]) ## ---- sum(duplicated(runif(1e6))) # around 110 for default generator ## and we would expect about almost sure duplicates beyond about qbirthday(1 - 1e-6, classes = 2e9) # 235,000

Documentation reproduced from R 3.0.2. License: GPL-2.