Функции группировки (tapply, by, aggregate) и семейство * apply

Всякий раз, когда я хочу сделать что-то «сопоставить» py в R, я обычно пытаюсь использовать функцию в applyсемье.

Однако я никогда не понимал различий между ними - как { sapply, lapplyи т. Д.} Применять функцию к входу / групповому вводу, как будет выглядеть вывод, или даже каким может быть ввод - поэтому я часто просто пройди их все, пока я не получу то, что хочу.

Может кто-нибудь объяснить, как использовать какой, когда?

Мое текущее (вероятно, неправильное / неполное) понимание ...

1. sapply(vec, f): вход является вектором. Выходной вектор / матрица, где элемент iявляется f(vec[i]), что дает вам матрицу , если fимеет выход многоэлементного

2. lapply(vec, f): тоже самое sapply, но вывод есть список?

3. apply(matrix, 1/2, f): вход является матрицей. output - вектор, где element i- это f (строка / столбец матрицы i)
4. tapply(vector, grouping, f): Выход матрица / массив, в котором элемент в матрице / массиве значения fпри группировке gвектора, и gполучает толкнул к / именам Col строка
5. by(dataframe, grouping, f): пусть gбудет группировка. применить fк каждому столбцу группы / dataframe. Довольно распечатать группировку и значение fв каждом столбце.
6. aggregate(matrix, grouping, f): похоже на by, но вместо того, чтобы красиво печатать вывод, агрегат вставляет все в информационный фрейм.

Дополнительный вопрос: я до сих пор не изучил plyr или не изменил форму - полностью plyrили reshapeполностью я бы их заменил?

R имеет много * применяет функции, которые умело описаны в файлах справки (например ?apply). Однако их достаточно, чтобы начинающим пользователям было трудно решить, какой из них подходит для их ситуации, или даже запомнить их все. У них может быть общее чувство, что «я должен использовать здесь функцию * apply», но поначалу бывает сложно держать их все прямо.

Несмотря на тот факт (отмеченный в других ответах), что большая часть функциональности семейства * apply покрыта чрезвычайно популярным plyrпакетом, базовые функции остаются полезными и их стоит знать.

Этот ответ призван служить своего рода указателем для новых пользователей, чтобы помочь им направить их к правильной функции * apply для их конкретной проблемы. Обратите внимание, это не предназначено просто для регургитации или замены документации R! Надежда состоит в том, что этот ответ поможет вам решить, какая * применимая функция подходит для вашей ситуации, а затем вам предстоит изучить ее дальше. За одним исключением, различия в производительности не будут устранены.

• apply - применять, когда вы хотите применить функцию к строкам или столбцам матрицы (и многомерных аналогов); как правило, не рекомендуется для фреймов данных, так как он сначала приведёт к матрице.

  # Two dimensional matrix
  M <- matrix(seq(1,16), 4, 4)
  
  # apply min to rows
  apply(M, 1, min)
  [1] 1 2 3 4
  
  # apply max to columns
  apply(M, 2, max)
  [1]  4  8 12 16
  
  # 3 dimensional array
  M <- array( seq(32), dim = c(4,4,2))
  
  # Apply sum across each M[*, , ] - i.e Sum across 2nd and 3rd dimension
  apply(M, 1, sum)
  # Result is one-dimensional
  [1] 120 128 136 144
  
  # Apply sum across each M[*, *, ] - i.e Sum across 3rd dimension
  apply(M, c(1,2), sum)
  # Result is two-dimensional
       [,1] [,2] [,3] [,4]
  [1,]   18   26   34   42
  [2,]   20   28   36   44
  [3,]   22   30   38   46
  [4,]   24   32   40   48
  

  Если вы хотите средства строк / столбцов или суммы для 2D - матрицы, убедитесь , что для расследования оптимизированный, молниеносный colMeans, rowMeans, colSums, rowSums.

• lapply - когда вы хотите применить функцию к каждому элементу списка по очереди и получить список обратно.

  Это рабочая лошадка многих других * применимых функций. Отогните их код, и вы часто найдете lapplyпод ним.

  x <- list(a = 1, b = 1:3, c = 10:100) 
  lapply(x, FUN = length) 
  $a 
  [1] 1
  $b 
  [1] 3
  $c 
  [1] 91
  lapply(x, FUN = sum) 
  $a 
  [1] 1
  $b 
  [1] 6
  $c 
  [1] 5005
  

• sapply - когда вы хотите применить функцию к каждому элементу списка по очереди, но вы хотите вернуть вектор , а не список.

  Если вы обнаружите, что печатаете unlist(lapply(...)), остановитесь и подумайте sapply.

  x <- list(a = 1, b = 1:3, c = 10:100)
  # Compare with above; a named vector, not a list 
  sapply(x, FUN = length)  
  a  b  c   
  1  3 91
  
  sapply(x, FUN = sum)   
  a    b    c    
  1    6 5005 
  

  При более продвинутом использовании sapplyон будет пытаться привести результат к многомерному массиву, если это необходимо. Например, если наша функция возвращает векторы одинаковой длины, sapplyбудем использовать их в качестве столбцов матрицы:

  sapply(1:5,function(x) rnorm(3,x))

  Если наша функция возвращает 2-мерную матрицу, она sapplyбудет делать то же самое, обрабатывая каждую возвращенную матрицу как один длинный вектор:

  sapply(1:5,function(x) matrix(x,2,2))

  Если мы не укажем simplify = "array", в этом случае он будет использовать отдельные матрицы для построения многомерного массива:

  sapply(1:5,function(x) matrix(x,2,2), simplify = "array")

  Каждое из этих поведений, конечно, зависит от нашей функции, возвращающей векторы или матрицы одинаковой длины или размера.

• vapply - когда вы хотите использовать, sapplyно, возможно, нужно выжать еще немного скорости из вашего кода.

  Для vapply, вы в основном даете R пример того , что такая вещи вашей функция будет возвращать, которая может сэкономить время принуждения возвращаемых значений , чтобы поместиться в одном атомном векторе.

  x <- list(a = 1, b = 1:3, c = 10:100)
  #Note that since the advantage here is mainly speed, this
  # example is only for illustration. We're telling R that
  # everything returned by length() should be an integer of 
  # length 1. 
  vapply(x, FUN = length, FUN.VALUE = 0L) 
  a  b  c  
  1  3 91
  

• mapply - для случаев, когда у вас есть несколько структур данных (например, векторы, списки), и вы хотите применить функцию к первым элементам каждого, а затем ко вторым элементам каждого и т. д., приведя результат к вектору / массиву, как в sapply,

  Это многовариантно в том смысле, что ваша функция должна принимать несколько аргументов.

  #Sums the 1st elements, the 2nd elements, etc. 
  mapply(sum, 1:5, 1:5, 1:5) 
  [1]  3  6  9 12 15
  #To do rep(1,4), rep(2,3), etc.
  mapply(rep, 1:4, 4:1)   
  [[1]]
  [1] 1 1 1 1
  
  [[2]]
  [1] 2 2 2
  
  [[3]]
  [1] 3 3
  
  [[4]]
  [1] 4
  

• Map - Обертка для mapplywith SIMPLIFY = FALSE, поэтому она гарантированно вернет список.

  Map(sum, 1:5, 1:5, 1:5)
  [[1]]
  [1] 3
  
  [[2]]
  [1] 6
  
  [[3]]
  [1] 9
  
  [[4]]
  [1] 12
  
  [[5]]
  [1] 15
  

• rapply - для случаев, когда вы хотите применить функцию к каждому элементу структуры вложенного списка , рекурсивно.

  Чтобы дать вам некоторое представление о том, как необычно rapply, я забыл об этом, когда впервые опубликовал этот ответ! Очевидно, я уверен, что многие люди используют его, но YMMV. rapplyЛучше всего проиллюстрировать пользовательскую функцию для применения:

  # Append ! to string, otherwise increment
  myFun <- function(x){
      if(is.character(x)){
        return(paste(x,"!",sep=""))
      }
      else{
        return(x + 1)
      }
  }
  
  #A nested list structure
  l <- list(a = list(a1 = "Boo", b1 = 2, c1 = "Eeek"), 
            b = 3, c = "Yikes", 
            d = list(a2 = 1, b2 = list(a3 = "Hey", b3 = 5)))
  
  
  # Result is named vector, coerced to character          
  rapply(l, myFun)
  
  # Result is a nested list like l, with values altered
  rapply(l, myFun, how="replace")

• tapply - если вы хотите применить функцию к подмножествам вектора, а подмножества определяются каким-то другим вектором, обычно фактором.

  Черная овца семейства * применяет, родов. Использование в файле справки фразы «рваный массив» может быть немного запутанным , но на самом деле все довольно просто.

  Вектор:

  x <- 1:20

  Фактор (одинаковой длины!), Определяющий группы:

  y <- factor(rep(letters[1:5], each = 4))

  Сложите значения в xкаждой подгруппе, определенной как y:

  tapply(x, y, sum)  
   a  b  c  d  e  
  10 26 42 58 74 

  Более сложные примеры могут быть обработаны, когда подгруппы определяются уникальными комбинациями списка из нескольких факторов. tapplyаналогичен по духу сплит-применять функции-объединить , которые являются общими в R ( aggregate, by, ave, ddplyи т.д.) Следовательно , его статус черные овцы.

Кроме того, здесь показано, как различные plyrфункции соответствуют базовым *applyфункциям (от вступления к документу plyr с веб-страницы plyr http://had.co.nz/plyr/ ).

Base function   Input   Output   plyr function 
---------------------------------------
aggregate        d       d       ddply + colwise 
apply            a       a/l     aaply / alply 
by               d       l       dlply 
lapply           l       l       llply  
mapply           a       a/l     maply / mlply 
replicate        r       a/l     raply / rlply 
sapply           l       a       laply 

Одна из целей plyrсостоит в том, чтобы обеспечить согласованные соглашения об именах для каждой из функций, кодируя входные и выходные типы данных в имени функции. Он также обеспечивает согласованность в выводе, поскольку выход из dlply()него легко переносится ldply()для получения полезного вывода и т. Д.

Концептуально обучение plyrне сложнее, чем понимание базовых *applyфункций.

plyrи reshapeфункции заменили почти все эти функции в моем повседневном использовании. Но также из вступления к документу Plyr:

Связанные функции tapplyи не sweepимеют соответствующей функции plyr, и остаются полезными. mergeполезно для объединения резюме с исходными данными.

Из слайда 21 http://www.slideshare.net/hadley/plyr-one-data-analytic-strategy :

(Надеюсь, это ясно, что applyсоответствует @ Hadley's aaplyи aggregateсоответствует @ Hadley's ddplyи т. Д. Слайд 20 того же слайдшера прояснит, если вы не получите его из этого изображения.)

(слева ввод, сверху вывод)

Сначала начните с отличного ответа Джорана - сомнительно, что все может быть лучше.

Тогда следующая мнемоника может помочь вспомнить различия между каждым. В то время как некоторые из них очевидны, другие могут быть не так - для них вы найдете оправдание в обсуждениях Джорана.

мнемоника

• lapplyявляется применением списка, которое действует на список или вектор и возвращает список.
• sapplyявляется простым lapply (функция по умолчанию возвращает вектор или матрицу, когда это возможно)
• vapplyявляется проверенным применением (позволяет предварительно указать тип возвращаемого объекта)
• rapplyявляется рекурсивным применением для вложенных списков, то есть списков в списках
• tapplyявляется тегом применить, где теги идентифицируют подмножества
• apply является универсальным : применяет функцию к строкам или столбцам матрицы (или, в более общем случае, к измерениям массива)

Создание правильного фона

Если использование applyсемьи все еще кажется вам чуждым, возможно, вам не хватает ключевой точки зрения.

Эти две статьи могут помочь. Они обеспечивают необходимую основу для мотивации методов функционального программирования , предоставляемых applyсемейством функций.

Пользователи Lisp сразу узнают эту парадигму. Если вы не знакомы с Lisp, то, как только вы разберетесь с FP, вы получите мощную точку зрения для использования в R - и у вас applyбудет гораздо больше смысла.

• Advanced R: функциональное программирование , Хэдли Уикхем
• Простое функциональное программирование на R , Майкл Бартон

Так как я понял, что (очень отличные) ответы на этот пост отсутствуют byи aggregateобъяснения. Вот мой вклад.

ПО

byФункции, как указано в документации , может быть , хотя, как «обертки» для tapply. Сила byвозникает, когда мы хотим вычислить задачу, которая tapplyне справляется. Одним из примеров является этот код:

ct <- tapply(iris$Sepal.Width , iris$Species , summary )
cb <- by(iris$Sepal.Width , iris$Species , summary )

 cb
iris$Species: setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 
-------------------------------------------------------------- 
iris$Species: versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 
-------------------------------------------------------------- 
iris$Species: virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 


ct
$setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 

$versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 

$virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 

Если мы печатаем эти два объекта, ctи cbмы «по существу» получаем одинаковые результаты, и единственные различия заключаются в том, как они отображаются, и в разных classатрибутах соответственно byдля cbи arrayдля ct.

Как я уже сказал, сила byвозникает, когда мы не можем использовать tapply; следующий код является одним из примеров:

 tapply(iris, iris$Species, summary )
Error in tapply(iris, iris$Species, summary) : 
  arguments must have same length

R говорит, что аргументы должны иметь одинаковую длину, скажем, «мы хотим вычислить summaryпеременную all по всей длине irisфактора Species»: но R просто не может этого сделать, потому что не знает, как с этим обращаться.

С помощью byфункции R отправьте конкретный метод для data frameкласса, а затем разрешите summaryфункции работать, даже если длина первого аргумента (и типа тоже) различна.

bywork <- by(iris, iris$Species, summary )

bywork
iris$Species: setosa
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.300   Min.   :2.300   Min.   :1.000   Min.   :0.100   setosa    :50  
 1st Qu.:4.800   1st Qu.:3.200   1st Qu.:1.400   1st Qu.:0.200   versicolor: 0  
 Median :5.000   Median :3.400   Median :1.500   Median :0.200   virginica : 0  
 Mean   :5.006   Mean   :3.428   Mean   :1.462   Mean   :0.246                  
 3rd Qu.:5.200   3rd Qu.:3.675   3rd Qu.:1.575   3rd Qu.:0.300                  
 Max.   :5.800   Max.   :4.400   Max.   :1.900   Max.   :0.600                  
-------------------------------------------------------------- 
iris$Species: versicolor
  Sepal.Length    Sepal.Width     Petal.Length   Petal.Width          Species  
 Min.   :4.900   Min.   :2.000   Min.   :3.00   Min.   :1.000   setosa    : 0  
 1st Qu.:5.600   1st Qu.:2.525   1st Qu.:4.00   1st Qu.:1.200   versicolor:50  
 Median :5.900   Median :2.800   Median :4.35   Median :1.300   virginica : 0  
 Mean   :5.936   Mean   :2.770   Mean   :4.26   Mean   :1.326                  
 3rd Qu.:6.300   3rd Qu.:3.000   3rd Qu.:4.60   3rd Qu.:1.500                  
 Max.   :7.000   Max.   :3.400   Max.   :5.10   Max.   :1.800                  
-------------------------------------------------------------- 
iris$Species: virginica
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.900   Min.   :2.200   Min.   :4.500   Min.   :1.400   setosa    : 0  
 1st Qu.:6.225   1st Qu.:2.800   1st Qu.:5.100   1st Qu.:1.800   versicolor: 0  
 Median :6.500   Median :3.000   Median :5.550   Median :2.000   virginica :50  
 Mean   :6.588   Mean   :2.974   Mean   :5.552   Mean   :2.026                  
 3rd Qu.:6.900   3rd Qu.:3.175   3rd Qu.:5.875   3rd Qu.:2.300                  
 Max.   :7.900   Max.   :3.800   Max.   :6.900   Max.   :2.500     

это действительно работает, и результат очень удивителен. Это объект класса, byкоторый вместе Species(скажем, для каждого из них) вычисляет summaryкаждую переменную.

Обратите внимание, что если первый аргумент - это data frame, отправленная функция должна иметь метод для этого класса объектов. Например, если мы используем этот код с meanфункцией, у нас будет этот код, который вообще не имеет смысла:

 by(iris, iris$Species, mean)
iris$Species: setosa
[1] NA
------------------------------------------- 
iris$Species: versicolor
[1] NA
------------------------------------------- 
iris$Species: virginica
[1] NA
Warning messages:
1: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
2: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
3: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA

ОБЩИЙ

aggregateможет рассматриваться как другой способ использования, tapplyесли мы используем его таким образом.

at <- tapply(iris$Sepal.Length , iris$Species , mean)
ag <- aggregate(iris$Sepal.Length , list(iris$Species), mean)

 at
    setosa versicolor  virginica 
     5.006      5.936      6.588 
 ag
     Group.1     x
1     setosa 5.006
2 versicolor 5.936
3  virginica 6.588

Два непосредственных различия состоят в том, что второй аргумент aggregate должен быть списком, в то время как tapply может (не обязательно) быть списком, и что выходные aggregateданные представляют собой фрейм данных, а один tapply- является array.

Сила в aggregateтом, что он может легко обрабатывать подмножества данных с subsetаргументом и что у него есть методы для tsобъектов, formulaа также.

Эти элементы aggregateоблегчают работу с этим tapplyв некоторых ситуациях. Вот несколько примеров (доступно в документации):

ag <- aggregate(len ~ ., data = ToothGrowth, mean)

 ag
  supp dose   len
1   OJ  0.5 13.23
2   VC  0.5  7.98
3   OJ  1.0 22.70
4   VC  1.0 16.77
5   OJ  2.0 26.06
6   VC  2.0 26.14

Мы можем добиться того же самого, tapplyно синтаксис немного сложнее, а вывод (в некоторых случаях) менее читабелен:

att <- tapply(ToothGrowth$len, list(ToothGrowth$dose, ToothGrowth$supp), mean)

 att
       OJ    VC
0.5 13.23  7.98
1   22.70 16.77
2   26.06 26.14

Есть другие случаи, когда мы не можем использовать byили tapplyи мы должны использовать aggregate.

 ag1 <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, mean)

 ag1
  Month    Ozone     Temp
1     5 23.61538 66.73077
2     6 29.44444 78.22222
3     7 59.11538 83.88462
4     8 59.96154 83.96154
5     9 31.44828 76.89655

Мы не можем получить предыдущий результат с tapplyодним вызовом, но мы должны вычислить среднее значение Monthдля каждого элемента и затем объединить их (также обратите внимание, что мы должны вызвать na.rm = TRUE, потому что formulaметоды aggregateфункции по умолчанию имеют na.action = na.omit):

ta1 <- tapply(airquality$Ozone, airquality$Month, mean, na.rm = TRUE)
ta2 <- tapply(airquality$Temp, airquality$Month, mean, na.rm = TRUE)

 cbind(ta1, ta2)
       ta1      ta2
5 23.61538 65.54839
6 29.44444 79.10000
7 59.11538 83.90323
8 59.96154 83.96774
9 31.44828 76.90000

в то время как с помощью byмы просто не можем этого достичь, на самом деле следующий вызов функции возвращает ошибку (но, скорее всего, это связано с предоставленной функцией mean):

by(airquality[c("Ozone", "Temp")], airquality$Month, mean, na.rm = TRUE)

В других случаях результаты совпадают, и различия заключаются только в объекте класса (а затем в том, как он показан / напечатан, а не только в примере, например, как его установить):

byagg <- by(airquality[c("Ozone", "Temp")], airquality$Month, summary)
aggagg <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, summary)

Предыдущий код достиг той же цели и результатов, в какой-то момент, какой инструмент использовать, зависит только от личных вкусов и потребностей; предыдущие два объекта имеют очень разные потребности с точки зрения поднабора.

Есть много отличных ответов, которые обсуждают различия в вариантах использования для каждой функции. Ни один из ответов не обсуждает различия в производительности. Это разумно, потому что различные функции ожидают различного ввода и производят различный вывод, но большинство из них имеют общую общую цель - оценивать по сериям / группам. Мой ответ будет сосредоточен на производительности. Из-за вышеизложенного создание ввода из векторов включено в синхронизацию, также applyфункция не измеряется.

Я протестировал две разные функции sumи lengthсразу. Протестированный объем составляет 50 М на входе и 50 К на выходе. Я также включил два популярных в настоящее время пакета, которые не были широко использованы в то время, когда задавался вопрос, data.tableи dplyr. И то, и другое определенно стоит посмотреть, если вы стремитесь к хорошей производительности.

library(dplyr)
library(data.table)
set.seed(123)
n = 5e7
k = 5e5
x = runif(n)
grp = sample(k, n, TRUE)

timing = list()

# sapply
timing[["sapply"]] = system.time({
    lt = split(x, grp)
    r.sapply = sapply(lt, function(x) list(sum(x), length(x)), simplify = FALSE)
})

# lapply
timing[["lapply"]] = system.time({
    lt = split(x, grp)
    r.lapply = lapply(lt, function(x) list(sum(x), length(x)))
})

# tapply
timing[["tapply"]] = system.time(
    r.tapply <- tapply(x, list(grp), function(x) list(sum(x), length(x)))
)

# by
timing[["by"]] = system.time(
    r.by <- by(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# aggregate
timing[["aggregate"]] = system.time(
    r.aggregate <- aggregate(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# dplyr
timing[["dplyr"]] = system.time({
    df = data_frame(x, grp)
    r.dplyr = summarise(group_by(df, grp), sum(x), n())
})

# data.table
timing[["data.table"]] = system.time({
    dt = setnames(setDT(list(x, grp)), c("x","grp"))
    r.data.table = dt[, .(sum(x), .N), grp]
})

# all output size match to group count
sapply(list(sapply=r.sapply, lapply=r.lapply, tapply=r.tapply, by=r.by, aggregate=r.aggregate, dplyr=r.dplyr, data.table=r.data.table), 
       function(x) (if(is.data.frame(x)) nrow else length)(x)==k)
#    sapply     lapply     tapply         by  aggregate      dplyr data.table 
#      TRUE       TRUE       TRUE       TRUE       TRUE       TRUE       TRUE 

# print timings
as.data.table(sapply(timing, `[[`, "elapsed"), keep.rownames = TRUE
              )[,.(fun = V1, elapsed = V2)
                ][order(-elapsed)]
#          fun elapsed
#1:  aggregate 109.139
#2:         by  25.738
#3:      dplyr  18.978
#4:     tapply  17.006
#5:     lapply  11.524
#6:     sapply  11.326
#7: data.table   2.686

Несмотря на все замечательные ответы здесь, есть еще 2 базовые функции, которые заслуживают упоминания, полезная outerфункция и скрытая eapplyфункция

внешний

outerэто очень полезная функция, скрытая как более приземленная. Если вы прочитали справку, для outerее описания говорится:

The outer product of the arrays X and Y is the array A with dimension  
c(dim(X), dim(Y)) where element A[c(arrayindex.x, arrayindex.y)] =   
FUN(X[arrayindex.x], Y[arrayindex.y], ...).

из-за этого кажется, что это полезно только для вещей типа линейной алгебры. Тем не менее, это может быть очень похоже mapplyна применение функции к двум векторам входов. Разница в том mapply, что функция будет применена к первым двум элементам, а затем ко вторым двум и т. Д., Тогда outerкак функция будет применяться к каждой комбинации одного элемента из первого вектора и одного из второго. Например:

 A<-c(1,3,5,7,9)
 B<-c(0,3,6,9,12)

mapply(FUN=pmax, A, B)

> mapply(FUN=pmax, A, B)
[1]  1  3  6  9 12

outer(A,B, pmax)

 > outer(A,B, pmax)
      [,1] [,2] [,3] [,4] [,5]
 [1,]    1    3    6    9   12
 [2,]    3    3    6    9   12
 [3,]    5    5    6    9   12
 [4,]    7    7    7    9   12
 [5,]    9    9    9    9   12

Я лично использовал это, когда у меня есть вектор значений и вектор условий, и я хочу посмотреть, какие значения соответствуют каким условиям.

eapply

eapplyпохоже на lapplyто, что вместо того, чтобы применять функцию к каждому элементу в списке, она применяет функцию к каждому элементу в среде. Например, если вы хотите найти список пользовательских функций в глобальной среде:

A<-c(1,3,5,7,9)
B<-c(0,3,6,9,12)
C<-list(x=1, y=2)
D<-function(x){x+1}

> eapply(.GlobalEnv, is.function)
$A
[1] FALSE

$B
[1] FALSE

$C
[1] FALSE

$D
[1] TRUE 

Честно говоря, я не очень этим пользуюсь, но если вы создаете много пакетов или создаете много сред, это может пригодиться.

Возможно, стоит упомянуть ave. aveэто tapply«S дружелюбный кузен. Он возвращает результаты в форме, которую вы можете подключить обратно в свой фрейм данных.

dfr <- data.frame(a=1:20, f=rep(LETTERS[1:5], each=4))
means <- tapply(dfr$a, dfr$f, mean)
##  A    B    C    D    E 
## 2.5  6.5 10.5 14.5 18.5 

## great, but putting it back in the data frame is another line:

dfr$m <- means[dfr$f]

dfr$m2 <- ave(dfr$a, dfr$f, FUN=mean) # NB argument name FUN is needed!
dfr
##   a f    m   m2
##   1 A  2.5  2.5
##   2 A  2.5  2.5
##   3 A  2.5  2.5
##   4 A  2.5  2.5
##   5 B  6.5  6.5
##   6 B  6.5  6.5
##   7 B  6.5  6.5
##   ...

Там нет ничего в базовом пакете , который работает как aveдля целых кадров данных (как это by, как tapplyдля кадров данных). Но вы можете обмануть это:

dfr$foo <- ave(1:nrow(dfr), dfr$f, FUN=function(x) {
    x <- dfr[x,]
    sum(x$m*x$m2)
})
dfr
##     a f    m   m2    foo
## 1   1 A  2.5  2.5    25
## 2   2 A  2.5  2.5    25
## 3   3 A  2.5  2.5    25
## ...

Недавно я обнаружил довольно полезную sweepфункцию и добавил ее здесь для полноты картины:

развертка

Основная идея заключается в том, чтобы подметать через row- массива или столбцы и возвращает модифицированный массив. Пример прояснит это (источник: datacamp ):

Допустим, у вас есть матрица и вы хотите стандартизировать ее по столбцам:

dataPoints <- matrix(4:15, nrow = 4)

# Find means per column with `apply()`
dataPoints_means <- apply(dataPoints, 2, mean)

# Find standard deviation with `apply()`
dataPoints_sdev <- apply(dataPoints, 2, sd)

# Center the points 
dataPoints_Trans1 <- sweep(dataPoints, 2, dataPoints_means,"-")
print(dataPoints_Trans1)
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Return the result
dataPoints_Trans1
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Normalize
dataPoints_Trans2 <- sweep(dataPoints_Trans1, 2, dataPoints_sdev, "/")

# Return the result
dataPoints_Trans2
##            [,1]       [,2]       [,3]
## [1,] -1.1618950 -1.1618950 -1.1618950
## [2,] -0.3872983 -0.3872983 -0.3872983
## [3,]  0.3872983  0.3872983  0.3872983
## [4,]  1.1618950  1.1618950  1.1618950

NB: для этого простого примера тот же результат, конечно, может быть достигнут легче
apply(dataPoints, 2, scale)

В схлопывания пакете недавно выпущенный на CRAN, я попытался сжать большую часть общего применять функции в только 2 функции:

1. dapply(Data-Apply) применяет функции к строкам или (по умолчанию) столбцам матриц и data.frames и (по умолчанию) возвращает объект того же типа и с теми же атрибутами (если результат каждого вычисления не является атомарным и drop = TRUE). Производительность сопоставима со значениями lapplyдля столбцов data.frame и примерно в 2 раза быстрее, чем applyдля строк или столбцов матрицы. Параллелизм доступен через mclapply(только для MAC).

Синтаксис:

dapply(X, FUN, ..., MARGIN = 2, parallel = FALSE, mc.cores = 1L, 
       return = c("same", "matrix", "data.frame"), drop = TRUE)

Примеры:

# Apply to columns:
dapply(mtcars, log)
dapply(mtcars, sum)
dapply(mtcars, quantile)
# Apply to rows:
dapply(mtcars, sum, MARGIN = 1)
dapply(mtcars, quantile, MARGIN = 1)
# Return as matrix:
dapply(mtcars, quantile, return = "matrix")
dapply(mtcars, quantile, MARGIN = 1, return = "matrix")
# Same for matrices ...

2. BYявляется универсальным S3 для вычисления split-apply-Combine с вектором, матрицей и методом data.frame. Это значительно быстрее , чем tapply, byи aggregate(также быстрее , чем plyrна большие объемы данных dplyrбыстрее , хотя).

Синтаксис:

BY(X, g, FUN, ..., use.g.names = TRUE, sort = TRUE,
   expand.wide = FALSE, parallel = FALSE, mc.cores = 1L,
   return = c("same", "matrix", "data.frame", "list"))

Примеры:

# Vectors:
BY(iris$Sepal.Length, iris$Species, sum)
BY(iris$Sepal.Length, iris$Species, quantile)
BY(iris$Sepal.Length, iris$Species, quantile, expand.wide = TRUE) # This returns a matrix 
# Data.frames
BY(iris[-5], iris$Species, sum)
BY(iris[-5], iris$Species, quantile)
BY(iris[-5], iris$Species, quantile, expand.wide = TRUE) # This returns a wider data.frame
BY(iris[-5], iris$Species, quantile, return = "matrix") # This returns a matrix
# Same for matrices ...

Списки группирующих переменных также могут быть предоставлены g.

Говоря о производительности: главная цель коллапса - способствовать высокопроизводительному программированию на R и полностью выйти за рамки раздельного применения и объединения. Для этого пакет имеет полный набор C ++ на основе быстро общие функции: fmean, fmedian, fmode, fsum, fprod, fsd, fvar, fmin, fmax, ffirst, flast, fNobs, fNdistinct, fscale, fbetween, fwithin, fHDbetween, fHDwithin, flag, fdiffи fgrowth. Они выполняют групповые вычисления за один проход данных (т.е. без разделения и рекомбинации).

Синтаксис:

fFUN(x, g = NULL, [w = NULL,] TRA = NULL, [na.rm = TRUE,] use.g.names = TRUE, drop = TRUE)

Примеры:

v <- iris$Sepal.Length
f <- iris$Species

# Vectors
fmean(v)             # mean
fmean(v, f)          # grouped mean
fsd(v, f)            # grouped standard deviation
fsd(v, f, TRA = "/") # grouped scaling
fscale(v, f)         # grouped standardizing (scaling and centering)
fwithin(v, f)        # grouped demeaning

w <- abs(rnorm(nrow(iris)))
fmean(v, w = w)      # Weighted mean
fmean(v, f, w)       # Weighted grouped mean
fsd(v, f, w)         # Weighted grouped standard-deviation
fsd(v, f, w, "/")    # Weighted grouped scaling
fscale(v, f, w)      # Weighted grouped standardizing
fwithin(v, f, w)     # Weighted grouped demeaning

# Same using data.frames...
fmean(iris[-5], f)                # grouped mean
fscale(iris[-5], f)               # grouped standardizing
fwithin(iris[-5], f)              # grouped demeaning

# Same with matrices ...

В пакете виньетки я предоставляю ориентиры. Программирование с помощью быстрых функций значительно быстрее, чем программирование с использованием dplyr или data.table , особенно для небольших данных, но также и для больших данных.