naginterfaces.library.fit.dim1_​spline_​auto

naginterfaces.library.fit.dim1_spline_auto(start, x, y, w, s, n, lamda, comm)

dim1_spline_auto computes a cubic spline approximation to an arbitrary set of data points. The knots of the spline are located automatically, but a single argument must be specified to control the trade-off between closeness of fit and smoothness of fit.

For full information please refer to the NAG Library document for e02be

https://support.nag.com/numeric/nl/nagdoc_30.3/flhtml/e02/e02bef.html

Parameters

startstr, length 1

Must be set to ‘C’ or ‘W’.

$start=\text{'C'}$

The function will build up the knot set starting with no interior knots. No values need be assigned to the arguments $n$, $lamda$, $comm$[‘wrk’] or $comm$[‘iwrk’].

$start=\text{'W'}$

The function will restart the knot-placing strategy using the knots found in a previous call of the function. In this case, the arguments $n$, $lamda$, $comm$[‘wrk’], and $comm$[‘iwrk’] must be unchanged from that previous call. This warm start can save much time in searching for a satisfactory value of $s$.

xfloat, array-like, shape $\left(m\right)$

The values $x_{\text{r}}$ of the independent variable (abscissa) $x$, for $\text{r}=1,2,\dots ,m$.

yfloat, array-like, shape $\left(m\right)$

The values $y_{\text{r}}$ of the dependent variable (ordinate) $y$, for $\text{r}=1,2,\dots ,m$.

wfloat, array-like, shape $\left(m\right)$

The values $w_{\text{r}}$ of the weights, for $\text{r}=1,2,\dots ,m$. For advice on the choice of weights, see the E02 Introduction.

sfloat

The smoothing factor, $S$.

If $S=0.0$, the function returns an interpolating spline.

If $S$ is smaller than machine precision, it is assumed equal to zero.

For advice on the choice of $S$, see Notes and Further Comments.

nint

If the warm start option is used, the value of $n$ must be left unchanged from the previous call.

lamdafloat, array-like, shape $\left(\text{nest}\right)$

If the warm start option is used, the values $lamda\left[0\right],lamda\left[1\right],\dots ,lamda[n-1]$ must be left unchanged from the previous call.

commdict, communication object, modified in place

Communication structure.

On initial entry: need not be set.

Returns

nint

The total number, $n$, of knots of the computed spline.

lamdafloat, ndarray, shape $\left(\text{nest}\right)$

The knots of the spline, i.e., the positions of the interior knots $lamda\left[4\right],lamda\left[5\right],\dots ,lamda[n-5]$ as well as the positions of the additional knots

$$lamda\left[0\right]=lamda\left[1\right]=lamda\left[2\right]=lamda\left[3\right]=x_1$$

and

$$lamda[n-4]=lamda[n-3]=lamda[n-2]=lamda[n-1]=x_m$$

needed for the B-spline representation.

cfloat, ndarray, shape $\left(\text{nest}\right)$

The coefficient $c_{\text{i}}$ of the B-spline $N_{\text{i}}\left(x\right)$ in the spline approximation $s\left(x\right)$, for $\text{i}=1,2,\dots ,n-4$.

fpfloat

The sum of the squared weighted residuals, $\theta$, of the computed spline approximation. If $fp=0.0$, this is an interpolating spline. $fp$ should equal $s$ within a relative tolerance of $0.001$ unless $n=8$ when the spline has no interior knots and so is simply a cubic polynomial. For knots to be inserted, $s$ must be set to a value below the value of $fp$ produced in this case.

Raises

NagValueError

(errno $1$)

On entry, $r=⟨value⟩$ and $w[r-1]=⟨value⟩$.

Constraint: $w[r-1]>0.0$ for all $r$.

(errno $1$)

On entry, $\text{nest}=⟨value⟩$.

Constraint: $\text{nest}\ge 8$.

(errno $1$)

On entry, $\text{nest}=⟨value⟩$.

Constraint: $\text{nest}\ge ⟨value⟩$ when $s=0.0$.

(errno $1$)

On entry, $s=⟨value⟩$.

Constraint: $s\ge 0.0$.

(errno $1$)

On entry, $m=⟨value⟩$.

Constraint: $m\ge 4$.

(errno $1$)

On entry, $start\ne \text{'W'}$ or $\text{'C'}$: $start=⟨value⟩$.

(errno $2$)

On entry, $r=⟨value⟩$ and $w[r-1]=⟨value⟩$.

Constraint: $w[r-1]>0.0$ for all $r$.

(errno $3$)

On entry, $r=⟨value⟩$, $x[r-2]=⟨value⟩$ and $x[r-1]=⟨value⟩$.

Constraint: $x[r-2]<x[r-1]$ for all $r$.

(errno $4$)

The number of knots needed is greater than $\text{nest}$: $\text{nest}=⟨value⟩$. Possibly $s$ is too small: $s=⟨value⟩$.

(errno $5$)

The iterative process has failed to converge. Possibly $s$ is too small: $s=⟨value⟩$.

Notes

In the NAG Library the traditional C interface for this routine uses a different algorithmic base. Please contact NAG if you have any questions about compatibility.

dim1_spline_auto determines a smooth cubic spline approximation $s\left(x\right)$ to the set of data points $(x_{\text{r}},y_{\text{r}})$, with weights $w_{\text{r}}$, for $\text{r}=1,2,\dots ,m$.

The spline is given in the B-spline representation

$$s\left(x\right)=\sum _{i=1}^{n-4}{c}_i{N}_i\left(x\right)\text{,}$$

where $N_i\left(x\right)$ denotes the normalized cubic B-spline defined upon the knots ${\lambda }_i,{\lambda }_{i+1},\dots ,{\lambda }_{i+4}$.

The total number $n$ of these knots and their values ${\lambda }_1,\dots ,{\lambda }_n$ are chosen automatically by the function. The knots ${\lambda }_5,\dots ,{\lambda }_{n-4}$ are the interior knots; they divide the approximation interval $[x_1,x_m]$ into $n-7$ sub-intervals. The coefficients $c_1,c_2,\dots ,c_{n-4}$ are then determined as the solution of the following constrained minimization problem:

minimize

$$\eta =\sum _{i=5}^{n-4}{\delta }_i^2$$

subject to the constraint

$$\theta =\sum _{r=1}^m{ϵ}_r^2\le S\text{,}$$

where	${\delta }_i$	stands for the discontinuity jump in the third order derivative of $s\left(x\right)$ at the interior knot ${\lambda }_i$,
	${ϵ}_r$	denotes the weighted residual $w_r(y_r-s\left(x_r\right))$,
and	$S$	is a non-negative number to be specified by you.

The quantity $\eta$ can be seen as a measure of the (lack of) smoothness of $s\left(x\right)$, while closeness of fit is measured through $\theta$. By means of the argument $S$, ‘the smoothing factor’, you can then control the balance between these two (usually conflicting) properties. If $S$ is too large, the spline will be too smooth and signal will be lost (underfit); if $S$ is too small, the spline will pick up too much noise (overfit). In the extreme cases the function will return an interpolating spline $(\theta =0)$ if $S$ is set to zero, and the weighted least squares cubic polynomial $(\eta =0)$ if $S$ is set very large. Experimenting with $S$ values between these two extremes should result in a good compromise. (See Choice of S for advice on choice of $S$.)

The method employed is outlined in Outline of Method Used and fully described in Dierckx (1975), Dierckx (1981) and Dierckx (1982). It involves an adaptive strategy for locating the knots of the cubic spline (depending on the function underlying the data and on the value of $S$), and an iterative method for solving the constrained minimization problem once the knots have been determined.

Values of the computed spline, or of its derivatives or definite integral, can subsequently be computed by calling dim1_spline_eval(), dim1_spline_deriv() or dim1_spline_integ(), as described in Evaluation of Computed Spline.

References

Dierckx, P, 1975, An algorithm for smoothing, differentiating and integration of experimental data using spline functions, J. Comput. Appl. Math. (1), 165–184

Dierckx, P, 1981, An improved algorithm for curve fitting with spline functions, Report TW54, Department of Computer Science, Katholieke Univerciteit Leuven

Dierckx, P, 1982, A fast algorithm for smoothing data on a rectangular grid while using spline functions, SIAM J. Numer. Anal. (19), 1286–1304

Reinsch, C H, 1967, Smoothing by spline functions, Numer. Math. (10), 177–183