# Randomization
The R language is commonly used for statistical analysis. As such, it contains a robust set of options for randomization. For specific information on sampling from probability distributions, see the documentation for distribution functions (opens new window).
# Random draws and permutations
The sample command can be used to simulate classic probability problems like drawing from an urn with and without replacement, or creating random permutations.
Note that throughout this example, set.seed is used to ensure that the example code is reproducible. However, sample will work without explicitly calling set.seed.
# Random permutation
In the simplest form, sample creates a random permutation of a vector of integers. This can be accomplished with:
set.seed(1251)
sample(x = 10)
[1] 7 1 4 8 6 3 10 5 2 9
When given no other arguments, sample returns a random permutation of the vector from 1 to x. This can be useful when trying to randomize the order of the rows in a data frame. This is a common task when creating randomization tables for trials, or when selecting a random subset of rows for analysis.
library(datasets)
set.seed(1171)
iris_rand <- iris[sample(x = 1:nrow(iris)),]
> head(iris)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1 5.1 3.5 1.4 0.2 setosa
2 4.9 3.0 1.4 0.2 setosa
3 4.7 3.2 1.3 0.2 setosa
4 4.6 3.1 1.5 0.2 setosa
5 5.0 3.6 1.4 0.2 setosa
6 5.4 3.9 1.7 0.4 setosa
> head(iris_rand)
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
145 6.7 3.3 5.7 2.5 virginica
5 5.0 3.6 1.4 0.2 setosa
85 5.4 3.0 4.5 1.5 versicolor
137 6.3 3.4 5.6 2.4 virginica
128 6.1 3.0 4.9 1.8 virginica
105 6.5 3.0 5.8 2.2 virginica
# Draws without Replacement
Using sample, we can also simulate drawing from a set with and without replacement. To sample without replacement (the default), you must provide sample with a set to be drawn from and the number of draws. The set to be drawn from is given as a vector.
set.seed(7043)
sample(x = LETTERS,size = 7)
[1] "S" "P" "J" "F" "Z" "G" "R"
Note that if the argument to size is the same as the length of the argument to x, you are creating a random permutation. Also note that you cannot specify a size greater than the length of x when doing sampling without replacement.
set.seed(7305)
sample(x = letters,size = 26)
[1] "x" "z" "y" "i" "k" "f" "d" "s" "g" "v" "j" "o" "e" "c" "m" "n" "h" "u" "a" "b" "l" "r" "w" "t" "q" "p"
sample(x = letters,size = 30)
Error in sample.int(length(x), size, replace, prob) :
cannot take a sample larger than the population when 'replace = FALSE'
This brings us to drawing with replacement.
# Draws with Replacement
To make random draws from a set with replacement, you use the replace argument to sample. By default, replace is FALSE. Setting it to TRUE means that each element of the set being drawn from may appear more than once in the final result.
set.seed(5062)
sample(x = c("A","B","C","D"),size = 8,replace = TRUE)
[1] "D" "C" "D" "B" "A" "A" "A" "A"
# Changing Draw Probabilities
By default, when you use sample, it assumes that the probability of picking each element is the same. Consider it as a basic "urn" problem. The code below is equivalent to drawing a colored marble out of an urn 20 times, writing down the color, and then putting the marble back in the urn. The urn contains one red, one blue, and one green marble, meaning that the probability of drawing each color is 1/3.
set.seed(6472)
sample(x = c("Red","Blue","Green"),
size = 20,
replace = TRUE)
Suppose that, instead, we wanted to perform the same task, but our urn contains 2 red marbles, 1 blue marble, and 1 green marble. One option would be to change the argument we send to x to add an additional Red. However, a better choice is to use the prob argument to sample.
The prob argument accepts a vector with the probability of drawing each element. In our example above, the probability of drawing a red marble would be 1/2, while the probability of drawing a blue or a green marble would be 1/4.
set.seed(28432)
sample(x = c("Red","Blue","Green"),
size = 20,
replace = TRUE,
prob = c(0.50,0.25,0.25))
Counter-intuitively, the argument given to prob does not need to sum to 1. R will always transform the given arguments into probabilities that total to 1. For instance, consider our above example of 2 Red, 1 Blue, and 1 Green. You can achieve the same results as our previous code using those numbers:
set.seed(28432)
frac_prob_example <- sample(x = c("Red","Blue","Green"),
size = 200,
replace = TRUE,
prob = c(0.50,0.25,0.25))
set.seed(28432)
numeric_prob_example <- sample(x = c("Red","Blue","Green"),
size = 200,
replace = TRUE,
prob = c(2,1,1))
> identical(frac_prob_example,numeric_prob_example)
[1] TRUE
The major restriction is that you cannot set all the probabilities to be zero, and none of them can be less than zero.
You can also utilize prob when replace is set to FALSE. In that situation, after each element is drawn, the proportions of the prob values for the remaining elements give the probability for the next draw. In this situation, you must have enough non-zero probabilities to reach the size of the sample you are drawing. For example:
set.seed(21741)
sample(x = c("Red","Blue","Green"),
size = 2,
replace = FALSE,
prob = c(0.8,0.19,0.01))
In this example, Red is drawn in the first draw (as the first element). There was an 80% chance of Red being drawn, a 19% chance of Blue being drawn, and a 1% chance of Green being drawn.
For the next draw, Red is no longer in the urn. The total of the probabilities among the remaining items is 20% (19% for Blue and 1% for Green). For that draw, there is a 95% chance the item will be Blue (19/20) and a 5% chance it will be Green (1/20).
# Setting the seed
The set.seed function is used to set the random seed for all randomization functions. If you are using R to create a randomization that you want to be able to reproduce, you should use set.seed first.
set.seed(1643)
samp1 <- sample(x = 1:5,size = 200,replace = TRUE)
set.seed(1643)
samp2 <- sample(x = 1:5,size = 200,replace = TRUE)
> identical(x = samp1,y = samp2)
[1] TRUE
Note that parallel processing requires special treatment of the random seed, described more elsewhere.
# Remarks
Users who are coming from other programming languages may be confused by the lack of a rand function equivalent to what they may have experienced before. Basic random number generation is done using the r* family of functions for each distribution (see the link above). Random numbers drawn uniformly from a range can be generated using runif, for "random uniform". Since this also looks suspiciously like "run if", it is often hard to figure out for new R users.