In data science we often face a tradeoff between run time and development time when it comes to our choice of language. Languages like R and Python are common because they are easy to write, even if the language runtime is slow.

In some cases, writing R is only slightly more verbose than the comparable statement in English. For example, suppose we wanted to take some data, filter to where x is greater than 2, and find the mean of column y. We could write this in R as follows:

```
library(tidyverse)
data |>
dplyr::filter(x > 2) |>
dplyr::reframe(
new_col = mean(y)
)
```

This brutal simplicity comes at at the expense of *speed* in some cases. Often times we prefer ease of use to speed, but what if speed is critical! We might need to use a language like C++ or Rust but this comes with added complexity – how do we use C++ in components of our workflow and R in others? How is data transfer handled between these environments? How do I compile code effectively?

Enter `Rcpp`

, a fantastic tool which strips away almost all of the barriers to entry with C++ when coming from R. This R package allows users to write C++ functions which accept R objects to be processed in C++ and returned in R. It handles all of the complexities of data transfer and object serialization.

Lets take an example in R. Suppose we wanted to compute the mean *across* several columns. In other words, what is the mean of the ith element of a collection of column vectors? The tidyverse includes a function called `dplyr::rowwise()`

specifically designed for this purpose. While exceptionally general, it is painfully slow. Lets write a C++ function to help us out.

The snippet below is the contents of a file called `functions.cpp`

, a C++ file which contains a function called `row_means_cpp()`

. This function accepts a 2D matrix and returns a column vector.

It iterates over each row finding the mean across all columns in this dataset. We begin by determining the shape of the matrix, looping over the rows and columns while computing the means along the way, and returning the vector.

```
#include <Rcpp.h>
using namespace Rcpp;
// [[Rcpp::export]]
NumericVector row_means_cpp(NumericMatrix X) {
int row = X.nrow();
int col = X.ncol();
NumericVector result(row);
for (int i = 0; i < row; i++) {
double mean = 0;
for (int j = 0; j < col; j++) {
mean += X(i, j);
}
result[i] = mean / col;
}
return result;
}
```

Now lets see how this compares to the `dplyr`

function in R! We can use the `bench`

package to profile R expressions. I have also designed a *wrapper* R function around our C++ function to make workflows with data frames a little easier called `row_means()`

.

```
library(Rcpp)
library(bench)
library(ggplot2)
Rcpp::sourceCpp("functions.cpp")
row_means <- function(...) {
list(...) |>
as.data.frame() |>
as.matrix() |>
row_means_cpp()
}
bench::mark(
Rowwise = {
diamonds |>
dplyr::rowwise() |>
dplyr::mutate(
means = mean(c(carat, depth, table, price, x, y, z))
)
},
Cpp = {
diamonds |>
dplyr::mutate(
means = row_means(carat, depth, table, price, x, y, z)
)
},
check = FALSE
) |>
dplyr::select(
expression,
median,
mem_alloc
) |>
print()
# A tibble: 2 × 3
expression median mem_alloc
<bch:expr> <bch:tm> <bch:byt>
1 Rowwise 651.25ms 28.08MB
2 Cpp 2.37ms 3.44MB
```

We compute the row-wise mean of seven columns. Specifically, the means of carat, depth, table, price, x, y, and z. We can see in the tibble output above that the `dplyr`

version is approximately 300 times slower and 8 times less memory efficient than our C++ function!

While the C++ function is markedly less general, for specific workflows it might represent a meaningful improvement in speed and performance. This makes Rcpp an excellent candidate for tinkering with machine learning models from scratch in R! You can implement machine learning models with fast procedural C++ code with the ease of scripting in R – a fantastic duo!