R 来自聚合的意外输出

在对另一个问题进行

aggregate

实验时，我遇到了一个相当奇怪的结果。我不知道为什么，我想知道我所做的是否完全错了

假设我有一个像这样的

data.frame

：

df <- structure(list(V1 = c(1L, 2L, 1L, 2L, 3L, 1L), 
                     V2 = c(2L, 3L, 2L, 3L, 4L, 2L), 
                     V3 = c(3L, 4L, 3L, 4L, 5L, 3L), 
                     V4 = c(4L, 5L, 4L, 5L, 6L, 4L)), 
                  .Names = c("V1", "V2", "V3", "V4"), 
        row.names = c(NA, -6L), class = "data.frame")
> df
#   V1 V2 V3 V4
# 1  1  2  3  4
# 2  2  3  4  5
# 3  1  2  3  4
# 4  2  3  4  5
# 5  3  4  5  6
# 6  1  2  3  4

我使用

聚合

通过如下实验获得此输出：

> aggregate(do.call(paste, df), by=df, print)

# [1] "1 2 3 4" "1 2 3 4" "1 2 3 4"
# [1] "2 3 4 5" "2 3 4 5"
# [1] "3 4 5 6"
#   V1 V2 V3 V4                         x
# 1  1  2  3  4 1 2 3 4, 1 2 3 4, 1 2 3 4
# 2  2  3  4  5          2 3 4 5, 2 3 4 5
# 3  3  4  5  6                   3 4 5 6

因此，这给了我粘贴的字符串。因此，如果我使用

length

而不是

print

，它应该给出这样的出现次数，这是期望的结果，情况就是这样（如下所示）

这似乎奏效了。但是，当

data.frame

维度为4*2500时，输出

data.frame

为1*2501，而不是4*2501（所有行都是唯一的，因此频率为1）

>df o dim（o）
# [1]    1 2501

---

我使用较小的data.frames进行测试，它只具有唯一的行，并给出正确的输出（例如，change

nrow=40

）。然而，当矩阵的维数增加时，这似乎不起作用。我就是不知道出了什么问题！有什么想法吗？

这里的问题是

aggregate.data.frame（）

如何确定组

在

aggregate.data.frame（）。在该循环中，
grp
通过以下方式更改/更新：

grp <- grp * nlevels(ind) + (as.integer(ind) - 1L)

实际上，循环更新将
grp
的值推到了一个与
Inf
无法区分的数字

完成此操作后，
aggregate.data.frame（）
稍后将执行此操作

y <- y[match(sort(unique(grp)), grp, 0L), , drop = FALSE]

因为

match(sort(unique(grp)), grp, 0L)

显然，只返回
1
：

> match(sort(unique(grp)), grp, 0L)
[1] 1

由于
grp
只有一个唯一值，这可能是因为字符串太长，
as.character
插入换行符？是的，作为替代方法，您可以执行
聚合（rep（1，nrow（df）），df，FUN=length）
。这与
as.character（）
无关，因为它的每个参数都是长度为1的向量。要查看此部分是否有效，只需执行
do.call（粘贴，df[1:3，]）
。由
by
组成的组太多了。我不建议您这样做，但另一种查看问题的方法是形成子数据帧，聚合将对其起作用
grp
没有转到
Inf
：
长度（拆分（do.call（粘贴，df），df））
。警告：有人会消耗你所有的内存（在我的4GB笔记本电脑上，我很快就浪费了交换空间）。@Arun-yep，
debugonce（）
是你做这类事情的朋友。
Browse[2]> grp
[1] Inf Inf Inf Inf

y <- y[match(sort(unique(grp)), grp, 0L), , drop = FALSE]

dim(y[match(sort(unique(grp)), grp, 0L), , drop = FALSE])

match(sort(unique(grp)), grp, 0L)

> match(sort(unique(grp)), grp, 0L)
[1] 1