R: Quando si utilizza data.table come faccio a colonne di y quando faccio x [y]?

Question

UPDATE :. Vecchia questione ... è stato risolto da v1.5.3 data.table nel febbraio 2011

Sto cercando di usare il pacchetto data.table, e davvero come gli incrementi nella velocità che sto ottenendo, ma sono perplesso da questo errore quando faccio x[y, <expr>] dove x e y sono "data-tavoli" con la stessa chiave, e <expr> contiene nomi delle colonne di entrambi x e y:

require(data.table)
x <- data.table( foo = 1:5, a = 5:1 )
y <- data.table( foo = 1:5, boo = 10:14)
setkey(x, foo)
setkey(y, foo)
> x[y, foo*boo]
Error in eval(expr, envir, enclos) : object 'boo' not found

UPDATE ... Per chiarire la funzionalità Sto cercando nell'esempio di cui sopra: ho bisogno di fare l'equivalente di quanto segue:

with(merge(x,y), foo*boo)

Tuttavia, secondo il sotto estratto del data.table FAQ, questo dovrebbe aver funzionato:

Infine, anche se sembra come se x [y] non restituisce le colonne in y, si può effettivamente utilizzare le colonne da y nell'espressione j. Questo è ciò che intendiamo per unirsi ambito ereditato. Perchè no basta tornare l'unione di tutte le colonne x ed y e quindi eseguire espressioni che? Si riduce a ecienza di codice e ciò che è più veloce programmare. Quando si scrive x [y, foo boo], data.table automaticamente ispeziona l'espressione j per vedere quale colonne utilizza. Sarà solo sottoinsieme, o gruppo, solo le colonne. Memoria viene creato solo per le colonne j usi. diciamo foo Let è in x, e boo è in y (insieme ad altri 20 colonne in y). Non è x [y, foo boo] più veloce da programma e più veloce per l'esecuzione di un step merge seguito da un altro sottoinsieme passo?

Sono a conoscenza di questa domanda che affrontato un problema simile, ma non sembrava essere stato risolto in modo soddisfacente. Qualcuno sa che cosa manco o incomprensione? Grazie.

UPDATE: ho chiesto sulla tabella dati help mailing list e l'autore del pacchetto (Matteo Dowle) risposero che effettivamente il FAQ citato sopra è sbagliato, quindi la sintassi sto utilizzando non funziona attualmente, vale a dire che non può fare riferimento al colonne y nell'argomento j (cioè secondo) quando faccio x[y,...].

Answer 1

Non sono sicuro se ho capito bene il problema, e ho anche appena iniziato a leggere la documentazione di data.table biblioteca, ma credo che se si desidera ottenere le colonne di y e anche fare qualcosa per coloro che dalle colonne di a , si potrebbe provare qualcosa di simile:

> x[y,a*y]
     foo boo
[1,]   5  50
[2,]   8  44
[3,]   9  36
[4,]   8  26
[5,]   5  14

Qui, si torna dalle colonne del y , moltiplicato per la colonna a di x . Se si desidera ottenere x 's pippo , moltiplicato per y ' s boo , provare:

> y[,x*boo]
     foo  a
[1,]  10 50
[2,]  22 44
[3,]  36 36
[4,]  52 26
[5,]  70 14

---

Dopo aver modificato: grazie @Prasad Chalasani rendere la questione più chiara per me

.

Se semplice fusione è preferito, quindi il seguente dovrebbe funzionare. Ho fatto una dei dati più complessa per vedere le azioni più profondo:

x <- data.table( foo = 1:5, a=20:24, zoo = 5:1 )
y <- data.table( foo = 1:5, b=30:34, boo = 10:14)
setkey(x, foo)
setkey(y, foo)

Quindi, solo una colonna in più è stato aggiunto a ciascun data.table. Vediamo merge e farlo con data.tables:

> system.time(merge(x,y))
   user  system elapsed 
  0.027   0.000   0.023 
> system.time(x[,list(y,x)])
   user  system elapsed 
  0.003   0.000   0.006 

Da quale quest'ultima sembra molto più veloce. I risultati non sono però identici, ma possono essere utilizzati nello stesso modo (con una colonna supplementare di quest'ultimo run):

> merge(x,y)
     foo  a zoo  b boo
[1,]   1 20   5 30  10
[2,]   2 21   4 31  11
[3,]   3 22   3 32  12
[4,]   4 23   2 33  13
[5,]   5 24   1 34  14
> x[,list(x,y)]
     foo  a zoo foo.1  b boo
[1,]   1 20   5     1 30  10
[2,]   2 21   4     2 31  11
[3,]   3 22   3     3 32  12
[4,]   4 23   2     4 33  13
[5,]   5 24   1     5 34  14

Quindi, per ottenere xy potremmo usare: xy <- x[,list(x,y)]. Per calcolare un data.table una colonna dal xy$foo * xy$boo, i seguenti lavori potenza:

> xy[,foo*boo]
[1] 10 22 36 52 70

Bene, il risultato non è un data.table ma un vettore al posto.

---

Aggiornamento (29/03/2012):. grazie per @ David per indicare la mia attenzione sul fatto che merge.data.table sono stati utilizzati negli esempi precedenti