R Tutorial — Apply Function Family in R

Learn how to use apply() function family in R

In this article, we will discuss the apply() function family in the R, its types, and a few of its types applied to different data structures. The apply() family is an in-built package in R, so we don’t have to install it separately. The main advantage of apply() function is that we can use these functions as an alternative to loop operations.

In this post, we’ll learn how we can use the R apply() function, and its different types such as lapply(), sapply(), tapply(), mapply(), and the replicate() function applied to different data structures. So let's get started!

Photo by Mohammad Rahmani on Unsplash

The apply() Family —

The apply() family is pre-installed in the R base package and is made up of various functions to manipulate the data from arrays, lists, matrices, and dataframes in a repetitive way. The apply() function family helps us to perform operations with very few lines of code. These functions could be —

1. Vectorized structures like lists, arrays, matrices, etc.
2. An aggregate function like mean, sum, average, etc.

How and when should we use these?

The use of these functions depends on the structure of the data that we want to operate on and the format of the output that we need. Let’s see how to execute these functions one by one —

The apply() Function

Let’s start with the first function of the family, the apply() function. This operates on arrays. To simplify things, we will only use 2D arrays in this tutorial. First, let’s see how the basic apply function works. We can use the help section of the RStudio to get a description of this function.

?apply()

The R documentation shows the syntax of the function as follows —

apply(X, MARGIN, FUN, ...)

Where:-

1. X is a 2D array.
2. MARGIN is a variable that defines how we can apply the function. When Margin =1, it is applied to rows, and when Margin = 2, it is applied to columns, and when Margin = c(1,2), then it is applied to both rows and columns.
3. FUN is the function that we apply to the data. It can be any R function, including the User Defined Function (UDF).
4. ….. this is used for any other arguments to be passed to the function.

Let’s construct a 4 x 4 matrix and calculate the sum of the values of each column —

matrix_1 <- matrix(1:16, nrow = 4)
matrix_1

We’ll get the output as follows —

[,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

Let’s calculate the sum of the values of each row —

apply(matrix_1, 1, sum)

We’ll get the output as follows —

[1] 28 32 36 40

Let’s calculate the sum of the values of each column —

apply(matrix_1, 2, sum)

We’ll get the output as follows—

[1] 10 26 42 58

Let’s introduce the NA value in the matrix and see how we can execute the function —

matrix_1[2,3] <- NA
matrix_1

We’ll get the output as follows—

[,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   NA   14
[3,]    3    7   11   15
[4,]    4    8   12   16

Let’s use the apply function —

apply(matrix_1, 1, sum)

We’ll get the output as follows —

[1] 28 NA 36 40

Passing the na.rm argument to the above code —

apply(matrix_1, 1, sum, na.rm = TRUE)

We’ll get the output as follows —

[1] 28 22 36 40

Now, let’s remove this NA —

matrix_1[2,3] <- 10
matrix_1

We’ll get the output as follows —

[,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

In the above examples, we used the apply() function to calculate the sum of a row or a column. In the below example, we will use the apply() function to transform the values in each row and column. Please pay attention to the MARGIN argument. We will define a function to multiply each element of the matrix by 5 and set the MARGIN argument to 1:2 so that the function can operate on every row and column of the matrix.

matrix_2 <- apply(matrix_1,1:2, function(x) x*5)
matrix_2

We’ll get the output as follows—

[,1] [,2] [,3] [,4]
[1,]    5   25   45   65
[2,]   10   30   50   70
[3,]   15   35   55   75
[4,]   20   40   60   80

In the previous examples, we used the apply() function on a matrix. But let’s see what happens when we loop through a vector instead?

Let's create a vector first —

vector_1 <- c(1:15)
vector_1

We will get the output as follows —

[1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Let’s use the apply() function —

apply(vector_1, 1, sum)

If you run this function, you’ll get the following error —

Error in apply(vector_1, 1, sum) : dim(X) must have a positive length

As you can see, it didn’t work because the apply() function works best only when the data has at least two dimensions. If the data used is in the vector format, then we need to use the other functions such as lapply(), sapply(), or vapply() instead.

Photo by Magnet.me on Unsplash

The lapply() Function

We use this function when we want to apply a given function that will loop through every element of the data in a list or a vector. We can use the help section of the RStudio to get a description of this function.

?lapply

The R documentation shows the syntax of the function as follows. Please note that there is no MARGIN argument in this function.

lapply(X, FUN, ....)

We can use this function for other objects such as dataframes, lists, or vectors, and the output we get in return is in the form of a list (hence the name starts with “l”), which has the same number of elements as the object passed to it. We will create three matrices named A, B, and C and extract values from a column to see how this works.

A = matrix(1:16, nrow = 4)
B = 1:10
C = 15:20
my_list <- list(A,B,C)
my_list

We will get the output as follows —

[[1]]
     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12   16

[[2]]
[1]  1  2  3  4  5  6  7  8  9 10

[[3]]
[1] 15 16 17 18 19 20

Let’s calculate the sum of each list —

lapply(my_list, sum)

We will get the output as follows —

[[1]]
[1] 136

[[2]]
[1] 55

[[3]]
[1] 105

We can see how the results are saved as a list. If we want a result in a vector form, then we’ve to pass the unlist argument to the lapply() function —

unlist(lapply(my_list, sum))

We will get the output as follows —

[1] 136  55 105

We can also create our own function and pass it to the lapply(). For example, if we want to add 10 to each element, we will use the code as shown below —

lapply(my_list, function(x) x + 10)

We will get the output as follows —

[[1]]
     [,1] [,2] [,3] [,4]
[1,]   11   15   19   23
[2,]   12   16   20   24
[3,]   13   17   21   25
[4,]   14   18   22   26

[[2]]
[1] 11 12 13 14 15 16 17 18 19 20

[[3]]
[1] 25 26 27 28 29 30

The sapply() Function

The sapply() function works just like the lapply() function, but it tries to simplify the output if possible. And indeed, sapply() function is a “wrapper” function for lapply(). We can use the help section of the RStudio to get a description of this function.

?sapply

The R documentation shows the syntax of the function as follows. Please note that there is no MARGIN argument in this function as well.

sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)

This means that instead of returning a list like lapply(), it will return a vector instead if the data is simplificable. Let's use the same example of my_list for this also.

sapply(my_list, sum)

We will get the output as follows —

[1] 136  55 105

Now let’s pass the simplify = FALSE argument to the above code and see what happens —

sapply(my_list, sum, simplify = FALSE)

We will get the output as follows —

[[1]]
[1] 136

[[2]]
[1] 55

[[3]]
[1] 105

Here, we can see that the output is returned in the form of a list instead of a vector. Like the apply() function, we can use a function to transform the data as well. Here is how we can do this —

print(sapply(my_list, function(x) x + 5))

We will get the output as follows —

[[1]]
       [,1] [,2] [,3] [,4]
[1,]    6   10   14   18
[2,]    7   11   15   19
[3,]    8   12   16   20
[4,]    9   13   17   21

[[2]]
[1]  6  7  8  9 10 11 12 13 14 15

[[3]]
[1] 20 21 22 23 24 25

The vapply() function

The vapply() function is similar to the sapply() function, but it requires users to specify what type of data they’re passing to the arguments of the vapply() function. We can use the help section of the RStudio to get a description of this function.

?vapply

The R documentation shows the syntax of the function as follows. Please note that there is no MARGIN argument in this function as well.

vapply(X, FUN, FUN.VALUE, …, USE.NAMES = TRUE)

FUN.VALUE is where we need to specify the type of data that we’re passing. If you want each item in the list to return a single numeric value, so we use the argument as FUN.VALUE = integer(1). Another thing to remember here is that the simplification is always done in the case of the vapply() function. This function checks that all values of FUN are compatible with the FUN.VALUE, for which they must have the same length and type.

vapply(my_list, sum, FUN.VALUE = integer(1))

We will get the output as follows —

[1] 136  55 105

The replicate() Function

This function is often used with the apply() function family. When we pass the replicate() function to a vector, it replicates its values a specified number of times. We can use the help section of the RStudio to get a description of this function.

?replicate

The R documentation shows the syntax of the function as follows. Please note that there is no MARGIN argument in this function as well.

replicate(n, expr, simplify = "array")

Where —

1. n is an integer that shows the number of replications.
2. expr is the expression to evaluate repeatedly.

Let's look at an example —

hist(replicate(100, mean(rexp(10))))

We will get the output as follows —

Image by Author

The mapply() function

The “m” in mapply() function stands for “multivariate” apply. This is modeled after the sapply() function. We use this function to vectorize arguments to a function that is usually not accepting vectors as arguments. We can apply this function to multiple lists or multiple vector arguments. We can use the help section of the RStudio to get a description of this function.

?mapply

The R documentation shows the syntax of the function as follows. Please note that there is no MARGIN argument in this function as well.

mapply(FUN, ..., MoreArgs = NULL, SIMPLIFY = TRUE, USE.NAMES = TRUE)

Where —

1. Fun is the function to apply
2. …. is the arguments to vectorize over
3. MoreArgs is a list of other arguments to FUN.
4. SIMPLIFY is logical or a character string. This tries to reduce the result to a vector, matrix, or a higher-dimensional array.
5. USE.NAMES is used if it is a character vector, we use that character vector as names.

Let’s consider the following example. Suppose we want to replicate 1 at 4 times, 2 at 3 times, 3 at 2 times, and 4 at 1 time.

mapply(rep, times = 1:4, x = 4:1)

We will get the output as follows —

[[1]]
[1] 4

[[2]]
[1] 3 3

[[3]]
[1] 2 2 2

[[4]]
[1] 1 1 1 1

There is another way to do this —

mapply(rep, times = 1:4, MoreArgs = list(x = 25))

We will get the output as follows —

[[1]]
[1] 25

[[2]]
[1] 25 25

[[3]]
[1] 25 25 25

[[4]]
[1] 25 25 25 25

We will get the output in the form of a list. To get the output in the vector form, use the following code —

unlist(mapply(rep, times = 1:4, x = 4:1))

We will get the output as follows —

[1] 4 3 3 2 2 2 1 1 1 1

Now, Let’s create a function and pass the mapply() function to it. Suppose we’ve two vectors and want to multiply them by 2 after adding each other. So let's create the function first and pass the arguments to it.

x <- c(A = 10, B = 20, C = 30)
y <- c(J = 40, K = 50, L = 60)
addition <- function(u,v){
  (u+v)*2
}
mapply(addition, x, y)

We will get the output as follows —

A   B   C 
100 140 180

The tapply() function —

This function applies a function to each cell of a ragged array, that is to each (non-empty) group of values given by a unique combination of the levels of certain factors. We can use the help section of the RStudio to get a description of this function.

?tapply

The R documentation shows the syntax of the function as follows. Please note that there is no MARGIN argument in this function as well.

tapply(X, INDEX, FUN = NULL, ..., default = NA, simplify = TRUE)

Let’s load the iris dataset in R and use the tapply() function on this iris dataset. Let's load the data set —

datasets::iris
head(iris)

We will get the output as follows —

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

Suppose if we want to calculate the mean value of the Sepal Length for all species —

tapply(iris$Sepal.Length, iris$Species, mean)

We will get the output as follows —

setosa versicolor  virginica 
5.006      5.936      6.588

Similarly, we can calculate the median Sepal Length for the three types of species by using this code —

tapply(iris$Sepal.Length, iris$Species, median)

We will get the output as follows —

setosa versicolor  virginica 
5.0        5.9        6.5

Conclusion —

In this article, we learned about the apply() functions family in R. If you liked this article or have any suggestions for me, please let me know by commenting below.

Thank You!