The family of apply() functions in R is used to apply user-defined functions to the elements of complex structures like matrices, lists or data frames.

These functions help a lot in simplifying your code and making it more readable. Moreover, they are compatible with parallel processing as well. Let us look at each function with detailed examples.

Table of Contents

## The apply() function in R Programming

The apply() function in R is used in case of matrices to apply a user-specified function on the rows or columns of the matrix. The following is the general syntax for apply() function.

```
apply(matrix, code, f, fargs)
```

In the above form, `matrix`

is the matrix object which we are using the apply() function for. `Code`

represents whether we wish to apply the function for rows (code set to 1) or columns (code set to 2). `F`

represents the function we need to apply and `fargs`

are the arguments to pass to the function.

Let us first define a matrix to illustrate the apply() function.

```
> x <-matrix(c(4,5,6,10,12,16),nrow=2,ncol=3)
> x
[,1] [,2] [,3]
[1,] 4 6 12
[2,] 5 10 16
```

Suppose that we wish to perform a very specific function upon each of these elements, like squaring first, then dividing by 3 and multiplying by 4. Let us define a function that does this.

```
> f <-function(x)
+ {
+ return (x^2*3/4)
+ }
> f(5)
[1] 18.75
```

Now, in order to apply this function to all the rows/columns in a matrix, we call the apply() function.

```
> apply(x, 2, f)
[,1] [,2] [,3]
[1,] 12.00 27 108
[2,] 18.75 75 192
```

The function gets conveniently applied to each element in the matrix without calling it in a loop. The apply() function in R doesn’t provide any speed benefit in execution but helps you write a cleaner and more compact code.

## sapply() and lapply() functions in R Programming

### Working with Lists

The `lapply()`

function in R is short for list apply. This works in a manner similar to the `apply()`

function above, but uses lists instead of matrices.

Let us look at an example:

```
> mylist <- list(c(1,2,3,4),c(10,20,30,40),c(5,5,5,5))
> lapply(mylist,mean)
[[1]]
[1] 2.5
[[2]]
[1] 25
[[3]]
[1] 5
```

The list **mylist** is a list of 3 vectors. We wish to apply a mean function to each one of the vectors. This is done by calling `lapply(mylist,mean)`

that returns the mean values of the three constituent vectors.

Similarly, sapply() function in R is short for for simplified apply. Instead of obtaining a separate mean value for each vector, `sapply`

returns a vector containing the mean values.

```
> sapply(mylist,mean)
[1] 2.5 25.0 5.0
```

### Working with Data Frames in R

Since data frames can be treated as a special case of lists, the functions `lapply()`

and `sapply()`

work in both cases. Let us look at an example.

Let us create a data frame first and then apply a sort() function on it using the lapply() function in R.

```
names <- c("Adam","Antony","Brian","Carl","Doug")
ages <- c(23,22,24,25,26)
playerdata <- data.frame(names,ages,stringsAsFactors = FALSE)
#Apply a sort function on the dataframe
> lapply(playerdata,sort)
$names
[1] "Adam" "Antony" "Brian" "Carl" "Doug"
$ages
[1] 22 23 24 25 26
```

The function returns both the columns of the data frame in a sorted order separately.

Similarly, calling sapply() provides a compact list with each column sorted separately.

```
> sapply(playerdata,sort)
names ages
[1,] "Adam" "22"
[2,] "Antony" "23"
[3,] "Brian" "24"
[4,] "Carl" "25"
[5,] "Doug" "26"
```

## tapply() function

The tapply() function also belongs to the same family but **used only in case of factors**. This is best explained with an example. Suppose we have the salaries of employees in a company in the form of a vector and their respective means of transport in a factor. Suppose that we wish to calculate what is the average salary of each group using a specific means of transport.

The tapply() function in R programming can be called for this purpose using the R’s built-in mean function.

```
> salaries <-c(25000,30000,45000,66000,20000,50000,35000,20000,15000)
> transport <-c('Bus','Car','Bus','Car','Metro','Metro','Bus','Bus','Metro')
> tapply(salaries,transport,mean)
Bus Car Metro
31250.00 48000.00 28333.33
```

As you can observe, the tapply() function in R outputs a well-formatted mean of the salaries with the means of transport as columns. Also, notice how it only accounts for unique values from the transport vector automatically.