Question

我需要逐行写入列表中出现的矩阵和稀疏矩阵的文件，我正在做这样的事情：

Address.Persons

可以在R中调用此函数：

#include <RcppArmadillo.h>

// [[Rcpp::export]]
bool write_rows (Rcpp::List data, Rcpp::CharacterVector clss, int n) {

  int len = data.length();
  for(int i = 0; i<n; i++) {
    for(int j=0; j<len; j++) {
      if (clss[j] == "matrix") {
        Rcpp::NumericMatrix x = data[j];
        auto row = x.row(i);
        // do something with row i
      } else if (clss[j] == "dgCMatrix") {
        arma::sp_mat x = data[j];
        auto row = x.row(i);
        // do something different with row i
      }
    }
  }

  return true;
}

该函数接收具有相同行数的矩阵或稀疏矩阵列表，并逐行写入这些矩阵，即。首先写入data <- list( x = Matrix::rsparsematrix(nrow = 1000, ncol = 1000, density = 0.3), y = matrix(1:10000, nrow = 1000, ncol = 10) ) clss <- c("dgCMatrix", "matrix") write_rows(data, clss, 1000)中所有元素的第一行，然后写入所有元素的第二行等等。

我的问题是，似乎这一行data似乎对性能产生了巨大影响，因为我似乎隐式地将列表元素arma::sp_mat x = data[i];强制转换为Armadillo稀疏矩阵{{1} }次。

我的问题是：无论如何我可以避免这种情况吗？有更有效的解决方案吗？我试着通过查看data[j]的源代码找到一个解决方案，因为它们也逐行编写列表元素，但它们也为每一行（in this line for example执行转换，但是这可能没有'因为他们处理SEXPS会对性能产生影响吗？

Answer 1

通过澄清，似乎结果应该交织来自每个矩阵的行。您仍然可以在避免多次转化的情况下执行此操作。

这是原始代码，经过修改后可生成一些实际输出：

// [[Rcpp::export]]
arma::mat write_rows(Rcpp::List data, Rcpp::CharacterVector clss, int nrows, int ncols) {

    int len = data.length();
    arma::mat result(nrows*len, ncols);

    for (int i = 0, k = 0; i < nrows; i++) {
        for (int j = 0; j < len; j++) {
            arma::rowvec r;

            if (clss[j] == "matrix") {
                Rcpp::NumericMatrix x = data[j];
                r = x.row(i);
            }
            else {
                arma::sp_mat x = data[j];
                r = x.row(i);
            }

            result.row(k++) = r;
        }
    }

    return result;
}

以下代码创建转换对象的向量，然后根据需要从每个对象中提取行。每个矩阵只进行一次转换。我使用一个包含密集和稀疏垫的结构，因为它比处理联合更简单;我不想拖入boost::variant或要求C ++ 17。由于我们只想处理2个类，因此开销很小。

struct Matrix_types {
    arma::mat m;
    arma::sp_mat M;
};

// [[Rcpp::export]]
arma::mat write_rows2(Rcpp::List data, Rcpp::CharacterVector clss, int nrows, int ncols) {

    const int len = data.length();
    std::vector<Matrix_types> matr(len);
    std::vector<bool> is_dense(len);
    arma::mat result(nrows*len, ncols);

    // populate the structs
    for (int j = 0; j < len; j++) {
        is_dense[j] = (clss[j] == "matrix");
        if (is_dense[j]) {
            matr[j].m = Rcpp::as<arma::mat>(data[j]);
        }
        else {
            matr[j].M = Rcpp::as<arma::sp_mat>(data[j]);
        }
    }

    // populate the result
    for (int i = 0, k = 0; i < nrows; i++) {
        for (int j = 0; j < len; j++, k++) {
            if (is_dense[j]) {
                result.row(k) = matr[j].m.row(i);
            }
            else {
                arma::rowvec r(matr[j].M.row(i));
                result.row(k) = r;
            }
        }
    }

    return result;
}

运行一些测试数据：

data <- list(
    a=Matrix(1.0, 1000, 1000, sparse=TRUE),
    b=matrix(2.0, 1000, 1000),
    c=Matrix(3.0, 1000, 1000, sparse=TRUE),
    d=matrix(4.0, 1000, 1000)
)

system.time(z <- write_rows(data, sapply(data, class), 1000, 1000))
#   user  system elapsed 
# 185.75   35.04  221.38 

system.time(z2 <- write_rows2(data, sapply(data, class), 1000, 1000))
#   user  system elapsed 
#   4.21    0.05    4.25 

identical(z, z2)
# [1] TRUE

在Rcpp中交叉许多对象的结果

1 个答案: