The apply functions are not just for compactness of code, but also for speed. If speed is an issue, such as when working with large data sets or long-running simulations, one must avoid explicit loops (read 'for' loop, or 'while' loop) as much as possible, because with apply() function and its variants, R can do them a lot faster than you can.
The apply Function
The apply() function applies a simple function over dimensions of a data structure. The apply() function has the following structure:
1> args(apply)
2function (X, MARGIN, FUN, ...)
3
- X is any R structure with dimensions (matrix, data frame, array .. NOT lists or vectors)
- MARGIN is the dimension number (1 = rows, 2 = columns)
- FUN is the function to apply (example:
mean())
- ... represents additional arguments to the function
Example
Let's define a simple matrix myMatrix which we will use to understand the apply() function. The rpois() function is a built-in function that can be used to simulate N independent Poisson random variables. For example, we can generate 30 Poisson random numbers with parameter λ = 3 as follows: > rpois(30, 3)
1> myMatrix <- matrix(rpois(30,3),5)
2> myMatrix
3 [,1] [,2] [,3] [,4] [,5] [,6]
4[1,] 3 1 7 4 4 3
5[2,] 2 3 5 5 2 3
6[3,] 2 5 1 2 2 1
7[4,] 3 5 1 4 5 3
8[5,] 0 0 4 2 1 2
9>
10
Now let's take a few examples to understand how we can use the apply() function.
Calculate the sum of each row.
1> apply(myMatrix,1,sum)
2[1] 22 20 13 21 9
3
The apply function applied the function sum to each row (specified with MARGIN=1) of the matrix myMatrix.
We can do the same column-wise by changing MARGIN=2, as shown below:
1> apply(myMatrix,2,sum)
2[1] 10 14 18 17 14 12
3
The following two examples show row minima and column maxima:
1> apply(myMatrix,1,min) #row minima
2[1] 1 2 1 1 0
3> apply(myMatrix,2,max) #col maxima
4[1] 3 5 7 5 5 3
5>
6
The apply function can be used with matrixes, arrays, and data frames. There are other functions which can be applied to lists and vectors.
The lapply() Function
The analog of apply() for lists is lapply(). It applies the given function to all elements of the specified list.
Example
1> lapply(list(1:5,20:26),median)
2[[1]]
3[1] 3
4[[2]]
5[1] 23
6>
7
As you can see, the lapply() function returns a list (always). You can use the unlist() to flatten the list and produce a simple vector.
1> unlist(lapply(list(1:5,20:26),median))
2[1] 3 23
3
We can also use the apply family of functions on our own custom functions as shown below:
1#The custom oilCost function - oil cost for two gallons
2oilCost <− function ( x=0 ) {
3 output <− x*2
4}
5#sample vector containing oil prices for the past 5 days (per gallon)
6oil_price <- c(10,9,8,9,11)
7#Use apply function to calculate two gallon oil cost each day
8lapply(oil_price,oilCost)
9
Result will be a list with cost for two gallons.
1> lapply(oil_price,oilCost)
2[[1]]
3[1] 20
4[[2]]
5[1] 18
6[[3]]
7[1] 16
8[[4]]
9[1] 18
10[[5]]
11[1] 22
12>
13
Let's say our custom function allows us to specify the quantity (instead of the fixed quantity of 2). We can modify our function as follows:
1#The custom oilCost function - oil cost for a specified quantity of gallons
2oilCost <− function ( x,qty ) {
3 output <− x*qty
4}
5#sample vector containing oil prices for the past 5 days (per gallon)
6oil_price <- c(10,9,8,9,11)
7#Use apply function to calculate three gallon oil cost each day
8unlist(lapply(oil_price,oilCost,qty=3))
9#Use apply function to calculate four gallon oil cost each day
10unlist(lapply(oil_price,oilCost,qty=4))
11
The function oilCost is applied to the vector oil_price and the qty is supplied as the third argument.
Result:
1> #Use apply function to calculate three gallon oil cost each day
2> unlist(lapply(oil_price,oilCost,qty=3))
3[1] 30 27 24 27 33
4>
5> #Use apply function to calculate three gallon oil cost each day
6> unlist(lapply(oil_price,oilCost,qty=4))
7[1] 40 36 32 36 44
8
The sapply() Function
As we saw, the lapply function takes a list or a vector, but always returns a list. This is because the input list can have different elements of different classes. That's why the output must be a list to accomodate output elements having different classes. However, there are many scenarios where all the elements of the output are of the same class (e.g. integer), and we would rather get the output as a vector. Earlier we achieved it using the unlist function. However, the sapply is a better choice as it automatically does this for us. It takes a list or a vector as an input and returns a vector or a matrix when possible. internally, it calls lapply and simplifies the output. The following example shows the difference between lapply and sapply.
1> myList <- list(Pois = rpois(10,3), Norm = rnorm(5), Unif = runif(5,1,10))
2> myList
3$Pois
4 [1] 7 5 3 3 2 2 0 1 4 4
5$Norm
6[1] 1.56840563 -0.08843082 0.19965929 0.20645959 0.85374249
7$Unif
8[1] 8.729636 8.109225 7.884665 9.558795 1.016197
9> lapply(myList,mean)
10$Pois
11[1] 3.1
12$Norm
13[1] 0.5479672
14$Unif
15[1] 7.059704
16> sapply(myList,mean)
17 Pois Norm Unif
183.1000000 0.5479672 7.0597036
19>
20
In this lesson, we saw three functions in the apply family, namely, apply(), lapply(), and sapply(). The entire family is made up of the apply(), lapply() , sapply(), vapply(), mapply(), rapply(), and tapply() functions.
