Przejdź przez kolumny, aby zsumować 2 poprzednie liczby w każdym wierszu

Aug 15 2020

W R mam ramkę danych z kolumnami „A”, „B”, „C”, „D”. Kolumny mają 100 wierszy.

Muszę iterować po kolumnach, aby wykonać obliczenia dla wszystkich wierszy w ramce danych, które sumują poprzednie 2 wiersze tej kolumny, a następnie ustawić w nowych kolumnach („AA”, „AB” itp.), Jaka jest ta suma:

A  B  C  D 
1  2  3  4
2  3  4  5
3  4  5  6
4  5  6  7 
5  6  7  8
6  7  8  9

do

A   B   C   D   AA   AB   AC   AD
1   2   3   4   NA   NA   NA   NA
2   3   4   5   3    5    7    9
3   4   5   6   5    7    9    11
4   5   6   7   7    9    11   13
5   6   7   8   9    11   13   15
6   7   8   9   11   13   15   17

Czy ktoś może wyjaśnić, jak utworzyć funkcję / pętlę, która pozwala mi ustawić kolumny, które chcę iterować (wybrane kolumny, a nie wszystkie kolumny) i kolumny, które chcę ustawić?

Odpowiedzi

2 DarrenTsai Aug 15 2020 at 17:50

baseJedna wkładka:

cbind(df, setNames(df + df[c(NA, 1:(nrow(df)-1)), ], paste0("A", names(df))))

Jeśli twoje dane są duże, ten może być najszybszy, ponieważ obsługuje całość data.frame.


dplyrRozwiązanie wykorzystujące mutate()z across().

library(dplyr)

df %>%
  mutate(across(A:D,
                ~ .x + lag(.x),
                .names = "A{col}"))

#   A B C D AA AB AC AD
# 1 1 2 3 4 NA NA NA NA
# 2 2 3 4 5  3  5  7  9
# 3 3 4 5 6  5  7  9 11
# 4 4 5 6 7  7  9 11 13
# 5 5 6 7 8  9 11 13 15
# 6 6 7 8 9 11 13 15 17

Jeśli chcesz zsumować poprzednie 3 wiersze, drugi argument across(), tj. .fns, Powinien mieć wartość

~ .x + lag(.x) + lag(.x, 2)

co jest równoważne użyciu rollsum()w zoo:

~ zoo::rollsum(.x, k = 3, fill = NA, align = 'right')

Reper

Test porównawczy z microbenchmarkpakietem na nowym data.framez 10000 wierszy i 100 kolumnami i oceniaj każde wyrażenie 10 razy.

# Unit: milliseconds
#                     expr        min         lq       mean     median         uq        max neval
#              darren_base   18.58418   20.88498   35.51341   33.64953   39.31909   80.24725    10
#         darren_dplyr_lag   39.49278   40.27038   47.26449   42.89170   43.20267   76.72435    10
# arg0naut91_dplyr_rollsum  436.22503  482.03199  524.54800  516.81706  534.94317  677.64242    10
#    Grothendieck_rollsumr 3423.92097 3611.01573 3650.16656 3622.50895 3689.26404 4060.98054    10
1 arg0naut91 Aug 15 2020 at 17:49

Możesz użyć dplyr's across(i ustawić opcjonalne nazwy) z sumą kroczącą (zaimplementowaną np. W zoo):

library(dplyr)
library(zoo)

df %>%
  mutate(
    across(
      A:D,
      ~ rollsum(., k = 2, fill = NA, align = 'right'), 
      .names = 'A{col}'
    )
  )

Wynik:

  A B C D AA AB AC AD
1 1 2 3 4 NA NA NA NA
2 2 3 4 5  3  5  7  9
3 3 4 5 6  5  7  9 11
4 4 5 6 7  7  9 11 13
5 5 6 7 8  9 11 13 15
6 6 7 8 9 11 13 15 17

Za pomocą A:Dokreśliliśmy zakres nazw kolumn, do których chcemy zastosować funkcję. Założenie powyżej w .namesargumencie jest takie, że chcesz wkleić razem Ajako przedrostek i nazwę kolumny ( {col}).

1 pseudospin Aug 15 2020 at 19:34

Oto rozwiązanie data.table. Jak o to prosisz, pozwala wybrać, do których kolumn chcesz zastosować, a nie tylko do wszystkich kolumn.

library(data.table)
x <- data.table(A=1:6, B=2:7, C=3:8, D=4:9)
selected_cols <- c('A','B','D')
new_cols <- paste0("A",selected_cols)
x[, (new_cols) := lapply(.SD, function(col) col+shift(col, 1)), .SDcols = selected_cols]
x[]

Uwaga: To jest 2 lub 3 razy szybsze niż najszybsza inna odpowiedź.

1 ivan866 Aug 15 2020 at 17:59

To naiwne podejście z zagnieżdżonymi forpętlami. Uważaj, jeśli zamierzasz iterować ponad setki tysięcy wierszy, jest to cholernie wolne.

i <- 1
n <- 5
df <- data.frame(A=i:(i+n), B=(i+1):(i+n+1), C=(i+2):(i+n+2), D=(i+3):(i+n+3))
for (col in colnames(df)) {
  for (ind in 1:nrow(df)) {
    if (ind-1==0) {next}
    s <- sum(df[c(ind-1, ind), col])
    df[ind, paste0('S', col)] <- s
  }
}  

To jest cumsummetoda:

na.df <- data.frame(matrix(NA, 2, ncol(df)))
colnames(na.df) <- colnames(df)
cs1 <- cumsum(df)
cs2 <- rbind(cs1[-1:-2,], na.df)
sum.diff <- cs2-cs1
cbind(df, rbind(na.df[1,], cs1[2,], sum.diff[1:(nrow(sum.diff)-2),]))  

Reper:

#    Unit: milliseconds  
#                      expr     min       lq     mean   median       uq     max neval  
#          darrentsai.rbind 11.5623 12.28025 23.38038 16.78240 20.83420 91.9135   100  
#     darrentsai.rbind.rev1  8.8267  9.10945 15.63652  9.54215 14.25090 62.6949   100  
#             pseudopsin.dt  7.2696  7.52080 20.26473 12.61465 17.61465 69.0110   100  
#            ivan866.cumsum 25.3706 30.98860 43.11623 33.78775 37.36950 91.6032   100  

Uważam, że w większości przypadków metoda kumulacji marnuje przydział df. Jeśli zostanie poprawnie dostosowany do backendu data.table, może być najszybszy.

1 G.Grothendieck Aug 16 2020 at 03:14

Określ żądane kolumny. Pokazujemy kilka różnych sposobów, aby to zrobić. Następnie użyj, rollsumraby uzyskać żądane kolumny, ustaw nazwy kolumn i cbind DFz nimi.

library(zoo)

# jx <- names(DF)  # if all columns wanted
# jx <- sapply(DF, is.numeric)  # if all numeric columns
# jx <- c("A", "B", "C", "D")  # specify columns by name
jx <- 1:4   # specify columns by position

r <- rollsumr(DF[jx], 2, fill = NA)
colnames(r) <- paste0("A", colnames(r))
cbind(DF, r)

dający:

  A B C D AA AB AC AD
1 1 2 3 4 NA NA NA NA
2 2 3 4 5  3  5  7  9
3 3 4 5 6  5  7  9 11
4 4 5 6 7  7  9 11 13
5 5 6 7 8  9 11 13 15
6 6 7 8 9 11 13 15 17

Uwaga

Dane wejściowe w odtwarzalnej formie:

DF <- structure(list(A = 1:6, B = 2:7, C = 3:8, D = 4:9), 
  class = "data.frame", row.names = c(NA, -6L))