Great question! Let's break down how R's runif() works under the hood, walk through building our own version, and dig into its internal implementation in R.

At its heart, runif() is a wrapper around R's pseudo-random number generator (PRNG) that transforms raw random values into a uniform distribution. Here's the high-level flow:

• Step 1: Generate raw pseudo-random integers
  R uses a PRNG (default is the Mersenne Twister algorithm, mt19937) to generate a sequence of deterministic integers. These integers are uniformly distributed across a large range (e.g., 0 to 2^32-1 for Mersenne Twister).
• Step 2: Normalize to [0,1)
  The raw integers are divided by their maximum possible value (like 2^32) to scale them into floating-point numbers between 0 (inclusive) and 1 (exclusive).
• Step 3: Scale to your desired range
  If you specify min and max, runif() applies a linear transformation: min + (max - min) * normalized_value. This shifts and stretches the [0,1) range to your target interval.

A quick note: Since it's a continuous uniform distribution, the theoretical probability of getting exactly min or max is zero (though floating-point precision might occasionally produce values very close to these bounds).

To make this concrete, let's build a simplified version using a basic PRNG (Linear Congruential Generator, LCG) — it's easier to understand than Mersenne Twister, though less robust for production use.

Step 1: Implement a Simple PRNG #

First, we'll write an LCG to generate normalized [0,1) values:

# Linear Congruential Generator (LCG) for [0,1) values
lcg_generator <- function(n, seed = 12345) {
  # LCG parameters (from Numerical Recipes)
  a <- 1664525
  c <- 1013904223
  m <- 2^32
  
  current_seed <- seed
  random_values <- numeric(n)
  
  for (i in 1:n) {
    current_seed <- (a * current_seed + c) %% m
    random_values[i] <- current_seed / m  # Normalize to [0,1)
  }
  
  random_values
}

Step 2: Wrap It into a runif Clone #

Now we'll add the range scaling logic, just like runif():

# Custom uniform random number function
my_runif <- function(n, min = 0, max = 1) {
  # Validate input
  if (min >= max) {
    stop("Error: 'min' must be less than 'max'")
  }
  
  # Get normalized [0,1) values from LCG
  uniform_01 <- lcg_generator(n)
  
  # Scale to target range
  min + (max - min) * uniform_01
}

Test It Out #

Compare it to R's built-in runif() (note: different PRNGs mean different sequences, but both follow a uniform distribution):

# Test built-in runif
set.seed(123)
head(runif(5, 2, 5))
# Output: [1] 2.439524 3.769823 2.070508 3.129287 4.939013

# Test our custom function
head(my_runif(5, 2, 5, seed = 123))
# Output: [1] 2.546088 2.765517 3.070837 3.994290 4.899825

R's runif() isn't written in R — its core logic lives in C code for speed. Here's a peek under the hood:

1. RNG Initialization: When you call runif() for the first time, R checks if the PRNG is initialized. If not, it uses a system-generated seed (or your manually set seed via set.seed()).
2. Call the PRNG: It invokes the current PRNG's C function (e.g., mt_unif() for Mersenne Twister) to generate raw normalized [0,1) values.
3. Range Transformation: The C code applies the same linear scaling (min + (max - min) * u) we used in our custom function, with extra checks for edge cases (like min == max, which returns a vector of min values).
4. Return to R: The generated C-level numeric vector is converted to an R vector and returned to the user.

Also, R lets you switch PRNGs with RNGkind() — runif() automatically adapts to the active generator, which is why it works seamlessly with different random number algorithms.

内容的提问来源于stack exchange，提问作者Yugandhar Shilawane