Best way to use c++ code from R package FOO in package BAR

Question

I am trying to define a function using Rcpp for speedup. The situation is as follows:

I have a package FOO with a lot of C++ code (my own package and currently not using Rcpp) which have defined a set of functions e.g. foo_a and foo_b.
In another package BAR (using Rcpp) I am defining a function (using Rcpp Attributes) where I want to call functions foo_a and foo_b.

How do I solve this? Looking a bit in other posts I get that I have in some way to include header files in FOO and use attribute // [[Rcpp::depends(FOO)]] in BAR, but I seem to miss some points. Any hints on how to do it?

Best Lars

EDIT: Thanks for the comments I liked Kevin Usheys approach and tried to implement it. However, after some coding I realized that I actually don't need functions from FOO but a class and its public functions. I guess that I cannot do the tricks you suggested for a class. I ended up putting the source files of the class from FOO in the BAR src dir (not the best approach since I now have 2 versions of the same code). However for the moment this hack work for me.

Put them into inst/include of package FOO (and set -I../inst/include in src/Makevars; have package BAR use RcppDepends(FOO) -- one copy only, two packages using it. See what I wrote about RcppXts. — Dirk Eddelbuettel, Jan 08 '14 at 22:10
Thanks Dirk. I will have a look at RcppXts. I did't think that it was possible for a class too. — Relund, Jan 09 '14 at 08:14

Romain Francois · Answer 1 · 2014-01-09T00:42:17.323

I would recommend one of these options:

If foo_a and foo_b are simple enough, just have them as inline functions in headers of FOO and put these headers in FOO/inst/include/FOO.h. Rcpp::depends(FOO) will then include this file when you invoke compileAttributes (or perhaps load_all) on BAR.

Otherwise, consider registering the functions using R's registration model. this is a bit more work, but that's bearable. Writing R extensions has the details. I would suggest putting all the registration logic in FOO so that the client package BAR only has to use it. For example, I'd have foo_a like this in FOO's headers, e.g. in FOO/inst/include/FOO.h:

#ifdef COMPILING_FOO
inline int foo_a(int x, double y, const std::string& z){
    typedef int (*Fun)(int, double, const std::string&) ;
    static Fun fun = (Fun)R_GetCCallable( "FOO", "foo_a" ) ;
    return fun(x,y,z) ;
}
#else 
// just declare it
int foo_a(int x, double y, const std::string& z) ;
#endif

and the actual definition of foo_a in some .cpp file in FOO/src:

#define COMPILING_FOO
#include <FOO.h>

int foo_a(int x, double y, const std::string& z){
   // do stuff
}

Then, you need to register foo_a using R_RegisterCCallable in the function R_init_FOO:

extern "C" void R_init_FOO( DllInfo* info ){
    R_RegisterCCallable( "FOO", "foo_a", (DL_FUNC)foo_a );
}

Of course it is R_init_FOO. I guess you can figure where I got the example from. — Romain Francois, Jan 09 '14 at 00:41

score 4 · Accepted Answer · answered Jan 08 '14 at 01:59

Another option, in case you don't mind introducing Rcpp into package FOO - follow along with Section 3.5 of Rcpp-attributes and do the following:

Place // [[Rcpp::interfaces(cpp)]] at the top of the .cpp source files containing functions you'd like to be made available to other packages,
Place // [[Rcpp::export]] in front of those functions you would like exported,
Call compileAttributes() in the package directory of FOO to generate files in inst/include that can then be used by package BAR, using // [[Rcpp::depends(FOO)]],
Install package FOO.

If you have this set up correctly, you should be able to call a function with a template like this (supposing foo_a is an exported function from FOO):

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

#include <Rcpp.h>
#include <FOO.h>
using namespace Rcpp;

// [[Rcpp::export]]
SEXP some_function() {
  return FOO::foo_a();
}

That is actually the same as the other two answers, but gets it done for you more easily :) — Dirk Eddelbuettel, Jan 08 '14 at 02:27

Dirk Eddelbuettel · Answer 3 · 2014-01-08T15:58:42.270

2

The RcppXts package does just that for a bunch of functions from the well-known xts package.

Edit: Here is some code from xts.

First, xts::src/init.c does the registration via a dozen or so declarations like

R_RegisterCCallable("xts","do_is_ordered",(DL_FUNC) &do_is_ordered);

Second, xts::inst/include/xtsApi.h provides a header for client packages with eg

SEXP attribute_hidden xtsIsOrdered(SEXP x, SEXP increasing, SEXP strictly) {
    static SEXP(*fun)(SEXP,SEXP,SEXP) = NULL;
    fun = (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable("xts","do_is_ordered");
    return fun(x, increasing, strictly);
}

Third, in a client package such as RcppXts we define this (using Rcpp Modules) as

function("xtsIsOrdered",
         &xtsIsOrdered,
         List::create(Named("x"),
                      Named("increasing") = true,
                      Named("strictly") = true),
         "Tests whether object is (strictly) (increasing) ordered");

which exposes it to R. We could equally well call the C function xtsIsOrdered from C++ code.

I removed the incorrect earlier comment that functions have to conform to 'SEXP in, SEXP out'.

edited Jan 08 '14 at 15:58

answered Jan 07 '14 at 21:55

Dirk Eddelbuettel

360,940
56
644
725

"Because everything 'happens through R', the functions have to conform to the 'SEXP foo(SEXP a, SEXP b, ...) scheme" No they don't. – Romain Francois Jan 07 '14 at 22:01
Even better. Is there a worked example somewhere where this scheme is used to exchange C++ objects? The base example of lme4 and Matrix does not IIRC. – Dirk Eddelbuettel Jan 07 '14 at 22:05
Rcpp is an obvious example. – Romain Francois Jan 07 '14 at 22:09
Good point: Rcpp_init.cpp does R_RegisterCCallable, register.h does other side of R_GetCCallable. – Dirk Eddelbuettel Jan 07 '14 at 22:26

Best way to use c++ code from R package FOO in package BAR

3 Answers3

Linked