Question

我编写了以下编译的Rcpp代码，但速度并不像预期的那样快。

// [[Rcpp::export]]
NumericVector combine_list_to_vec (const Rcpp::List& list)
{
  int list_size = list.size();
  int large_vec_size = 0;
  IntegerVector start_index(list_size);
  IntegerVector end_index(list_size);
  for (int ii = 0; ii < list_size; ii++)
  {
    NumericVector vec = list[ii];
    start_index[ii] = large_vec_size;
    large_vec_size += vec.size();
    end_index[ii] = large_vec_size - 1;
  }
  NumericVector large_vec(large_vec_size);   // Creating object after getting its size
  for (int ii = 0; ii < list_size; ii++)
  {
    int current_start_index = start_index[ii];
    NumericVector vec = list[ii];
    for (int jj = 0; jj < vec.size(); jj++)
    {
      large_vec[jj + current_start_index] = vec[jj];
    }
  }
  return large_vec;
}

输入变量'list'包含一堆NumericVector，我想把它们组合成一个大的，带有'... tail - head -tail ...'结构。 start_index和end_index变量用于方便复制。

微基准测试为特定示例提供了以下信息：

x=list();
x[[1]]=runif(1E6);  x[[2]]=runif(1E6);
x[[3]]=runif(1E6);  x[[4]]=runif(1E6);
x[[5]]=runif(1E6);  x[[6]]=runif(1E6);
x[[7]]=runif(1E6);  x[[8]]=runif(1E6);
x[[9]]=runif(1E6);  x[[10]]=runif(1E6);
microbenchmark(combine_list_to_vec(x) -> y)

# Unit: milliseconds
                        expr       min        lq       mean    median        uq       max neval
# y <- combine_list_to_vec(x) 84.166964 84.587516 89.9520601 84.728212 84.871673 349.33234   100

我尝试的另一种方法是调用外部R函数do.call(c,x)：

// [[Rcpp::export]]
List combine_list_to_vec (const Rcpp::List& list)
{
  int list_size = list.size();
  int large_vec_size = 0;
  IntegerVector start_index(list_size);
  IntegerVector end_index(list_size);
  for (int ii = 0; ii < list_size; ii++)
  {
    NumericVector vec = list[ii];
    start_index[ii] = large_vec_size;
    large_vec_size += vec.size();
    end_index[ii] = large_vec_size - 1;
  }
  NumericVector large_vec = internal::convert_using_rfunction(list, "sub_do_call");
  List rtn = List::create(large_vec, start_index, end_index);
  return rtn;
}

// The following codes exist as R codes instead of Rcpp
sub_do_call <- function (x)
{
  return (do.call(c, x));
}

速度几乎是之前代码的4倍。有没有办法可以通过在Rcpp和/或RcppArmadillo中使用指针或其他工具来加速组合操作，或者只是在Rcpp中编写do.call（c，x）而不是在外部调用它？谢谢。

Answer 1

如果我理解正确，您基本上会问，＆＃34;我如何在base::unlist中撰写Rcpp？＆＃34;而且，由于base::unlist是一个.Internal函数（它有一个C实现），因此Rcpp不太可能让您做得更好。

但是，为了好玩，让我们试试吧。这是我将使用的与您类似的实现，但是应该更便宜，因为我们使用std::copy而不是在每次迭代时重新编制索引：

#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::export]]
NumericVector combine(const List& list)
{
   std::size_t n = list.size();

   // Figure out the length of the output vector
   std::size_t total_length = 0;
   for (std::size_t i = 0; i < n; ++i)
      total_length += Rf_length(list[i]);

   // Allocate the vector
   NumericVector output = no_init(total_length);

   // Loop and fill
   std::size_t index = 0;
   for (std::size_t i = 0; i < n; ++i)
   {
      NumericVector el = list[i];
      std::copy(el.begin(), el.end(), output.begin() + index);

      // Update the index
      index += el.size();
   }

   return output;

}

/*** R
library(microbenchmark)
x <- replicate(10, runif(1E6), simplify = FALSE)
identical(unlist(x), combine(x))
microbenchmark(
   unlist(x),
   combine(x)
)
*/

运行此代码会给我：

> Rcpp::sourceCpp('C:/Users/Kevin/scratch/combine.cpp')

> library(microbenchmark)

> x <- replicate(10, runif(1E6), simplify = FALSE)

> identical(unlist(x), combine(x))
[1] TRUE

> microbenchmark(
+    unlist(x),
+    combine(x)
+ )
Unit: milliseconds
       expr      min       lq     mean   median       uq      max neval
  unlist(x) 21.89620 22.43381 29.20832 23.14454 35.32135 68.09562   100
 combine(x) 20.96225 21.55827 28.13269 22.08985 24.13403 51.68660   100

所以，实际上是一样的。我们只是因为我们没有进行任何类型检查而获得了一点点时间（这意味着如果我们没有包含仅包含数字向量的列表，这些代码会爆炸）但至少应该说明事实我们真的不能在这里做得更好。

（我猜，唯一的例外是巨大的向量，其中并行处理可能对此有帮助）

如何有效地将NumericVectors列表组合成一个大的NumericVector？

1 个答案: