Idiomatic R-код для разбиения вектора по индексу и выполнения операции над этим разделом

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

df <- data.frame(x = c(1,2,3,4,5,6), index = c('a', 'a', 'b', 'b', 'c', 'c'))

Я хочу, чтобы на выходе создавался вектор (пусть его зовут z):

c(1/(1+2), 2/(1+2), 3/(3+4), 3/(3+4), 5/(5+6), 6/(5+6))

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

select 
 x / sum(x) over (partition by index) as z 
from df

и если бы я использовал plyr, я бы сделал что-то вроде этого:

ddply(df, .(index), transform, z = x / sum(x))

но я хотел бы знать, как это сделать, используя стандартные инструменты функционального программирования R, такие как mapply/aggregate и т.д.

Ответ 1

Еще один вариант - ave. Для хорошей меры я собрал ответы выше, старался изо всех сил сделать свой выходной эквивалент (вектор) и предоставил тайминги более 1000 прогонов, используя ваши данные примера в качестве входных данных. Во-первых, мой ответ, используя ave: ave(df$x, df$index, FUN = function(z) z/sum(z)). Я также показываю пример с использованием пакета data.table, поскольку он обычно довольно быстрый, но я знаю, что вы ищете базовые решения, поэтому можете игнорировать это, если хотите.

И теперь куча таймингов:

library(data.table)
library(plyr)
dt <- data.table(df)

plyr <- function() ddply(df, .(index), transform, z = x / sum(x))
av <- function() ave(df$x, df$index, FUN = function(z) z/sum(z))
t.apply <- function() unlist(tapply(df$x, df$index, function(x) x/sum(x)))
l.apply <- function() unlist(lapply(split(df$x, df$index), function(x){x/sum(x)}))
b.y <- function() unlist(by(df$x, df$index, function(x){x/sum(x)}))
agg <- function() aggregate(df$x, list(df$index), function(x){x/sum(x)})
d.t <- function() dt[, x/sum(x), by = index]

library(rbenchmark)
benchmark(plyr(), av(), t.apply(), l.apply(), b.y(), agg(), d.t(), 
           replications = 1000, 
           columns = c("test", "elapsed", "relative"),
           order = "elapsed")
#-----

       test elapsed  relative
4 l.apply()   0.052  1.000000
2      av()   0.168  3.230769
3 t.apply()   0.257  4.942308
5     b.y()   0.694 13.346154
6     agg()   1.020 19.615385
7     d.t()   2.380 45.769231
1    plyr()   5.119 98.442308

В этом случае выигрыш в lapply() кажется выигрышным, а data.table() на удивление медленным. Посмотрите, как это масштабируется для большей проблемы агрегации:

df <- data.frame(x = sample(1:100, 1e5, TRUE), index = gl(1000, 100))
dt <- data.table(df)

#Replication code omitted for brevity, used 100 replications and dropped plyr() since I know it 
#will be slow by comparison:
       test elapsed  relative
6     d.t()   2.052  1.000000
1      av()   2.401  1.170078
3 l.apply()   4.660  2.270955
2 t.apply()   9.500  4.629630
4     b.y()  16.329  7.957602
5     agg()  20.541 10.010234

что кажется более согласованным с тем, что я ожидаю.

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

Изменить - и пример с 1e7 строками

Вероятно, недостаточно для Matt, но такой большой, как мой ноутбук может работать без сбоев:

df <- data.frame(x = sample(1:100, 1e7, TRUE), index = gl(10000, 1000))
dt <- data.table(df)
#-----
       test elapsed  relative
6     d.t()    0.61  1.000000
1      av()    1.45  2.377049
3 l.apply()    4.61  7.557377
2 t.apply()    8.80 14.426230
4     b.y()    8.92 14.622951
5     agg()   18.20 29.83606

Ответ 2

Если вы работаете только с одним вектором и вам нужен только один вектор индексирования, то нажимать довольно быстро

dat <- 1:6
lev <- rep(1:3, each = 2)
tapply(dat, lev, function(x){x/sum(x)})
#$`1`
#[1] 0.3333333 0.6666667
#
#$`2`
#[1] 0.4285714 0.5714286
#
#$`3`
#[1] 0.4545455 0.5454545
#
unlist(tapply(dat, lev, function(x){x/sum(x)}))
#       11        12        21        22        31        32 
#0.3333333 0.6666667 0.4285714 0.5714286 0.4545455 0.5454545

Ответ 3

Три других подхода:

dat <- 1:6
lev <- rep(1:3, each = 2)

lapply(split(dat, lev), function(x){x/sum(x)})
by(dat, lev, function(x){x/sum(x)})
aggregate(dat, list(lev), function(x){x/sum(x)})