Passer un vecteur ou une matrice de R à une fonction C en utilisant Rcpp sans copie locale ?

Question

Voici une illustration de ce que je fais actuellement avec deux fonctions.

Dans les deux cas, je crée une copie locale : soit une instance de std::vector<GLfloat> ou de std::vector<GLdouble> .

N'y a-t-il pas un raccourci n'impliquant pas de copies, où je pourrais passer de Rcpp::NumericMatrix a GLfloat * / GLdouble * d'une manière plus directe ?

#include <Rcpp.h>
#include <GLFW/glfw3.h>
using namespace Rcpp;

//' @export
// [[Rcpp::export("glLoadMatrixf")]]
void gl_load_matrixf(Rcpp::NumericMatrix m) {

  std::vector<GLfloat> float_v = Rcpp::as<std::vector<GLfloat> >(m);
  const GLfloat * _float_v = &float_v[0];

  glLoadMatrixf(_float_v);
}

//' @export
// [[Rcpp::export("glLoadMatrixd")]]
void gl_load_matrixd(Rcpp::NumericMatrix m) {

  std::vector<GLdouble> double_v = Rcpp::as<std::vector<GLdouble> >(m);
  const GLdouble * _double_v = &double_v[0];

  glLoadMatrixd(_double_v);
}

Answer 1

Sur mon système GLfloat y GLdouble sont définis comme suit :

typedef float GLfloat;
typedef double GLdouble;

Et le type de données numériques de R est toujours un double . Vous pouvez donc utiliser &m[0] o m.begin() directement pour obtenir quelque chose de convertible en un GLdouble * sans qu'il soit nécessaire de copier les données. Pour GLfloat ce n'est pas possible, puisqu'il faut un moulage (avec perte) pour passer de la version (64 bit) double utilisé par R à un (32 bit) float .

Un peu de code à titre d'illustration :

Sys.setenv(PKG_LIBS="-lGL -lglfw")

Rcpp::sourceCpp(code = '
#include <Rcpp.h>
#include <GLFW/glfw3.h>
using namespace Rcpp;

// [[Rcpp::export("glLoadMatrixd")]]
void gl_load_matrixd(Rcpp::NumericMatrix m) {

     const GLdouble * _double_v = &m[0];

     glLoadMatrixd(_double_v);
}
')

glLoadMatrixd(matrix(runif(10), 2, 5))

BTW, je n'ai aucune idée des dimensions qu'une telle matrice devrait avoir. 2x5 est probablement incorrect ...