NAG FL Interface
g10abf (fit_​spline)

Settings help

FL Name Style:


FL Specification Language:


1 Purpose

g10abf fits a cubic smoothing spline for a given smoothing parameter.

2 Specification

Fortran Interface
Subroutine g10abf ( mode, weight, n, x, y, wt, rho, yhat, c, ldc, rss, df, res, h, comm, ifail)
Integer, Intent (In) :: n, ldc
Integer, Intent (Inout) :: ifail
Real (Kind=nag_wp), Intent (In) :: x(n), y(n), wt(*), rho
Real (Kind=nag_wp), Intent (Inout) :: c(ldc,3), comm(9*n+14)
Real (Kind=nag_wp), Intent (Out) :: yhat(n), rss, df, res(n), h(n)
Character (1), Intent (In) :: mode, weight
C Header Interface
#include <nag.h>
void  g10abf_ (const char *mode, const char *weight, const Integer *n, const double x[], const double y[], const double wt[], const double *rho, double yhat[], double c[], const Integer *ldc, double *rss, double *df, double res[], double h[], double comm[], Integer *ifail, const Charlen length_mode, const Charlen length_weight)
The routine may be called by the names g10abf or nagf_smooth_fit_spline.

3 Description

g10abf fits a cubic smoothing spline to a set of n observations (xi, yi), for i=1,2,,n. The spline provides a flexible smooth function for situations in which a simple polynomial or nonlinear regression model is unsuitable.
Cubic smoothing splines arise as the unique real-valued solution function f, with absolutely continuous first derivative and squared-integrable second derivative, which minimizes:
i=1nwi(yi-f(xi))2+ρ -(f(x))2dx,  
where wi is the (optional) weight for the ith observation and ρ is the smoothing parameter. This criterion consists of two parts: the first measures the fit of the curve, and the second the smoothness of the curve. The value of the smoothing parameter ρ weights these two aspects; larger values of ρ give a smoother fitted curve but, in general, a poorer fit. For details of how the cubic spline can be estimated see Hutchinson and de Hoog (1985) and Reinsch (1967).
The fitted values, y^ = (y^1,y^2,,y^n) T , and weighted residuals, ri, can be written as
y^=Hy  and  ri=wi(yi-y^i)  
for a matrix H. The residual degrees of freedom for the spline is trace(I-H) and the diagonal elements of H, hii, are the leverages.
The parameter ρ can be chosen in a number of ways. The fit can be inspected for a number of different values of ρ. Alternatively the degrees of freedom for the spline, which determines the value of ρ, can be specified, or the (generalized) cross-validation can be minimized to give ρ; see g10acf for further details.
g10abf requires the xi to be strictly increasing. If two or more observations have the same xi-value then they should be replaced by a single observation with yi equal to the (weighted) mean of the y values and weight, wi, equal to the sum of the weights. This operation can be performed by g10zaf.
The computation is split into three phases.
  1. (i)Compute matrices needed to fit spline.
  2. (ii)Fit spline for a given value of ρ.
  3. (iii)Compute spline coefficients.
When fitting the spline for several different values of ρ, phase (i) need only be carried out once and then phase (ii) repeated for different values of ρ. If the spline is being fitted as part of an iterative weighted least squares procedure phases (i) and (ii) have to be repeated for each set of weights. In either case, phase (iii) will often only have to be performed after the final fit has been computed.
The algorithm is based on Hutchinson (1986).

4 References

Hastie T J and Tibshirani R J (1990) Generalized Additive Models Chapman and Hall
Hutchinson M F (1986) Algorithm 642: A fast procedure for calculating minimum cross-validation cubic smoothing splines ACM Trans. Math. Software 12 150–153
Hutchinson M F and de Hoog F R (1985) Smoothing noisy data with spline functions Numer. Math. 47 99–106
Reinsch C H (1967) Smoothing by spline functions Numer. Math. 10 177–183

5 Arguments

1: mode Character(1) Input
On entry: indicates in which mode the routine is to be used.
mode='P'
Initialization and fitting is performed. This partial fit can be used in an iterative weighted least squares context where the weights are changing at each call to g10abf or when the coefficients are not required.
mode='Q'
Fitting only is performed. Initialization must have been performed previously by a call to g10abf with mode='P'. This quick fit may be called repeatedly with different values of rho without re-initialization.
mode='F'
Initialization and full fitting is performed and the function coefficients are calculated.
Constraint: mode='P', 'Q' or 'F'.
2: weight Character(1) Input
On entry: indicates whether user-defined weights are to be used.
weight='W'
User-defined weights should be supplied in wt.
weight='U'
The data is treated as unweighted.
Constraint: weight='W' or 'U'.
3: n Integer Input
On entry: n, the number of distinct observations.
Constraint: n3.
4: x(n) Real (Kind=nag_wp) array Input
On entry: the distinct and ordered values xi, for i=1,2,,n.
Constraint: x(i)<x(i+1), for i=1,2,,n-1.
5: y(n) Real (Kind=nag_wp) array Input
On entry: the values yi, for i=1,2,,n.
6: wt(*) Real (Kind=nag_wp) array Input
Note: the dimension of the array wt must be at least n if weight='W'.
On entry: if weight='W', wt must contain the n weights. Otherwise wt is not referenced and unit weights are assumed.
Constraint: if weight='W', wt(i)>0.0, for i=1,2,,n.
7: rho Real (Kind=nag_wp) Input
On entry: ρ, the smoothing parameter.
Constraint: rho0.0.
8: yhat(n) Real (Kind=nag_wp) array Output
On exit: the fitted values, y^i, for i=1,2,,n.
9: c(ldc,3) Real (Kind=nag_wp) array Input/Output
On entry: if mode='Q', c must be unaltered from the previous call to g10abf with mode='P'. Otherwise c need not be set.
On exit: if mode='F', c contains the spline coefficients. More precisely, the value of the spline at t is given by ((c(i,3)×d+c(i,2))×d+c(i,1)) × d + y^i , where xit<xi+1 and d=t-xi.
If mode='P' or 'Q', c contains information that will be used in a subsequent call to g10abf with mode='Q'.
10: ldc Integer Input
On entry: the first dimension of the array c as declared in the (sub)program from which g10abf is called.
Constraint: ldcn-1.
11: rss Real (Kind=nag_wp) Output
On exit: the (weighted) residual sum of squares.
12: df Real (Kind=nag_wp) Output
On exit: the residual degrees of freedom.
13: res(n) Real (Kind=nag_wp) array Output
On exit: the (weighted) residuals, ri, for i=1,2,,n.
14: h(n) Real (Kind=nag_wp) array Output
On exit: the leverages, hii, for i=1,2,,n.
15: comm(9×n+14) Real (Kind=nag_wp) array Communication Array
On entry: if mode='Q', comm must be unaltered from the previous call to g10abf with mode='P'. Otherwise comm need not be set.
On exit: if mode='P' or 'Q', comm contains information that will be used in a subsequent call to g10abf with mode='Q'.
16: ifail Integer Input/Output
On entry: ifail must be set to 0, −1 or 1 to set behaviour on detection of an error; these values have no effect when no error is detected.
A value of 0 causes the printing of an error message and program execution will be halted; otherwise program execution continues. A value of −1 means that an error message is printed while a value of 1 means that it is not.
If halting is not appropriate, the value −1 or 1 is recommended. If message printing is undesirable, then the value 1 is recommended. Otherwise, the value 0 is recommended. When the value -1 or 1 is used it is essential to test the value of ifail on exit.
On exit: ifail=0 unless the routine detects an error or a warning has been flagged (see Section 6).

6 Error Indicators and Warnings

If on entry ifail=0 or −1, explanatory error messages are output on the current error message unit (as defined by x04aaf).
Errors or warnings detected by the routine:
ifail=1
On entry, ldc=value and n=value.
Constraint: ldcn-1.
On entry, mode=value.
Constraint: mode='P', 'Q' or 'F'.
On entry, n=value.
Constraint: n3.
On entry, rho=value.
Constraint: rho0.0.
On entry, weight=value.
Constraint: weight='W' or 'U'.
ifail=2
On entry, at least one element of wt0.0.
ifail=3
On entry, x is not a strictly ordered array.
ifail=-99
An unexpected error has been triggered by this routine. Please contact NAG.
See Section 7 in the Introduction to the NAG Library FL Interface for further information.
ifail=-399
Your licence key may have expired or may not have been installed correctly.
See Section 8 in the Introduction to the NAG Library FL Interface for further information.
ifail=-999
Dynamic memory allocation failed.
See Section 9 in the Introduction to the NAG Library FL Interface for further information.

7 Accuracy

Accuracy depends on the value of ρ and the position of the x values. The values of xi-xi-1 and wi are scaled and ρ is transformed to avoid underflow and overflow problems.

8 Parallelism and Performance

Background information to multithreading can be found in the Multithreading documentation.
g10abf is not threaded in any implementation.

9 Further Comments

The time taken by g10abf is of order n.
Regression splines with a small (<n) number of knots can be fitted by e02baf and e02bef.

10 Example

The data, given by Hastie and Tibshirani (1990), is the age, xi, and C-peptide concentration (pmol/ml), yi, from a study of the factors affecting insulin-dependent diabetes mellitus in children. The data is input, reduced to a strictly ordered set by g10zaf and a series of splines fit using a range of values for the smoothing parameter, ρ.

10.1 Program Text

Program Text (g10abfe.f90)

10.2 Program Data

Program Data (g10abfe.d)

10.3 Program Results

Program Results (g10abfe.r)
GnuplotProduced by GNUPLOT 5.4 patchlevel 6 3 3.5 4 4.5 5 5.5 6 6.5 7 0 2 4 6 8 10 12 14 16 C-peptide concentration (pmol/ml) Age (years) raw data raw data r = 1 ρ = 1 r = 10 ρ = 10 r = 100 ρ = 100 Example Program Cubic Smoothing Spline Study of the factors affecting insulin-dependent diabetes mellitus in children Hastie and Tibshirani (1990)