Random Number Generation

In this vignette, you will learn how to generate random numbers in {anvl}, which is different from base R, where random number generation uses a global state (.Random.seed) that is automatically updated after each call:

set.seed(42)
.Random.seed[2:4]
#> [1]        624  507561766 1260545903
rnorm(3)
#> [1]  1.3709584 -0.5646982  0.3631284
.Random.seed[2:4]
#> [1]           6 -1577024373  1699409082
rnorm(3)
#> [1]  0.6328626  0.4042683 -0.1061245
.Random.seed[2:4]
#> [1]          12 -1577024373  1699409082

In {anvl}, the random state must be explicitly passed around. This is because we are following a functional programming paradigm where functions are pure and don’t have side effects.

Note: This explicit state-passing behavior might change in the future to provide a more R-like experience, but for now you need to manage the state yourself.

To generate random numbers, you first need to create an initial RNG state, which is simply a ui64[2]. You can convert a seed into a state using nv_rng_state():

library(anvl)
state <- nv_rng_state(42L)
state
#> AnvlArray
#>  42
#>   0
#> [ CPUui64{2} ]

The main functions for generating random numbers are nv_runif(), nv_rnorm(), nv_rbinom(), nv_sample_int(), and nv_sample(). All those functions return a named list of two elements:

1. state – the new RNG state, to be used for subsequent random number generation.
2. values – the generated random numbers.

Let’s generate some uniform random numbers:

result <- nv_runif(state, dtype = "f32", shape = c(2, 3))
result$state
#> AnvlArray
#>  42
#>   3
#> [ CPUui64{2} ]
result$values
#> AnvlArray
#>  0.8690 0.1506 0.5203
#>  0.3103 0.9928 0.1065
#> [ CPUf32{2,3} ]

For normally distributed random numbers:

result <- nv_rnorm(state, shape = c(2, 3), mean = 0, sd = 1)
result$values
#> AnvlArray
#>  -0.0675  1.9457  1.2002
#>   0.9489 -0.5255  0.0008
#> [ CPUf32{2,3} ]

mean and sd are arrayish, so they may vary across the sample.

sds <- nv_matrix(c(0.01, 0.1, 1, 10, 100, 1000), nrow = 2)
nv_rnorm(state, shape = c(2, 3), sd = sds)$values
#> AnvlArray
#>   -0.0007   1.9457 120.0167
#>    0.0949  -5.2551   0.7665
#> [ CPUf32{2,3} ]

To draw integers, use nv_sample_int(), the counterpart to R’s sample.int():

# roll six dice
nv_sample_int(6L, state, 6L)$values
#> AnvlArray
#>  4
#>  6
#>  2
#>  5
#>  1
#>  2
#> [ CPUi32{6} ]

nv_sample() draws from an arbitrary population instead. Unlike R’s sample(), its population argument is never overloaded with a count, so nv_sample(5L, state, nv_array(6)) samples from the population 6 rather than from 1:6:

population <- nv_array(c(10, 20, 30))
nv_sample(8L, state, population)$values
#> AnvlArray
#>  20
#>  30
#>  10
#>  30
#>  10
#>  10
#>  10
#>  20
#> [ CPUf32{8} ]

One thing to avoid is to reuse the same state for multiple calls as done in the example below:

result1 <- nv_runif(state, dtype = "f32", shape = 3L)
result2 <- nv_runif(state, dtype = "f32", shape = 3L)
list(first = result1$values, second = result2$values)
#> $first
#> AnvlArray
#>  0.8690
#>  0.3103
#>  0.1506
#> [ CPUf32{3} ] 
#> 
#> $second
#> AnvlArray
#>  0.8690
#>  0.3103
#>  0.1506
#> [ CPUf32{3} ]

As you can see, both calls produced identical random numbers because we used the same state for both. To get different random numbers in subsequent calls, you need to pass the new state returned by the previous call:

result1 <- nv_runif(state, dtype = "f32", shape = 3L)
new_state <- result1$state
result2 <- nv_runif(new_state, dtype = "f32", shape = 3L)
list(first = result1$values, second = result2$values)
#> $first
#> AnvlArray
#>  0.8690
#>  0.3103
#>  0.1506
#> [ CPUf32{3} ] 
#> 
#> $second
#> AnvlArray
#>  0.5203
#>  0.1065
#>  0.2499
#> [ CPUf32{3} ]

Now we get different random numbers because we properly propagated the state.