Utilizzo di data.table con funzioni di sostituzione in

Question

Oggi mi sono imbattuto nel seguente problema e mi chiedo se esiste un modo migliore per realizzare ciò che sto cercando di fare.

Supponiamo Ho il seguente data.table (solo un timestamp ogni ora):

library(data.table) 
tdt <- data.table(Timestamp = seq(as.POSIXct("1980-01-01 00:00:00"), as.POSIXct("2015-01-01 00:00:00"), '1 hour')) 

> tdt 
        Timestamp 
    1: 1980-01-01 00:00:00 
    2: 1980-01-01 01:00:00 
    3: 1980-01-01 02:00:00 
    4: 1980-01-01 03:00:00 
    5: 1980-01-01 04:00:00 
    ---      
306813: 2014-12-31 20:00:00 
306814: 2014-12-31 21:00:00 
306815: 2014-12-31 22:00:00 
306816: 2014-12-31 23:00:00 
306817: 2015-01-01 00:00:00 

Il mio obiettivo è quello di cambiare il verbale della timestamp, per esempio, 10 minuti.

So che posso usare:

library(lubridate) 
minute(tdt$Timestamp) <- 10 

ma questo non utilizza la velocità veloce eccellente di tabella di dati (che ho bisogno). Sul mio portatile ha preso questo:

> system.time(minute(tdt$Timestamp) <- 10) 
    user system elapsed 
    11.29 0.16 11.45 

Quindi, la mia domanda è: Possiamo usare in qualche modo una funzione di sostituzione nella sintassi tabella di dati in modo che possa fare quello che voglio con data.table 's di velocità? Se la risposta è no, qualsiasi altra soluzione di data.table per fare questo veloce, sarebbe accettabile.

Se vi chiedete una delle cose che ho provato è:

tdt[, Timestamp2 := minute(Timestamp) <- 10] 

che non funziona.

Output previsto (ma con tabella dati sintassi):

> tdt 
        Timestamp 
    1: 1980-01-01 00:10:00 
    2: 1980-01-01 01:10:00 
    3: 1980-01-01 02:10:00 
    4: 1980-01-01 03:10:00 
    5: 1980-01-01 04:10:00 
    ---      
306813: 2014-12-31 20:10:00 
306814: 2014-12-31 21:10:00 
306815: 2014-12-31 22:10:00 
306816: 2014-12-31 23:10:00 
306817: 2015-01-01 00:10:00 

Answer 1

funzioni ricambio vengono eseguite in due fasi:

1. Una funzione che crea l'output desiderato,
2. Questo risultato viene quindi assegnato al risultato.

È possibile eseguire step 1 without running step 2. Questo risultato può quindi essere utilizzato per impostare la colonna data.table (set utilizzata qui, ma è possibile utilizzare anche).

library(lubridate) 
library(data.table) 
tdt <- data.table(Timestamp = seq(as.POSIXct("1980-01-01 00:00:00"), as.POSIXct("2015-01-01 00:00:00"), '1 hour')) 
minute(tdt$Timestamp) <- 20 
print(`minute<-`(tdt$Timestamp,11)) 
set(tdt, j=1L,value=`minute<-`(tdt$Timestamp,11) ) 

Edit: Piccole data.table vs Big Data.tabella comparativa

library(lubridate) 
library(data.table) 
library(microbenchmark) 

# Config 
tms <- 5L 

# Sample data, 1 column 
tdt <- data.table(Timestamp = seq(as.POSIXct("1980-01-01 00:00:00"), as.POSIXct("2015-01-01 00:00:00"), '1 hour')) 
minute(tdt$Timestamp) <- 20 

tdf <- as.data.frame(tdt) 


# Sample data, lots of columns 
bdf <- cbind(tdf, as.data.frame(replicate(100, runif(nrow(tdt))))) 
bdt <- as.data.table(bdf) 

# Benchmark 
microbenchmark(
    `minute<-`(tdt$Timestamp,10), # How long does the operation to generate the new vector itself take? 
    set(tdt, j=1L,value=`minute<-`(tdt$Timestamp,11) ), # One column: How long does it take to generate the new vector and replace the contents in the data.table? 
    minute(tdf$Timestamp) <- 12, # One column: How long does it take to do it with a data.frame? 
    set(tdt, j=1L,value=`minute<-`(bdt$Timestamp,13) ), # Many columns: How long does it take to generate the new vector and replace the contents in the data.table? 
    minute(bdf$Timestamp) <- 14, # Many columns: How long does it take to do it with a data.frame? 
    times = tms 
) 

Unit: seconds 
                expr  min  lq  mean median  uq  max neval 
          `minute<-`(tdt$Timestamp, 10) 1.304388 1.385883 1.417616 1.389316 1.459166 1.549327  5 
set(tdt, j = 1L, value = `minute<-`(tdt$Timestamp, 11)) 1.314495 1.344277 1.376241 1.352124 1.389083 1.481225  5 
          minute(tdf$Timestamp) <- 12 1.342104 1.349231 1.488639 1.378840 1.380659 1.992358  5 
set(tdt, j = 1L, value = `minute<-`(bdt$Timestamp, 13)) 1.337944 1.383429 1.402802 1.418211 1.418922 1.455503  5 
          minute(bdf$Timestamp) <- 14 1.332482 1.333713 1.355331 1.335728 1.342607 1.432127  5 

Sembra che non è più veloce, che smentisce la mia comprensione di ciò che sta accadendo. Strano.

Answer 2

Un oggetto POSIXct è solo una doppia con alcuni attributi

storage.mode(as.POSIXct("1980-01-01 00:00:00")) 
## [1] "double" 

Quindi, al fine di manipolarlo efficiente si può solo trattalo come uno, per esempio

tdt[, Timestamp := Timestamp + 600L] 

aggiungerà 600 secondi (10 minuti) per ogni riga con riferimento

---

Alcuni parametri

tdt <- data.table(Timestamp = seq(as.POSIXct("1600-01-01 00:00:00"), 
            as.POSIXct("2015-01-01 00:00:00"), 
            '1 hour')) 
system.time(minute(tdt$Timestamp) <- 10) 
# user system elapsed 
# 124.86 1.95 127.68 
system.time(set(tdt, j = 1L, value = `minute<-`(tdt$Timestamp, 10))) 
# user system elapsed 
# 124.99 1.83 128.25 
system.time(tdt[, Timestamp := Timestamp + dminutes(10)]) 
# user system elapsed 
# 0.39 0.04 0.42 
system.time(tdt[, Timestamp := Timestamp + 600L]) 
# user system elapsed 
# 0.01 0.00 0.01 

Answer 3

Credo che questo dovrebbe fare il trucco per voi:

library(data.table) 
library(lubridate) 

tdt <- data.table(
    Timestamp = seq(as.POSIXct("1980-01-01 00:00:00") 
    , as.POSIXct("2015-01-01 00:00:00") 
    , '1 hour')) 
tdt[, Timestamp := Timestamp + dminutes(10)]