Question

好的，这是我希望使用高效，优雅的解决方案解决的问题，例如data.table或dplyr。

定义：

DT = data.table(group=c(rep("A",3),rep("B",5)),value=c(2,9,2,3,4,1,0,3))

   time group value  
1:    1     A     2  
2:    2     A     9 
3:    3     A     2 
4:    1     B     3     
5:    2     B     4 
6:    3     B     1 
7:    4     B     0 
8:    5     B     3

我想要得到的是一组累计和的值除以它们观察到的时刻的逆序。

   time group value    RESULT
1:    1     A     2  2.000000
2:    2     A     9 10.000000
3:    3     A     2  7.166667
4:    1     B     3  3.000000
5:    2     B     4  5.500000
6:    3     B     1  4.000000
7:    4     B     0  2.583333
8:    5     B     3  4.933333

在第5行，结果是： 4/1 + 3/2 = 5.5 因为在时间2，B组有2个观察值，最后一个除以1，前一个除以1。第6行接下来的结果是： 1/1 + 4/2+ 3/3 = 4 从时间3开始，B组有3个观察值，最后一个除以1，前一个除以2，前一个除以3.在第7行，0/1 + 1/2 + 4/3 + 3/4 = 2.583333，等等......

数据很大，所以避免循环是必不可少的！

Answer 1

我使用矩阵代数：

n_max = DT[, .N, by=group][, max(N)]
m     = matrix(0, n_max, n_max)
m[]   = ifelse( col(m) >= row(m), 1 / (col(m) - row(m) + 1 ), m)

DT[, res := value %*% m[seq_len(.N), seq_len(.N)], by=group ]

   group value       res
1:     A     2  2.000000
2:     A     9 10.000000
3:     A     2  7.166667
4:     B     3  3.000000
5:     B     4  5.500000
6:     B     1  4.000000
7:     B     0  2.583333
8:     B     3  4.933333

Answer 2

您可以*apply跨越组长度的序列，使序列编入索引value，然后反过来将其除以。使用dplyr：

library(tidyverse)

DT %>% group_by(group) %>% 
    mutate(result = sapply(seq(n()), function(x){sum(value[seq(x)] / rev(seq(x)))}))

## Source: local data frame [8 x 3]
## Groups: group [2]
## 
##    group value    result
##   <fctr> <dbl>     <dbl>
## 1      A     2  2.000000
## 2      A     9 10.000000
## 3      A     2  7.166667
## 4      B     3  3.000000
## 5      B     4  5.500000
## 6      B     1  4.000000
## 7      B     0  2.583333
## 8      B     3  4.933333

或使用purrr::map_dbl代替sapply，

DT %>% group_by(group) %>% 
    mutate(result = map_dbl(seq(n()), ~sum(value[seq(.x)] / rev(seq(.x)))))

返回相同的东西。您也可以将相同的逻辑转换为基数R：

DT$result <- ave(DT$value, 
                 DT$group, 
                 FUN = function(v){sapply(seq_along(v), 
                                          function(x){sum(v[seq(x)] / rev(seq(x)))})})

DT

##   group value    result
## 1     A     2  2.000000
## 2     A     9 10.000000
## 3     A     2  7.166667
## 4     B     3  3.000000
## 5     B     4  5.500000
## 6     B     1  4.000000
## 7     B     0  2.583333
## 8     B     3  4.933333

虽然我没有进行基准测试，但这些方法对于大多数工作来说应该足够快。我怀疑，如果速度至关重要，@弗兰克的答案可能会更快。

Answer 3

如果你有多余的内存，你可以使用一个笛卡尔联接来预先分配行，这样在各个过程中完成的操作就更简单了，并且可以利用data.table的GForce优化。这可能/可能不会比其他解决方案更快，因为它基本上交换内存以便在by中使用更优化的代码。

> DT[, .SD
     ][DT, on='group', allow.cartesian=T
     ][, setnames(.SD, 'i.time', 'groupRow')
     ][time <= groupRow
     ][, timeRev := .N:1, .(group, groupRow)
     ][, res := value / timeRev
     ][, .(res=sum(res)), .(group, groupRow, i.value)
     ][, groupRow := NULL
     ][, setnames(.SD, 'i.value', 'value')
     ]
   group value    res
1:     A     2  2.000
2:     A     9 10.000
3:     A     2  7.167
4:     B     3  3.000
5:     B     4  5.500
6:     B     1  4.000
7:     B     0  2.583
8:     B     3  4.933
>

具有不同分母R

3 个答案: