R 带有列和行的分面 qqplots

我需要使用按行和列的构面创建 qqplot。我了解如何用列和行绘制分面图，但我不确定如何设置我的数据。最终，我想按列和行对数据集进行分组，然后按升序对“建模”结果和“观察到”结果进行排序，同时添加带有“行”组的列和带有“列”组的列。

我一直在尝试修改这个问题的解决方案，使用 ggplot2 进行分面 qqplots https://stackoverflow.com/questions/12369377/faceted-qqplots-with-ggplot2，，但我对 lapply 不太熟悉，所以也许我错过了一些东西。

这是我一直在使用的代码：

#Dummy Data:
df <- mtcars
# Name columns as I have in my real data
df$rows <- df$cyl
df$columns <- df$gear
df$Modeled <- df$wt
df$Observed <- df$mpg

# Function to sort data while maintaining the rows & columns for use in facet later.
dat_sort <- do.call("rbind", 
                  sapply(list(unique(df$rows), unique(df$columns)), 
                         FUN = function(x) {
                           data.frame(rows = x[[1]], 
                                      columns = x[[2]], 
                                      Observed = sort(df$Observed[df$rows == x[[1]] & df$columns == x[[2]]]), 
                                      Modeled = sort(df$Modeled[df$rows == x[[1]] & df$columns == x[[2]]])
                                      )
                           }
                         ))

我没有收到错误，但我的输出绝对不是我所期望的。我的输出应如下所示：（具有正确的列名称）

rows columns Observed Modeled
6      4      17.8      2.620
6      4      19.2      2.875
6      4      21.0      3.440
6      4      21.0      3.440
4      3      21.5      2.465
8      5      15.0      3.17
8      5      15.8      3.57   

代码输出：

       [,1]   [,2]   [,3]   [,4]
[1,]  6.000  6.000  6.000  6.000
[2,]  4.000  4.000  4.000  4.000
[3,] 17.800 19.200 21.000 21.000
[4,]  2.620  2.875  3.440  3.440
[5,]  4.000  4.000  4.000  4.000
[6,]  3.000  3.000  3.000  3.000
[7,] 21.500 21.500 21.500 21.500
[8,]  2.465  2.465  2.465  2.465

非常感激任何的帮助！

Thanks!

我们只需要order数据集按升序排列，可以通过以下方式完成order

df1 <- df[c('rows', 'columns', 'Observed', 'Modeled')]
df2 <- df1[do.call(order, -df1),]

在OP的代码中，更改sapply to lapply返回为list (sapply默认情况下使用simplify = TRUE返回一个matrix)

do.call(rbind, lapply(list(unique(df$rows),
        unique(df$columns)), 
            FUN = function(x) {
               data.frame(rows = x[[1]], 
                          columns = x[[2]], 
                          Observed = sort(df$Observed[df$rows == x[[1]] & 
                                   df$columns == x[[2]]]), 

                          Modeled = sort(df$Modeled[df$rows == x[[1]] &
                                     df$columns == x[[2]]])
                                                               )
                                                    }
                                                  ))
#   rows columns Observed Modeled
#1    6       4     17.8   2.620
#2    6       4     19.2   2.875
#3    6       4     21.0   3.440
#4    6       4     21.0   3.440
#5    4       3     21.5   2.465

通过循环unique as a list，每个向量都是一个单独的list元素和x[[1]], x[[2]]实际上是基于第二个元素的 6, 4 和 4, 3 进行子集化

list(unique(df$rows), unique(df$columns))
#[[1]]
#[1] 6 4 8

#[[2]]
#[1] 4 3 5

相反，如果我们需要对相应的元素执行此操作，则使用Map或循环序列unique元素（假设它们具有相同的长度），但更简单的方法是split

如果长度相同unique元素，并且想要根据相应的值进行子集，然后使用Map

do.call(rbind, Map(function(x, y) {
    i1 <- df$rows == x & df$columns == y
    data.frame(rows = x, columns = y,
               Observed = sort(df$Observed[i1]),
               Modeled = sort(df$Modeled[i1]))},
    unique(df$rows), unique(df$columns)))
#  rows columns Observed Modeled
#1    6       4     17.8   2.620
#2    6       4     19.2   2.875
#3    6       4     21.0   3.440
#4    6       4     21.0   3.440
#5    4       3     21.5   2.465
#6    8       5     15.0   3.170
#7    8       5     15.8   3.570