Looping over Objects in R Programming

Prerequisite: Data Structures in R Programming

One of the biggest issues with the “for” loop is its memory consumption and its slowness in executing a repetitive task. And when it comes to dealing with large data set and iterating over it, for loop is not advised. R provides many alternatives to be applied to vectors for looping operations that are pretty useful when working interactively on a command line. In this article, we deal with apply() function and its variants:

• apply()
• lapply()
• sapply()
• tapply()
• mapply()

Let us see what each of these functions does.

Looping Function	Operation
apply()	Applies a function over the margins of an array or matrix
lapply()	Apply a function over a list or a vector
sapply()	Same as lapply() but with simplified results
tapply()	Apply a function over a ragged array
mapply()	Multivariate version of lapply()

• apply(): This function applies a given function over the margins of a given array.
  

  apply(array, margins, function, …)

  array = list of elements
  margins = dimension of the array along which the function needs to be applied
  function = the operation which you want to perform

  Example:

  # R program to illustrate
  # apply() function
  
  # Creating a matrix
  A = matrix(1:9, 3, 3)
  print(A)
  
  # Applying apply() over row of matrix
  # Here margin 1 is for row
  r = apply(A, 1, sum)
  print(r)
  
  # Applying apply() over column of matrix
  # Here margin 2 is for column
  c = apply(A, 2, sum)
  print(c)

  Output:

  [, 1] [, 2] [, 3]
  [1, ]    1    4    7
  [2, ]    2    5    8
  [3, ]    3    6    9
  
  [1] 12 15 18
  [1]  6 15 24
  

• lapply(): This function is used to apply a function over a list. It always returns a list of the same length as the input list.
  

  lapply(list, function, …)

  list = Created list
  function = the operation which you want to perform

  Example:

  # R program to illustrate
  # lapply() function
  
  # Creating a matrix
  A = matrix(1:9, 3, 3)
  
  # Creating another matrix
  B = matrix(10:18, 3, 3)
  
  # Creating a list
  myList = list(A, B)
  
  # applying lapply()
  determinant = lapply(myList, det)
  print(determinant)

  Output:

  [[1]]
  [1] 0
  
  [[2]]
  [1] 5.329071e-15
  

• sapply(): This function is used to simplify the result of lapply(), if possible. Unlike lapply(), the result is not always a list. The output varies in the following ways:-
  • If output is a list containing elements having length 1, then a vector is returned.
  • If output is a list where all the elements are vectors of same length(>1), then a matrix is returned.
  • If output contains elements which cannot be simplified or elements of different types, a list is returned.

  sapply(list, function, …)

  list = Created list
  function = the operation which you want to perform

  Example:

  # R program to illustrate
  # sapply() function
  
  # Creating a list
  A = list(a = 1:5, b = 6:10)
  
  # applying sapply()
  means = sapply(A, mean)
  print(means)

  Output:

  a b
  3 8
  

  A vector is returned since the output had a list with elements of length 1.

• tapply(): This function is used to apply a function over subset of vectors given by a combination of factors.
  

  tapply(vector, factor, function, …)

  vector = Created vector
  factor = Created factor
  function = the operation which you want to perform

  Example:

  # R program to illustrate
  # tapply() function
  
  # Creating a factor
  Id = c(1, 1, 1, 1, 2, 2, 2, 3, 3)
  
  # Creating a vector
  val = c(1, 2, 3, 4, 5, 6, 7, 8, 9)
  
  # applying tapply()
  result = tapply(val, Id, sum)
  print(result)

  Output:

  1  2  3 
  10 18 17 
  

  How does the above code work?

  

• mapply(): It’s a multivariate version of lapply(). This function can be applied over several list simultaneously.
  

  mapply(function, list1, list2, …)

  function = the operation which you want to perform

  list1, list2 = Created lists

  Example:

  # R program to illustrate
  # mapply() function
  
  # Creating a list
  A = list(c(1, 2, 3, 4))
  
  # Creating another list
  B = list(c(2, 5, 1, 6))
  
  # Applying mapply()
  result = mapply(sum, A, B)
  print(result)

  Output:

  [1] 24