Basis Splines¶
This chapter describes functions for the computation of smoothing basis splines (Bsplines). A smoothing spline differs from an interpolating spline in that the resulting curve is not required to pass through each datapoint. For information about interpolating splines, see Interpolation.
The header file gsl_bspline.h
contains the prototypes for the
bspline functions and related declarations.
Overview¶
Bsplines are commonly used as basis functions to fit smoothing curves to large data sets. To do this, the abscissa axis is broken up into some number of intervals, where the endpoints of each interval are called breakpoints. These breakpoints are then converted to knots by imposing various continuity and smoothness conditions at each interface. Given a nondecreasing knot vector
the basis splines of order are defined by
for . The common case of cubic Bsplines is given by . The above recurrence relation can be evaluated in a numerically stable way by the de Boor algorithm.
If we define appropriate knots on an interval then the Bspline basis functions form a complete set on that interval. Therefore we can expand a smoothing function as
given enough data pairs. The coefficients can be readily obtained from a leastsquares fit.
Initializing the Bsplines solver¶

type gsl_bspline_workspace¶
The computation of Bspline functions requires a preallocated workspace.

gsl_bspline_workspace *gsl_bspline_alloc(const size_t k, const size_t nbreak)¶
This function allocates a workspace for computing Bsplines of order
k
. The number of breakpoints is given bynbreak
. This leads to basis functions. Cubic Bsplines are specified by . The size of the workspace is .

void gsl_bspline_free(gsl_bspline_workspace *w)¶
This function frees the memory associated with the workspace
w
.
Constructing the knots vector¶

int gsl_bspline_knots(const gsl_vector *breakpts, gsl_bspline_workspace *w)¶
This function computes the knots associated with the given breakpoints and stores them internally in
w>knots
.

int gsl_bspline_knots_uniform(const double a, const double b, gsl_bspline_workspace *w)¶
This function assumes uniformly spaced breakpoints on and constructs the corresponding knot vector using the previously specified
nbreak
parameter. The knots are stored inw>knots
.
Evaluation of Bsplines¶

int gsl_bspline_eval(const double x, gsl_vector *B, gsl_bspline_workspace *w)¶
This function evaluates all Bspline basis functions at the position
x
and stores them in the vectorB
, so that the th element is . The vectorB
must be of length . This value may also be obtained by callinggsl_bspline_ncoeffs()
. Computing all the basis functions at once is more efficient than computing them individually, due to the nature of the defining recurrence relation.

int gsl_bspline_eval_nonzero(const double x, gsl_vector *Bk, size_t *istart, size_t *iend, gsl_bspline_workspace *w)¶
This function evaluates all potentially nonzero Bspline basis functions at the position
x
and stores them in the vectorBk
, so that the th element is . The last element ofBk
is . The vectorBk
must be of length . By returning only the nonzero basis functions, this function allows quantities involving linear combinations of the to be computed without unnecessary terms (such linear combinations occur, for example, when evaluating an interpolated function).

size_t gsl_bspline_ncoeffs(gsl_bspline_workspace *w)¶
This function returns the number of Bspline coefficients given by .
Evaluation of Bspline derivatives¶

int gsl_bspline_deriv_eval(const double x, const size_t nderiv, gsl_matrix *dB, gsl_bspline_workspace *w)¶
This function evaluates all Bspline basis function derivatives of orders through
nderiv
(inclusive) at the positionx
and stores them in the matrixdB
. The th element ofdB
is . The matrixdB
must be of size by . The value may also be obtained by callinggsl_bspline_ncoeffs()
. Note that function evaluations are included as the zeroth order derivatives indB
. Computing all the basis function derivatives at once is more efficient than computing them individually, due to the nature of the defining recurrence relation.

int gsl_bspline_deriv_eval_nonzero(const double x, const size_t nderiv, gsl_matrix *dB, size_t *istart, size_t *iend, gsl_bspline_workspace *w)¶
This function evaluates all potentially nonzero Bspline basis function derivatives of orders through
nderiv
(inclusive) at the positionx
and stores them in the matrixdB
. The th element ofdB
is . The last row ofdB
contains . The matrixdB
must be of size by at least . Note that function evaluations are included as the zeroth order derivatives indB
. By returning only the nonzero basis functions, this function allows quantities involving linear combinations of the and their derivatives to be computed without unnecessary terms.
Working with the Greville abscissae¶
The Greville abscissae are defined to be the mean location of
consecutive knots in the knot vector for each basis spline function of order
. With the first and last knots in the gsl_bspline_workspace
knot vector excluded, there are gsl_bspline_ncoeffs()
Greville abscissae
for any given Bspline basis. These values are often used in Bspline
collocation applications and may also be called MarsdenSchoenberg points.

double gsl_bspline_greville_abscissa(size_t i, gsl_bspline_workspace *w)¶
Returns the location of the th Greville abscissa for the given Bspline basis. For the illdefined case when , the implementation chooses to return breakpoint interval midpoints.
Examples¶
The following program computes a linear least squares fit to data using cubic Bspline basis functions with uniform breakpoints. The data is generated from the curve on the interval with Gaussian noise added.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gsl/gsl_bspline.h>
#include <gsl/gsl_multifit.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_statistics.h>
/* number of data points to fit */
#define N 200
/* number of fit coefficients */
#define NCOEFFS 12
/* nbreak = ncoeffs + 2  k = ncoeffs  2 since k = 4 */
#define NBREAK (NCOEFFS  2)
int
main (void)
{
const size_t n = N;
const size_t ncoeffs = NCOEFFS;
const size_t nbreak = NBREAK;
size_t i, j;
gsl_bspline_workspace *bw;
gsl_vector *B;
double dy;
gsl_rng *r;
gsl_vector *c, *w;
gsl_vector *x, *y;
gsl_matrix *X, *cov;
gsl_multifit_linear_workspace *mw;
double chisq, Rsq, dof, tss;
gsl_rng_env_setup();
r = gsl_rng_alloc(gsl_rng_default);
/* allocate a cubic bspline workspace (k = 4) */
bw = gsl_bspline_alloc(4, nbreak);
B = gsl_vector_alloc(ncoeffs);
x = gsl_vector_alloc(n);
y = gsl_vector_alloc(n);
X = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
w = gsl_vector_alloc(n);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
/* this is the data to be fitted */
for (i = 0; i < n; ++i)
{
double sigma;
double xi = (15.0 / (N  1)) * i;
double yi = cos(xi) * exp(0.1 * xi);
sigma = 0.1 * yi;
dy = gsl_ran_gaussian(r, sigma);
yi += dy;
gsl_vector_set(x, i, xi);
gsl_vector_set(y, i, yi);
gsl_vector_set(w, i, 1.0 / (sigma * sigma));
printf("%f %f\n", xi, yi);
}
/* use uniform breakpoints on [0, 15] */
gsl_bspline_knots_uniform(0.0, 15.0, bw);
/* construct the fit matrix X */
for (i = 0; i < n; ++i)
{
double xi = gsl_vector_get(x, i);
/* compute B_j(xi) for all j */
gsl_bspline_eval(xi, B, bw);
/* fill in row i of X */
for (j = 0; j < ncoeffs; ++j)
{
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(X, i, j, Bj);
}
}
/* do the fit */
gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw);
dof = n  ncoeffs;
tss = gsl_stats_wtss(w>data, 1, y>data, 1, y>size);
Rsq = 1.0  chisq / tss;
fprintf(stderr, "chisq/dof = %e, Rsq = %f\n",
chisq / dof, Rsq);
printf("\n\n");
/* output the smoothed curve */
{
double xi, yi, yerr;
for (xi = 0.0; xi < 15.0; xi += 0.1)
{
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
printf("%f %f\n", xi, yi);
}
}
gsl_rng_free(r);
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_vector_free(w);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
return 0;
} /* main() */
The output is shown below:
$ ./a.out > bspline.txt
chisq/dof = 1.118217e+00, Rsq = 0.989771
The data and fitted model are shown in Fig. 39.
References and Further Reading¶
Further information on the algorithms described in this section can be found in the following book,
C. de Boor, A Practical Guide to Splines (1978), SpringerVerlag, ISBN 0387903569.
Further information of Greville abscissae and Bspline collocation can be found in the following paper,
Richard W. Johnson, Higher order Bspline collocation at the Greville abscissae. Applied Numerical Mathematics. vol.: 52, 2005, 63–75.
A large collection of Bspline routines is available in the PPPACK library available at http://www.netlib.org/pppack, which is also part of SLATEC.