Ggtcf

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?

#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

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)

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)

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