主页 / coding / 问题 / 79066762
Accepted
M. Beausoleil
Asked: 2024-10-08 23:42:57 +0800 CST

R 中选定基码与其他代码之间的滚动差异

  • 772

我有一个代码，其中有一个场景（sc列）和一个代码名称（cd列）。我想计算所有场景与第一个场景之间的差异（所以场景2-1，3-1等等。我还有多个场景......）。有没有一种快速的方法来编码将要比较哪个场景，例如，如果我现在所有其他场景的比较场景现在是场景 2，那将是1-2，3-2等等？

但我也想确保在场景之间只减去相同的代号名称（cd），所以（sc1.cd1 - sc2.cd1），（sc1.cd2 - sc2.cd2）等等。

sc我还想要了解每个代码中 1 与其他场景之间的百分比差异。

目前，我的代码假设当我比较场景时，它们cd的顺序相同。有没有办法将场景和代码一起比较，而不是使用数据子集？

set.seed(123456)
vals = as.vector(mapply(FUN = rpois, n = 10, lambda = c(5, 10, 100)))
df.test = data.frame(cd = rep(1:10,3), sc = rep(1:3, each =10 ), vals)

# New empty column 
df.test$delta = NA

# Subset each scenarios and subtract for the first scenario
df.test[df.test$sc ==1,'delta'] = df.test[df.test$sc ==1,'vals']-df.test[df.test$sc ==1,'vals']
df.test[df.test$sc ==2,'delta'] = df.test[df.test$sc ==2,'vals']-df.test[df.test$sc ==1,'vals']
df.test[df.test$sc ==3,'delta'] = df.test[df.test$sc ==3,'vals']-df.test[df.test$sc ==1,'vals']

# Get difference
df.test$diff = abs(abs(df.test$delta) - df.test$vals)

# Calculate percentage
df.test$delta.perc = abs(df.test$delta) / df.test$diff +1
df.test$diff * df.test$delta.perc

# Percentage increase
df.test$delta.perc.increase = df.test$delta.perc *100

2 个回答

  1. 您可以sapply对 进行减法运算unique(sc)。使用时transform您不需要df.test$一直书写。

    > df.test |> 
+   transform(delta=sapply(unique(sc), FUN=\(x) {
+     vals[sc == x] - vals[sc == 1]
+   }) |> as.vector()) |> 
+   transform(dif=abs(delta - vals)) |> 
+   transform(delta.perc=abs(delta)/dif + 1) |> 
+   transform(delta.perc.increase=delta.perc*100)
   cd sc vals delta dif delta.perc delta.perc.increase
1   1  1    7     0   7   1.000000            100.0000
2   2  1    6     0   6   1.000000            100.0000
3   3  1    4     0   4   1.000000            100.0000
4   4  1    4     0   4   1.000000            100.0000
5   5  1    4     0   4   1.000000            100.0000
6   6  1    3     0   3   1.000000            100.0000
7   7  1    5     0   5   1.000000            100.0000
8   8  1    2     0   2   1.000000            100.0000
9   9  1   11     0  11   1.000000            100.0000
10 10  1    3     0   3   1.000000            100.0000
11  1  2   12     5   7   1.714286            171.4286
12  2  2   14     8   6   2.333333            233.3333
13  3  2   17    13   4   4.250000            425.0000
14  4  2   13     9   4   3.250000            325.0000
15  5  2    8     4   4   2.000000            200.0000
16  6  2    6     3   3   2.000000            200.0000
17  7  2    7     2   5   1.400000            140.0000
18  8  2   13    11   2   6.500000            650.0000
19  9  2   13     2  11   1.181818            118.1818
20 10  2   10     7   3   3.333333            333.3333
21  1  3   92    85   7  13.142857           1314.2857
22  2  3   85    79   6  14.166667           1416.6667
23  3  3  105   101   4  26.250000           2625.0000
24  4  3   92    88   4  23.000000           2300.0000
25  5  3   94    90   4  23.500000           2350.0000
26  6  3  101    98   3  33.666667           3366.6667
27  7  3  104    99   5  20.800000           2080.0000
28  8  3   95    93   2  47.500000           4750.0000
29  9  3  110    99  11  10.000000           1000.0000
30 10  3  118   115   3  39.333333           3933.3333

    使用within，更简洁，但新的列是向后排序的。

    > df.test |> within({
+   delta <- sapply(unique(sc), FUN=\(x) {
+     vals[sc == x] - vals[sc == 1]
+   }) |> as.vector()
+   dif <- abs(delta - vals)
+   delta.perc <- abs(delta)/dif + 1
+   delta.perc.increase <- delta.perc*100
+ })
   cd sc vals delta delta.perc.increase delta.perc dif
1   1  1    7     0            100.0000   1.000000   7
2   2  1    6     0            100.0000   1.000000   6
3   3  1    4     0            100.0000   1.000000   4
4   4  1    4     0            100.0000   1.000000   4
5   5  1    4     0            100.0000   1.000000   4
6   6  1    3     0            100.0000   1.000000   3
7   7  1    5     0            100.0000   1.000000   5
8   8  1    2     0            100.0000   1.000000   2
9   9  1   11     0            100.0000   1.000000  11
10 10  1    3     0            100.0000   1.000000   3
11  1  2   12     5            171.4286   1.714286   7
12  2  2   14     8            233.3333   2.333333   6
13  3  2   17    13            425.0000   4.250000   4
14  4  2   13     9            325.0000   3.250000   4
15  5  2    8     4            200.0000   2.000000   4
16  6  2    6     3            200.0000   2.000000   3
17  7  2    7     2            140.0000   1.400000   5
18  8  2   13    11            650.0000   6.500000   2
19  9  2   13     2            118.1818   1.181818  11
20 10  2   10     7            333.3333   3.333333   3
21  1  3   92    85           1314.2857  13.142857   7
22  2  3   85    79           1416.6667  14.166667   6
23  3  3  105   101           2625.0000  26.250000   4
24  4  3   92    88           2300.0000  23.000000   4
25  5  3   94    90           2350.0000  23.500000   4
26  6  3  101    98           3366.6667  33.666667   3
27  7  3  104    99           2080.0000  20.800000   5
28  8  3   95    93           4750.0000  47.500000   2
29  9  3  110    99           1000.0000  10.000000  11
30 10  3  118   115           3933.3333  39.333333   3
    • 1
  2. Best Answer

    问题在于，您已经对场景之间的差异进行了硬编码，同时假设cd值将完全一致，这使得更改基本场景并不十分麻烦，但绝对很麻烦。

    我们可以使用dplyr来处理分组和计算，这样我们就可以动态设置任何基本场景，例如1，2或任何您想要的。我们还将确保仅在匹配cd值之间计算差异，因此不存在任何假设。

    library(dplyr)

set.seed(123456)
vals <- as.vector(mapply(FUN = rpois, n = 10, lambda = c(5, 10, 100)))
df_test <- data.frame(cd = rep(1:10, 3), sc = rep(1:3, each = 10), vals)

base_scenario <- 1

df_test <- df_test %>%
  group_by(cd) %>%
  mutate(
    base_vals = vals[sc == base_scenario],
    delta = vals - base_vals,
    delta_perc = ifelse(base_vals != 0, delta / base_vals * 100, NA)
  ) %>%
  ungroup()

print(df_test)

    这样，您可以将 设置base_scenario为您想要的任何值，它会自动更新，通过分组，cd我们确保delta是针对每个 单独计算的cd，因此您可以得到sc1.cd1 - sc2.cd2而不是按顺序减去行。我还添加了以防止在基值为 时出现ifelse任何错误。div/00

    通过这种方式，您可以将 更改base_scenario为任意值，并且它也会随之改变 - 因此当基数设置为 时，您将获得 、1-2等。3-22

    如果我没有解释清楚，请随意在回复中留下问题:)

    • 1

相关问题