如何使用Rcpp将R函数转换为C ++函数？

Question

我定义了以下功能：

pij = function(vec){
  out = vec %*% t(vec)
  diag(out) = NA
  out = sum(out, na.rm = T)
  return(out)
}

其中vec是向量，例如vec = rnorm(10^4,0,1) 。

我想知道如何使用Rcpp包用C ++编写此函数。

Answer 1

这是一个更好，更直接的版本，在该版本中，C ++最终获得了一些收益：

// [[Rcpp::depends(RcppArmadillo)]]

#include <RcppArmadillo.h>

// [[Rcpp::export]]
double pij_cpp(const arma::vec & v) {
  arma::mat m = v * v.t();
  m.diag().zeros();
  double s = arma::as_scalar(arma::accu(m));
  return(s);
}

/*** R
library(rbenchmark)
set.seed(123)

pij <- function(vec){
  out <- vec %*% t(vec)
  diag(out) <- NA
  out <- sum(out, na.rm = T)
}

x <- rnorm(1000)

## make sure they are the same
all.equal(pij(x), pij_cpp(x))

## benchmark
benchmark(R=pij(x), Cpp=pij_cpp(x))
*/

在我的机器上，C ++处于领先地位：

R> sourceCpp("~/git/so-r/53105055/answer.cpp")

R> library(rbenchmark)

R> set.seed(123)

R> pij <- function(vec){
+   out <- vec %*% t(vec)
+   diag(out) <- NA
+   out <- sum(out, na.rm = T)
+ }

R> x <- rnorm(1000)

R> ## make sure they are the same
R> all.equal(pij(x), pij_cpp(x))
[1] TRUE

R> ## benchmark
R> benchmark(R=pij(x), Cpp=pij_cpp(x))
  test replications elapsed relative user.self sys.self user.child sys.child
2  Cpp          100   0.127    1.000     0.283    0.356          0         0
1    R          100   0.583    4.591     2.607    4.011          0         0
R>

更大的收获是...您看错了问题。 您的R函数已经高度矢量化，可以调出大部分已编译的代码，因此收获不多。

Answer 2

我建议先考虑问题背后的数学原理。 对于向量v您正在尝试计算

sum_{i=1}^{N-1} sum_{j=i+1}^{N} 2 * v_i * v_j

您可以通过先创建矩阵v_i * v_j来做到这v_i * v_j ，但是如果v很大，那可能会很昂贵。 因此，直接在C ++中更容易实现双重和：

#include <Rcpp.h>
// [[Rcpp::export]]
double pij_cpp(Rcpp::NumericVector vec) {
  double out{0.0};
  int N = vec.size();
  for (int i = 0; i < N; ++i) {
    for (int j = i + 1; j < N; ++j) {
      out += 2 * vec[i] * vec[j];
    }
  }
  return out;
}

但是，上面的公式实际上可以重新排列：

2 * sum_{i=1}^{N-1} v_i * sum_{j=i+1}^{N} v_j

从高端开始到低端，这使我们摆脱了双重循环：

#include <Rcpp.h>
// [[Rcpp::export]]
double pij_opt(Rcpp::NumericVector vec) {
  double out{0.0};
  double sum{0.0};
  int N = vec.size();
  for (int i = N -1; i > 0; --i) {
    sum += vec[i];
    out += sum * vec[i-1];
  }
  return 2 * out;
}

我们可以将这些版本与您的R代码以及基于Armadillo的版本进行比较，以获得长度为10^4的向量：

> bench::mark(pij(vec), pij_cpp(vec), pij_opt(vec), pij_arma(vec))
# A tibble: 4 x 14
  expression     min    mean  median     max `itr/sec` mem_alloc  n_gc n_itr total_time result
  <chr>      <bch:t> <bch:t> <bch:t> <bch:t>     <dbl> <bch:byt> <dbl> <int>   <bch:tm> <list>
1 pij(vec)   716.4ms 716.4ms 716.4ms 716.4ms      1.40    1.49GB     1     1      716ms <dbl …
2 pij_cpp(v…  59.9ms  61.4ms  61.5ms  62.3ms     16.3     2.49KB     0     9      552ms <dbl …
3 pij_opt(v…  14.2µs  15.6µs  14.9µs 864.5µs  64072.      2.49KB     0 10000      156ms <dbl …
4 pij_arma(… 834.5ms 834.5ms 834.5ms 834.5ms      1.20    2.49KB     0     1      834ms <dbl …
# ... with 3 more variables: memory <list>, time <list>, gc <list>

R和Armadillo差不多（可能受内存分配限制）。 第一个C ++版本的速度提高了10倍，第二个版本的速度提高了50000倍！

完整代码：

// [[Rcpp::depends(RcppArmadillo)]]
#include <RcppArmadillo.h>

// [[Rcpp::export]]
double pij_arma(arma::vec vec) {
  arma::mat out = vec * vec.t();
  out.diag().zeros();
  return arma::accu(out);
}

// [[Rcpp::export]]
double pij_cpp(Rcpp::NumericVector vec) {
  double out{0.0};
  int N = vec.size();
  for (int i = 0; i < N; ++i) {
    for (int j = i + 1; j < N; ++j) {
      out += 2 * vec[i] * vec[j];
    }
  }
  return out;
}

// [[Rcpp::export]]
double pij_opt(Rcpp::NumericVector vec) {
  double out{0.0};
  double sum{0.0};
  int N = vec.size();
  for (int i = N -1; i > 0; --i) {
    sum += vec[i];
    out += sum * vec[i-1];
  }
  return 2 * out;
}


/*** R
pij = function(vec){
  out = vec %*% t(vec)
  diag(out) = NA
  out = sum(out, na.rm = T)
  return(out)
}


set.seed(42)
vec = rnorm(10^4,0,1)
pij(vec)

bench::mark(pij(vec), pij_cpp(vec), pij_opt(vec), pij_arma(vec))
*/

为了完整pij_cpp ：这实际上是算法问题，因此即使R中的for循环也比pij_cpp更快：

pij_opt_r <- function(vec) {
  out <- 0
  sum <- 0
  N <- length(vec)
  for (i in seq.int(from = N, to = 2, by = -1)) {
    sum <- sum + vec[i]
    out <- out + sum * vec[i-1]
  }
  2 * out
}

在R中使用向量化函数甚至更快，但仍不及pij_opt ：

pij_opt_r2 <- function(vec) {
  N <- length(vec)
  vec <- rev(vec)
  sums <- cumsum(vec)
  2 * sum(vec[2:N] * sums[1:N-1])
}

完整基准：

> bench::mark(pij(vec), pij_cpp(vec), pij_opt(vec), pij_opt_r(vec), pij_opt_r2(vec), pij_arma(vec))
# A tibble: 6 x 14
  expression     min     mean   median     max `itr/sec` mem_alloc  n_gc n_itr total_time result
  <chr>      <bch:t> <bch:tm> <bch:tm> <bch:t>     <dbl> <bch:byt> <dbl> <int>   <bch:tm> <list>
1 pij(vec)   733.6ms  733.6ms  733.6ms 733.6ms      1.36    1.49GB     1     1      734ms <dbl …
2 pij_cpp(v…    60ms  61.41ms  60.84ms  64.2ms     16.3     2.49KB     0     9      553ms <dbl …
3 pij_opt(v…  14.2µs  15.83µs  15.35µs 750.1µs  63164.      2.49KB     0 10000      158ms <dbl …
4 pij_opt_r… 981.1µs   1.04ms   1.02ms   1.5ms    960.     119.2KB     0   480      500ms <dbl …
5 pij_opt_r…   157µs 272.95µs 241.57µs  66.3ms   3664.    547.28KB     1  1832      500ms <dbl …
6 pij_arma(… 878.4ms 878.38ms 878.38ms 878.4ms      1.14    2.49KB     0     1      878ms <dbl …
# ... with 3 more variables: memory <list>, time <list>, gc <list>

Answer 3

这是我发现的解决方案：

library(Rcpp)
library(inline)

rcpp_inc = "using namespace Rcpp;
using namespace arma;"

src = "
vec vec1 = as<vec>(vecin);
mat out = vec1*trans(vec1);
out.diag().zeros();

return(wrap(accu(out)));
"
pij_rcpp = cxxfunction(signature(vecin="numeric"), src, plugin='RcppArmadillo', rcpp_inc)

但是，它比用R编写的函数要慢。例如，如果我运行此示例，

set.seed(1)
x = runif(1e4)
system.time({pij_r(x)}) 
system.time({pij_rcpp(x)})

我得到的过去时间是pij_r为1.101和pij_r为pij_rcpp 。