Random Numbers in R: rnorm, runif, sample and set.seed

set.seed() Comes First

Random draws that change on every run are useless for teaching, grading, debugging, or science - if your simulation says 0.146 today and 0.153 tomorrow, which number goes in the report? set.seed() fixes the generator's starting point, making the entire stream of "randomness" that follows exactly repeatable:

set.seed(42)
print(rnorm(3))

set.seed(42)          # same seed...
print(rnorm(3))       # ...same "random" numbers

set.seed(7)           # different seed, different stream
print(rnorm(3))

Same seed, identical draws, every time, on every machine. The numbers are pseudo-random: a deterministic sequence engineered to pass every statistical test of randomness, with the seed choosing where in the sequence you start. The seed value itself carries no meaning - 42, 7, 20260807 - pick anything; just write it down. The habit to build: one set.seed() at the top of any script that uses randomness. (Note that consuming draws advances the state, so the order of calls matters to reproducibility too.)

The d/p/q/r System: One Table Decodes the Whole Library

R names every distribution function as prefix + family, and once you see the grid you can read the entire stats library:

Prefix	Question it answers	Normal example
r	Give me random draws	rnorm(5)
d	Density: how high is the curve at x?	dnorm(0)
p	Probability: P(X ≤ x)?	pnorm(1.96)
q	Quantile: which x sits at this percentile?	qnorm(0.975)

p and q are inverses, and they're the pair you met in confidence intervals as qt(0.975, df):

print(pnorm(1.96))      # P(Z <= 1.96), about 0.975
print(qnorm(0.975))     # which z has 97.5% below it? About 1.96
print(dnorm(0))         # height of the bell curve at its peak

Swap the family name and everything carries over: runif/dunif/punif/qunif, rbinom/..., rpois/..., rt/..., rexp/.... Learn four prefixes, get dozens of distributions.

rnorm(): Normal Draws

rnorm(n, mean, sd) draws from a bell curve - the workhorse for simulating measurement-like data:

set.seed(42)
iq <- rnorm(1000, mean = 100, sd = 15)

print(mean(iq))
print(sd(iq))
print(mean(iq > 130))   # share more than 2 sd above the mean

The sample mean and sd land near - not on - 100 and 15: that gap is sampling noise, shrinking as n grows. The last line is a trick worth stealing: mean() of a logical vector is the proportion of TRUEs, and the share beyond 130 comes out near the theoretical 1 - pnorm(130, 100, 15) ≈ 2.3%. Defaults are mean = 0, sd = 1 (the standard normal). A histogram of iq shows the familiar bell.

runif(), rbinom(), rpois()

Three more families cover most simulation needs:

set.seed(42)

print(runif(5))                    # uniform on [0, 1]
print(runif(3, min = 10, max = 20))

print(rbinom(8, size = 10, prob = 0.5))   # successes in 10 coin flips, 8 times

print(rpois(8, lambda = 3))        # event counts averaging 3 per interval

runif() spreads draws evenly across a range ("uniform," not "run if" - everyone misreads it once). rbinom(n, size, prob) simulates n experiments of size trials each, returning the success count of each - so each value above is heads out of 10 flips. rpois(n, lambda) generates counts of events that occur independently at a known average rate: support tickets per hour, typos per page.

sample(): Sampling and Shuffling

Where the r* functions invent values from a distribution, sample() draws from values you already have:

set.seed(42)

print(sample(1:10, 3))                              # 3 values, no repeats
print(sample(c("win", "lose"), 5, replace = TRUE))  # 5 draws, repeats allowed
print(sample(1:5))                                  # no size = shuffle everything

The replace argument is the whole story: FALSE (default) deals cards - each value can appear once, and asking for more than you have is an error; TRUE rolls dice - every draw resets. Sampling with replacement from your own data is the engine of bootstrapping. Called with just a vector, sample(x) returns a random permutation - the idiom for shuffling.

Sampling rows of a data frame uses sample() inside row indexing:

set.seed(42)

random_cars <- mtcars[sample(nrow(mtcars), 5), ]
print(random_cars[, c("mpg", "wt", "hp")])

sample(nrow(mtcars), 5) picks 5 random row numbers; the indexing pulls those rows. This is the standard move for spot-checking a big dataset or splitting train/test sets.

A Mini Monte Carlo Simulation

Here's the payoff of the whole toolkit. Question: a process yields measurements distributed N(100, 15); you average 10 of them - what's the probability that average exceeds 105? Instead of deriving the answer, simulate it - do the experiment 10,000 times and count:

set.seed(42)

trial <- function() {
  mean(rnorm(10, mean = 100, sd = 15)) > 105
}

results <- replicate(10000, trial())
print(mean(results))

# The exact answer, for comparison:
print(1 - pnorm(105, mean = 100, sd = 15 / sqrt(10)))

The simulation lands within a few thousandths of the exact value (about 0.146). That's Monte Carlo in one breath: write one trial as a function, replicate() it thousands of times, take mean() of the successes. The exact answer existed here because the setup was textbook-simple - the moment the question gets messy (weird distributions, max of correlated draws, a rule-based game), the analytic route closes and the simulation recipe keeps working unchanged. Notice the 15 / sqrt(10) in the check: means wobble less than individual draws - the same square-root law that drives confidence interval widths.

Simulation-Grade, Not Secret-Grade

One boundary to respect: R's default generator (Mersenne Twister) is built for statistical quality and speed, not secrecy. Its output is deterministic given the seed and its internal state can be reconstructed from observed output - fatal flaws for passwords, tokens, or anything security-adjacent. For simulation, bootstrapping, and teaching it's excellent; for cryptography, use a purpose-built library (e.g. the openssl package), never sample() or runif().

What You Take Away

• set.seed() once at the top makes every "random" result reproducible - same seed, same draws.
• The d/p/q/r prefixes decode the whole distribution library: random draw, density, cumulative probability, quantile.
• rnorm(n, mean, sd), runif(n, min, max), rbinom(n, size, prob), rpois(n, lambda) cover most simulation needs.
• sample() draws from your own values - replace = TRUE for dice, default for cards, no size to shuffle; df[sample(nrow(df), k), ] samples rows.
• Monte Carlo = one-trial function + replicate() + mean() - the recipe that answers probability questions math can't conveniently reach.
• R's RNG is for simulation, not cryptography.

Next up: debugging - what R's error messages actually mean and how to read a traceback.