The `dqrng`

package provides several fast random number
generators together with fast functions for generating random numbers
according to a uniform, normal and exponential distribution. These
functions are modeled after the `base`

functions
`set.seed`

, `RNGkind`

, `runif`

,
`rnorm`

, and `rexp`

. However, note that the functions
provided here do not accept vector arguments for the number of observations
as well as the parameters describing the distribution functions. Please see
`register_methods`

if you need this functionality.

`dqrrademacher`

uses a fast algorithm to generate random
Rademacher variables (-1 and 1 with equal probability). To do so, it
generates a random 64 bit integer and then uses each bit to generate
a 0/1 variable. This generates 64 integers per random number generation.

`dqrng_get_state`

and `dqrng_set_state`

can be used to get and set
the RNG's internal state. The character vector should not be manipulated directly.

```
dqRNGkind(kind, normal_kind = "ignored")
dqrng_get_state()
dqrng_set_state(state)
dqrunif(n, min = 0, max = 1)
dqrnorm(n, mean = 0, sd = 1)
dqrexp(n, rate = 1)
dqrrademacher(n)
dqset.seed(seed, stream = NULL)
```

- kind
string specifying the RNG (see details)

- normal_kind
ignored; included for compatibility with

`RNGkind`

- state
character vector representation of the RNG's internal state

- n
number of observations

- min
lower limit of the uniform distribution

- max
upper limit of the uniform distribution

- mean
mean value of the normal distribution

- sd
standard deviation of the normal distribution

- rate
rate of the exponential distribution

- seed
integer scalar to seed the random number generator, or an integer vector of length 2 representing a 64-bit seed. Maybe

`NULL`

, see details.- stream
integer used for selecting the RNG stream; either a scalar or a vector of length 2

`dqrunif`

, `dqrnorm`

, and `dqrexp`

return a numeric vector
of length `n`

. `dqrrademacher`

returns an integer vector of length `n`

.
`dqrng_get_state`

returns a character vector representation of the RNG's internal state.

Supported RNG kinds:

- pcg64
The default 64 bit variant from the PCG family developed by Melissa O'Neill. See https://www.pcg-random.org/ for more details.

- Xoroshiro128++ and Xoshiro256++
RNGs developed by David Blackman and Sebastiano Vigna. See https://prng.di.unimi.it/ for more details. The older generators Xoroshiro128+ and Xoshiro256+ should be used only for backwards compatibility.

- Threefry
The 64 bit version of the 20 rounds Threefry engine as provided by

`sitmo-package`

Xoroshiro128++ is the default since it is fast, small and has good statistical properties.

The functions `dqrnorm`

and `dqrexp`

use the Ziggurat algorithm as
provided by `boost.random`

.

See `generateSeedVectors`

for rapid generation of integer-vector
seeds that provide 64 bits of entropy. These allow full exploration of
the state space of the 64-bit RNGs provided in this package.

If the provided `seed`

is `NULL`

, a seed is generated from R's RNG
without state alteration.

```
library(dqrng)
# Set custom RNG.
dqRNGkind("Xoshiro256++")
# Use an integer scalar to set a seed.
dqset.seed(42)
# Use integer scalars to set a seed and the stream.
dqset.seed(42, 123)
# Use an integer vector to set a seed.
dqset.seed(c(31311L, 24123423L))
# Use an integer vector to set a seed and a scalar to select the stream.
dqset.seed(c(31311L, 24123423L), 123)
# Random sampling from distributions.
dqrunif(5, min = 2, max = 10)
#> [1] 6.671009 6.819399 5.809120 7.420207 9.432123
dqrexp(5, rate = 4)
#> [1] 0.3195102 0.1255143 0.3573952 0.7278543 0.1367707
dqrnorm(5, mean = 5, sd = 3)
#> [1] 2.479324 2.667785 4.365715 7.538162 4.144456
# get and restore the state
(state <- dqrng_get_state())
#> [1] "xoshiro256++" "9418222475388072763" "14697922287555972744"
#> [4] "17803728035708903246" "3873340903374287490"
dqrunif(5)
#> [1] 0.7461946 0.3834459 0.5778508 0.3488599 0.4695689
dqrng_set_state(state)
dqrunif(5)
#> [1] 0.7461946 0.3834459 0.5778508 0.3488599 0.4695689
```