Самый быстрый способ поиска совпадающих строк

Ответ 1

Поскольку вы сказали, что скорость - ваша главная проблема, вы можете получить ускорение даже над решением data.table с Rcpp:

library(Rcpp)
cppFunction(
"LogicalVector compareToRow(NumericMatrix x, NumericVector y) {
  const int nr = x.nrow();
  const int nc = x.ncol();
  LogicalVector ret(nr, true);
  for (int j=0; j < nr; ++j) {
    for (int k=0; k < nc; ++k) {
      if (x(j, k) != y[k]) {
        ret[j] = false;
        break;
      }
    }
  }
  return ret;
}")
testXts[compareToRow(testXts, rowToSearch),]
#                   a         b         c
# 1970-01-02 1.324457 0.8485654 -1.464764
# 1970-01-05 1.324457 0.8485654 -1.464764
# 1970-01-08 1.324457 0.8485654 -1.464764

Здесь сравнивается довольно большой экземпляр (с 1 миллионом строк):

set.seed(144)
bigXts <- testXts[sample(nrow(testXts), 1000000, replace=TRUE),]
testDT <- as.data.frame(bigXts)

josilber <- function(x, y) x[compareToRow(x, y),]
roland.base <- function(x, y) x[colSums(t(x) != as.vector(y)) == 0L,]
library(data.table)
roland.dt <- function(testDT, y) {
  setDT(testDT, keep.rownames=TRUE)
  setkey(testDT, a, b, c)
  testDT[setDT(as.data.frame(y))]
}
library(microbenchmark)
microbenchmark(josilber(bigXts, rowToSearch), roland.base(bigXts, rowToSearch), roland.dt(testDT, rowToSearch), times=10)
# Unit: milliseconds
#                              expr         min         lq       mean     median         uq       max
#     josilber(bigXts, rowToSearch)    7.830986   10.24748   45.64805   14.41775   17.37049  258.4404
#  roland.base(bigXts, rowToSearch) 3530.042324 3964.72314 4288.05758 4179.64233 4534.21407 5400.5619
#    roland.dt(testDT, rowToSearch)   32.826285   34.95014  102.52362   57.30213  130.51053  267.2249

В этом тесте предполагается, что объект был преобразован в кадр данных (~ 4 секунды) перед вызовом roland.dt и что compareToRows был скомпилирован (~ 3 секунды накладные расходы) перед вызовом josilber. Решение Rcpp примерно в 300 раз быстрее, чем базовое R-решение, и примерно в 4 раза быстрее, чем решение data.table в срединной среде исполнения. Подход, основанный на digest, был неконкурентоспособным, и каждый раз он выполнял более 60 секунд.

Ответ 2

Ниже приведено более быстрое базовое решение R:

ind <- colSums(t(testXts) != as.vector(rowToSearch)) == 0L
testXts[ind,]

Вот решение, использующее соединение data.table:

library(data.table)
testDT <- as.data.frame(testXts)
setDT(testDT, keep.rownames=TRUE)
setkey(testDT, a, b, c)
testDT[setDT(as.data.frame(rowToSearch))]

Однако, я был бы осторожен, если сравнивает числа с плавающей запятой.

Ответ 3

Это не использует data.table, но может быть довольно быстрым. Вы можете сделать это путем хэширования строк,

library(digest)
hash <- apply(testXts, 1, digest)
testXts[which(hash[1] == hash)]

#                    a          b          c
# 1970-01-02 0.8466816 -0.7129076 -0.5742323
# 1970-01-05 0.8466816 -0.7129076 -0.5742323
# 1970-01-08 0.8466816 -0.7129076 -0.5742323

Ответ 4

Простейшим решением data.table является, вероятно, следующее:

merge(as.data.table(testXts), as.data.table(rowToSearch, keep.rownames=FALSE))

Возврат:

          a          b         c      index
1: 1.685138 -0.3039018 -1.550871 1970-01-02
2: 1.685138 -0.3039018 -1.550871 1970-01-05
3: 1.685138 -0.3039018 -1.550871 1970-01-08

Почему это работает:

merge = внутреннее соединение на общих столбцах, если не указано иное. Это внутреннее соединение возвращает только столбцы с одинаковыми значениями (a, b, c) как rowToSearch.

keep.rownames=FALSE с правой стороны гарантирует, что индекс даты rowToSearch (который не нужен) отбрасывается и не вводит общие столбцы для соединения.