The method employed is that of evaluation by taking convex combinations due to de Boor (1972). For further details of the algorithm and its use see Cox (1972) and Cox and Hayes (1973).

It is expected that a common use of nag_fit_1dspline_eval (e02bb) will be the evaluation of the cubic spline approximations produced by nag_fit_1dspline_knots (e02ba). A generalization of nag_fit_1dspline_eval (e02bb) which also forms the derivative of

s (x)

is nag_fit_1dspline_deriv (e02bc). nag_fit_1dspline_deriv (e02bc) takes about

50 %

longer than nag_fit_1dspline_eval (e02bb).

References

Cox M G (1972) The numerical evaluation of B-splines J. Inst. Math. Appl. 10 134–149

Cox M G (1978) The numerical evaluation of a spline from its B-spline representation J. Inst. Math. Appl. 21 135–143

Cox M G and Hayes J G (1973) Curve fitting: a guide and suite of algorithms for the non-specialist user NPL Report NAC26 National Physical Laboratory

de Boor C (1972) On calculating with B-splines J. Approx. Theory 6 50–62

Parameters

Compulsory Input Parameters

1: $lamda (ncap7)$ – double array: $lamda (j)$ must be set to the value of the $j$ th member of the complete set of knots, $λ_{j}$ , for $j = 1, 2, \dots, \bar{n} + 7$ .

Constraint: the $lamda (j)$ must be in nondecreasing order with $lamda (ncap7 - 3) > lamda (4)$ .
2: $c (ncap7)$ – double array: The coefficient $c_{i}$ of the B-spline $N_{i} (x)$ , for $i = 1, 2, \dots, \bar{n} + 3$ . The remaining elements of the array are not referenced.
3: $x$ – double scalar: The argument $x$ at which the cubic spline is to be evaluated.

Constraint: $lamda (4) \leq x \leq lamda (ncap7 - 3)$ .

Optional Input Parameters

1: $ncap7$ – int64int32nag_int scalar: Default: the dimension of the arrays lamda, c. (An error is raised if these dimensions are not equal.)
$\bar{n} + 7$ , where $\bar{n}$ is the number of intervals (one greater than the number of interior knots, i.e., the knots strictly within the range $λ_{4}$ to $λ_{\bar{n} + 4}$ ) over which the spline is defined.

Constraint: $ncap7 \geq 8$ .

Output Parameters

1: $s$ – double scalar: The value of the spline, $s (x)$ .
2: $ifail$ – int64int32nag_int scalar: $ifail = 0$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Errors or warnings detected by the function:

$ifail = 1$: The argument x does not satisfy $lamda (4) \leq x \leq lamda (ncap7 - 3)$ .

In this case the value of s is set arbitrarily to zero.

$ifail = 2$: $ncap7 < 8$ , i.e., the number of interior knots is negative.

$ifail = - 99$: An unexpected error has been triggered by this routine. Please contact NAG.

$ifail = - 399$: Your licence key may have expired or may not have been installed correctly.

$ifail = - 999$: Dynamic memory allocation failed.

Accuracy

The computed value of

s (x)

has negligible error in most practical situations. Specifically, this value has an absolute error bounded in modulus by

18 \times c_{\max} \times machine precision

, where

c_{\max}

is the largest in modulus of

c_{j}, c_{j + 1}, c_{j + 2}

and

c_{j + 3}

, and

j

is an integer such that

λ_{j + 3} \leq x \leq λ_{j + 4}

. If

c_{j}, c_{j + 1}, c_{j + 2}

and

c_{j + 3}

are all of the same sign, then the computed value of

s (x)

has a relative error not exceeding

20 \times machine precision

in modulus. For further details see Cox (1978).

Further Comments

The time taken is approximately

c \times (1 + 0.1 \times \log (\bar{n} + 7))

seconds, where c is a machine-dependent constant.

Note: the function does not test all the conditions on the knots given in the description of lamda in Arguments, since to do this would result in a computation time approximately linear in

\bar{n} + 7

instead of

\log (\bar{n} + 7)

. All the conditions are tested in nag_fit_1dspline_knots (e02ba), however.

Example

Evaluate at nine equally-spaced points in the interval

1.0 \leq x \leq 9.0

the cubic spline with (augmented) knots

1.0

1.0

1.0

1.0

3.0

6.0

8.0

9.0

9.0

9.0

9.0

and normalized cubic B-spline coefficients

1.0

2.0

4.0

7.0

6.0

4.0

3.0

The example program is written in a general form that will enable a cubic spline with

\bar{n}

intervals, in its normalized cubic B-spline form, to be evaluated at

m

equally-spaced points in the interval

lamda (4) \leq x \leq lamda (\bar{n} + 4)

. The program is self-starting in that any number of datasets may be supplied.

Open in the MATLAB editor: e02bb_example

function e02bb_example


fprintf('e02bb example results\n\n');

knots = [3 6 8];
ncap = size(knots,2) + 1;
ncap7 = ncap + 7;

lamda = zeros(ncap7,1);
lamda(1:4) = 1;
lamda(5:7) = knots;
lamda(8:ncap7) = 9;

% B-spline coefficients
c = zeros(ncap7,1);
c(1:ncap+3) = [1  2  4   7   6    4    3];

% Evaluate spline at values in lamda range
a = lamda(4);
b = lamda(ncap+4);
for x = 1:9;
  [s(x), ifail] = e02bb( ...
                         lamda, c, x);
end
fprintf('    x      spline at x\n');
fprintf('%7.2f%14.4f\n',[ [1:9]; s]);

fig1 = figure;
hold on
plot([1:9],s,'*')
plot([1:9],s);
xlabel('x');
title('Evaluation of cubic spline representation');
legend('Evaluation points','cubic spline','Location','NorthWest');
hold off;

e02bb example results

    x      spline at x
   1.00        1.0000
   2.00        2.3779
   3.00        3.6229
   4.00        4.8327
   5.00        5.8273
   6.00        6.3571
   7.00        6.1905
   8.00        5.1667
   9.00        3.0000

PDF version (NAG web site, 64-bit version, 64-bit version)

Chapter Contents

Chapter Introduction

NAG Toolbox