Início / coding / Perguntas / 79066762
Accepted
M. Beausoleil
Asked: 2024-10-08 23:42:57 +0800 CST

diferença de rolagem entre um código base selecionado em comparação com outro código em R

  • 772

Tenho um código onde há um cenário ( sccoluna) e um nome de código ( cdcoluna). Quero calcular a diferença entre todos os cenários para o primeiro (então cenário 2-1, 3-1, etc. Tenho vários outros cenários...). Existe uma maneira rápida de codificar qual cenário será comparado, por exemplo, se eu agora o cenário do qual todos os outros são comparados é agora o cenário 2, seria 1-2, 3-2, etc.?

Mas também quero ter certeza de que, entre os cenários, eu subtraia apenas os mesmos nomes de código ( cd), então ( sc1.cd1 - sc2.cd1), ( sc1.cd2 - sc2.cd2), etc.

Também quero a diferença percentual entre o sccenário 1 em comparação aos outros para cada código.

No momento, meu código assume que, quando comparo os cenários, eles cdestão na mesma ordem. Haveria uma maneira de comparar os cenários e o código juntos em vez de usar um subconjunto dos dados?

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 respostas

  1. Você poderia fazer sapplya subtração sobre o unique(sc). Usando transformvocê não precisa escrever df.test$o tempo todo.

    > 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

    Usando within, mais conciso, mas as novas colunas são ordenadas de trás para frente.

    > 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

    O problema é que você codificou as diferenças entre os cenários, assumindo que cdos valores se alinharão perfeitamente, o que torna a alteração do cenário base não tão trabalhosa, mas definitivamente um incômodo.

    Podemos usar dplyrpara lidar com o agrupamento e os cálculos, dessa forma podemos definir qualquer cenário base dinamicamente, como 1, 2, ou o que você quiser. Também garantiremos que as diferenças sejam calculadas apenas entre cdvalores correspondentes, para que não haja suposições.

    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)

    dessa forma você pode definir o base_scenariopara qualquer valor que você quiser e ele atualiza automagicamente, e ao agrupar por cdnós garantimos que os delta's sejam calculados individualmente para cada cd, então você obtém sc1.cd1 - sc2.cd2em vez de apenas subtrair linhas em ordem. Eu também adicionei o ifelsepara evitar div/0erros quando o valor base é 0.

    Fazer dessa forma permite que você altere o base_scenariopara qualquer valor e ele será alterado para ele — então você obterá 1-2, 3-2, etc., quando a base for definida como 2.

    Se eu não expliquei algo bem o suficiente, fique à vontade para deixar uma pergunta nas respostas :)

    • 1

relate perguntas