The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.

Rcpp interoperability with std::array (et al.)

Rcpp is a mature and very widely used package providing seamless interoperability between C++ and the R language, which has a native C API. This package facilitates conversion between R data structures and the templated std::array class introduced in C++11, by using the interface provided in Rcpp. It originated with this Stack Overflow question.

Support for std::tuple was added in package version 0.3.0. This data structure, also introduced in C++11, combines a fixed set of elements of potentially different types.

std::array is a templated container type with a fixed number of elements, an object-orientated analogue of a C-style array type like int[3]. Client packages can interface this type with R if they add RcppArray to LinkingTo and include the header. (A simple example package is provided.)

// No need to include "Rcpp.h" as well
#include "RcppArray.h"

// [[Rcpp::export]]
RObject test() {
  Rcpp::NumericVector vec = Rcpp::NumericVector::create(1,2,3);
  std::array<double,3> arr = Rcpp::as<std::array<double,3>>(vec);
  // Do something with the array
  
  std::array<unsigned int,3> result = { 1, 2, 3 };
  return result;    // Implicitly Rcpp::wrap(result)
}

In either direction the element type of the array can be any atomic type that Rcpp knows how to convert, and isn’t limited to the types that R uses internally. In the example above, unsigned int is used even though it doesn’t directly correspond to an R vector mode: the wrap() function will convert it to an R numeric vector, i.e., double.

A tuple, declared in C++ via a variadic template, as in std::tuple<int, double, std::string>, can be converted similarly using Rcpp::as() and Rcpp::wrap(). In this case the R analogue is a list rather than an atomic vector, since the element types can vary.

std::span

There is also experimental support for std::span, introduced in C++20. This is a typed container of fixed or dynamic length which provides a “view” onto a contiguous block of data owned by another object. Once again, there is a simple example client package showing usage of this facility.

In this case there are some notable caveats. Client packages must obviously request C++20 support, and a configure script may well be needed to check for span availability. Moreover, since a span does not own the memory it points to, as<span<T,D>>() will only compile where the requested type T matches a type that R uses internally (viz. int, double, etc.). The latter limitation does not apply to wrap, however, because a new vector is created and the data converted.

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.