RcppGSL provides an interface from R to the vector and matrix classes of the GNU GSL, a collection of numerical routines for scientifc computing.

It is particularly useful for C and C++ programs as it provides a standard C interface to a wide range of mathematical routines such as special functions, permutations, combinations, fast fourier transforms, eigensystems, random numbers, quadrature, random distributions, quasi-random sequences, Monte Carlo integration, N-tuples, differential equations, simulated annealing, numerical differentiation, interpolation, series acceleration, Chebyshev approximations, root-finding, discrete Hankel transforms physical constants, basis splines and wavelets. There are over 1000 functions in total with an extensive test suite.

The RcppGSL package provides an easy-to-use interface between GSL data structures and GNU R using concepts from Rcpp which is itself a package that eases the interfaces between R and C++.

The RcppGSL package does a few things, in particular for vectors and matrices:

- templated vector and matrix classes: these are similar to Rcpp's own vector and matrix classes, but really are just smart pointers around the C structure expected by the library
- this means you can transfer data from R to your GSL-using programs in pretty much the same way you would in other C++ programs using Rcpp---by relying on the
`Rcpp::as()`

and`Rcpp::wrap()`

converterrs which are most often invoked automatically for you anyway - at the C++ level you can use these GSL vectors in a more C++-alike way (using eg
`foo[i]`

to access an element at index i) - yet at the same time you can just pass these vector and matrix objects to the GSL functions expecting its C objects: thanks to some cleverness in these classes they pass the right object on (see the example below)
- we also provide the lightweight
*views*for vectors and matrices as the GSL API uses these in many places.

In sum, these features aim to make it a lot easier to use functionality from the (excellent) GNU GSL in a way that is more natural to a user of C++ and R (and of course Rcpp) The package vignette. has a more details.

Here is a simple implementation of a column norm (which we could easily compute directly in R, but we are simply re-using an example from Section 8.4.14 of the GSL manual).

```
#include <RcppGSL.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_blas.h>
// [[Rcpp::export]]
Rcpp::NumericVector colNorm(const RcppGSL::Matrix & G) {
int k = G.ncol();
Rcpp::NumericVector n(k); // to store results
for (int j = 0; j < k; j++) {
RcppGSL::VectorView colview = gsl_matrix_const_column (G, j);
n[j] = gsl_blas_dnrm2(colview);
}
return n; // return vector
}
```

This example shows how a `RcppGSL::Matrix`

object (a `typedef`

shortcut to the templated `double`

representation) gets passed down from R; we can use standard `const &`

interface as well. Inside the function we then read the number of columns from a member function `ncol()`

(using the same name as in R). We assign a standard Rcpp vector of the corresponding size `k`

to hold the result which is returned to R.

To compute the column norms, we loop over all columns. The norm is computed after we extract a column as a *const view* (see the GSL manual for details: this is essentially a lightweight slice referring back to the original object). This column can be passed directly to a GSL function expecting a vector -- very nice. The actual computation is done by a standard GSL function, here `gsl_blas_dnrm2`

, which expects a standard GSL vector -- which our classes transparently provide in this context.

Previous versions then had to free the memory of the matrix object; this is now done automagically. By using Rcpp Attributes, all this is wrapped in a `try/catch`

block as is standard with Rcpp.

Another example function for a faster compiled implementation of `lm()`

using the model fitting code in the GSL is also included in the package.

RcppGSL is a CRAN package, lives otherwise in its own habitat at GitHub and can also be downloaded from the local Rcpp archive which also has a copy of the vignette describing the package.

RcppGSL is being written by Dirk Eddelbuettel and Romain Francois using Rcpp.

RcppGSL is licensed under the GNU GPL version 2 or later.