如何避免在Rcpp函数中从R环境读取数据

Question

Even though MyCppFunction(NumericVector x) returns the desired output, I am not sure of a proper/efficient way to avoid reading the data on variable myY withou passing it as a function argument.

The reason I do not pass the data as an argument is that I will eventually pass the C++ function as an objective function to minimize and the minimization routine accepts a function of one argument only, namely myX . Just as an example: in R, I would pass myY to optim(...) in the following way : optim(par,fn=MyRFunction,y=myY) .

Any advice on how to properly access myY from within the C++ function is appreciated, here's a minimal example of what I am afraid is a really wrong way to do it:

Update : I've modified the code to better reflect the context as well as what has been proposed in the answers. Just in case, the focus of my question lies on this line : NumericVector y = env["myY"]; // How to avoid this? NumericVector y = env["myY"]; // How to avoid this?

#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::export]]
double MyCppFunction(NumericVector x) {

  Environment env = Environment::global_env();
  NumericVector y = env["myY"];  // How to avoid this?

  double res = 0;

  for (int i = 0; i < x.size(); i++) res = res + (x(i) * y(i));

  return res;
}

double MyCppFunctionNoExport(NumericVector x) {

  Environment env = Environment::global_env();
  NumericVector y = env["myY"];  // How to avoid this?

  double res = 0;

  for (int i = 0; i < x.size(); i++) res = res + (x(i) * y(i));

  return res;
}

// [[Rcpp::export]]
double MyCppFunction2(NumericVector x, NumericVector y) {
  double res = 0;

  for (int i = 0; i < x.size(); i++) res = res + (x(i) * y(i));

  return res;
}

// [[Rcpp::export]]
double MyRoutine(NumericVector x, Function fn) {

  for (int i = 0; i < x.size(); i++) fn(x);

  return 0;
}

// [[Rcpp::export]]
double MyRoutineNoExport(NumericVector x) {

  for (int i = 0; i < x.size(); i++) MyCppFunctionNoExport(x);

  return 0;
}

/*** R
MyRFunction <- function(x, y=myY) {
  res = 0
  for(i in 1:length(x)) res = res + (x[i]*y[i])
  return (res)
}

callMyCppFunction2 <- function(x) {
   MyCppFunction2(x, myY)
}

set.seed(123456)

myY = rnorm(1e3)
myX = rnorm(1e3)

all.equal(MyCppFunction(myX), MyRFunction(myX), callMyCppFunction2(myX))

require(rbenchmark)

benchmark(MyRoutine(myX, fn=MyCppFunction),
          MyRoutine(myX, fn=MyRFunction),
          MyRoutine(myX, fn=callMyCppFunction2),
          MyRoutineNoExport(myX), order="relative")[, 1:4]

*/

Output :

 $ Rscript -e 'Rcpp::sourceCpp("stack.cpp")' > MyRFunction <- function(x, y = myY) { + res = 0 + for (i in 1:length(x)) res = res + (x[i] * y[i]) + return(res) + } > callMyCppFunction2 <- function(x) { + MyCppFunction2(x, myY) + } > set.seed(123456) > myY = rnorm(1000) > myX = rnorm(1000) > all.equal(MyCppFunction(myX), MyRFunction(myX), callMyCppFunction2(myX)) [1] TRUE > require(rbenchmark) Loading required package: rbenchmark > benchmark(MyRoutine(myX, fn = MyCppFunction), MyRoutine(myX, + fn = MyRFunction), MyRoutine(myX, fn = callMyCppFunction2), + MyRoutineNoEx .... [TRUNCATED] test replications elapsed relative 4 MyRoutineNoExport(myX) 100 1.692 1.000 1 MyRoutine(myX, fn = MyCppFunction) 100 3.047 1.801 3 MyRoutine(myX, fn = callMyCppFunction2) 100 3.454 2.041 2 MyRoutine(myX, fn = MyRFunction) 100 8.277 4.892 

Answer 1

Use two parameters and wrap the C++ function in an R function.

#include <Rcpp.h>
using namespace Rcpp;
// [[Rcpp::export]]
double MyCppFunction(NumericVector x, NumericVector y) {
  return (sum(x) + sum(y));
}

R side:

callMyCFunc <- function(x) {
   MyCppFunction(x, myY)
}

Answer 2

optim does allow one to pass additional variables. Here we minimize f over x and pass in the additional variable a .

f <- function(x, a) sum((x - a)^2)
optim(1:2, f, a = 1)

giving:

$par
[1] 1.0000030 0.9999351

$value
[1] 4.22133e-09

$counts
function gradient 
      63       NA 

$convergence
[1] 0

$message
NULL

Answer 3

Another solution. Set global in C space:

#include <Rcpp.h>
using namespace Rcpp;

static NumericVector yglobal;

// [[Rcpp::export]]
void set_Y(NumericVector y) {
  yglobal = y;
}

// [[Rcpp::export]]
double MyCppFunction(NumericVector x) {
  double res = 0;
  for (int i = 0; i < x.size(); i++) res = res + (x(i) * yglobal(i));
  return res;
}

R side:

set.seed(123456)

myY = rnorm(1000)
set_Y(myY);
myX = rnorm(1000)

MyCppFunction(myX)

(Note: the purpose of static is to limit the scope of the variable to your particular script)