# Random

##### Random Number Generation

`.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 Rversion (for reproducibility).

`set.seed`

is the recommended way to specify seeds.

- Keywords
- distribution, sysdata

##### 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"`

.
[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object]

`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.0 (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

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"`

.

##### Value

`.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`0`

).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 Rversion.`set.seed`

returns`NULL`

, invisibly.

##### Note

Initially, there is no seed; a new one is created from the current time and 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.)

##### 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

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

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 formerly at `http://www.math.keio.ac.jp/~matumoto/emt.html`

.
Now see

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.

##### See Also

`sample`

for random sampling with and without replacement.

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

##### Examples

`library(base)`

```
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 package base, version 3.3, License: Part of R @VERSION@*