The R package **splines2** provides functions to construct basis matrix of

- B-splines
- M-splines
- I-splines
- convex splines (C-splines)
- generalized Bernstein polynomials
- their integrals (except C-splines) and derivatives of given order by close-form recursive formulas

In addition to the R interface, **splines2** also provides a C++ header-only library integrated with **Rcpp**, which allows construction of spline basis matrix directly in C++ with the help of **Rcpp** and **RcppArmadillo**. So it can also be treated as one of the **Rcpp*** packages. A toy example package that uses the C++ interface is available here.

You can install the released version from CRAN.

The latest version of package is under development at GitHub. If it is able to pass the building check by Travis CI, one may install it by

Online document provides reference for all functions and contains the following vignettes:

Since v0.3.0, the implementation of the main functions has been rewritten in C++ with the help of the **Rcpp** and **RcppArmadillo** package. The computational performance has thus been boosted.

Some benchmarks with the **splines** package (version 4.0.1) are provided for reference as follows:

```
library(microbenchmark)
library(splines)
library(splines2)
x <- seq.int(0, 1, 0.001)
degree <- 3
ord <- degree + 1
knots <- seq.int(0.1, 0.9, 0.1)
b_knots <- range(x)
all_knots <- sort(c(knots, rep(b_knots, ord)))
## check equivalency of outputs
my_check <- function(values) {
all(sapply(values[- 1], function(x) {
all.equal(unclass(values[[1]]), x, check.attributes = FALSE)
}))
}
```

For B-splines, function `splines2::bSpline()`

provides equivalent results with `splines::bs()`

and `splines::splineDesign()`

, and is about 3x faster than `bs()`

and 2x faster than `splineDesign()`

.

```
## B-splines
microbenchmark(
"splines::bs" = bs(x, knots = knots, degree = degree,
intercept = TRUE, Boundary.knots = b_knots),
"splines::splineDesign" = splineDesign(x, knots = all_knots, ord = ord),
"splines2::bSpline" = bSpline(x, knots = knots, degree = degree,
intercept = TRUE, Boundary.knots = b_knots),
check = my_check,
times = 1e3
)
```

```
Unit: microseconds
expr min lq mean median uq max neval cld
splines::bs 335.703 353.810 387.53 362.81 381.259 3015.9 1000 c
splines::splineDesign 204.151 213.133 244.16 216.05 226.820 2342.8 1000 b
splines2::bSpline 84.866 91.677 108.45 95.46 99.399 2149.9 1000 a
```

Similarly, for derivatives of B-splines, `splines2::dbs()`

provides equivalent results with `splines::splineDesign()`

, and is more than 2x faster.

```
## Derivatives of B-splines
derivs <- 2
microbenchmark(
"splines::splineDesign" = splineDesign(x, knots = all_knots,
ord = ord, derivs = derivs),
"splines2::dbs" = dbs(x, derivs = derivs, knots = knots, degree = degree,
intercept = TRUE, Boundary.knots = b_knots),
check = my_check,
times = 1e3
)
```

```
Unit: microseconds
expr min lq mean median uq max neval cld
splines::splineDesign 274.066 285.540 330.04 295.3 327.12 4143.4 1000 b
splines2::dbs 88.085 94.344 127.73 99.0 107.18 2639.1 1000 a
```

The **splines** package does not provide function producing integrals of B-splines. So we instead performed a comparison with package **ibs** (version 1.4), where the function `ibs::ibs()`

was also implemented in **Rcpp**.

```
## integrals of B-splines
set.seed(123)
coef_sp <- rnorm(length(all_knots) - ord)
microbenchmark(
"ibs::ibs" = ibs::ibs(x, knots = all_knots, ord = ord, coef = coef_sp),
"splines2::ibs" = as.numeric(
splines2::ibs(x, knots = knots, degree = degree,
intercept = TRUE, Boundary.knots = b_knots) %*% coef_sp
),
check = my_check,
times = 1e3
)
```

```
Unit: microseconds
expr min lq mean median uq max neval cld
ibs::ibs 2445.25 2666.93 3259.59 3213.59 3342.26 113446.1 1000 b
splines2::ibs 264.84 319.18 363.78 338.62 360.94 2826.4 1000 a
```

The function `ibs::ibs()`

returns the integrated B-splines instead of the integrals of spline bases. So we applied the same coefficients to the bases from `splines2::ibs()`

for equivalent results, which was still much faster than `ibs::ibs()`

.