Integer type:  int32  int64  nag_int  show int32  show int32  show int64  show int64  show nag_int  show nag_int

Chapter Contents
Chapter Introduction
NAG Toolbox

# NAG Toolbox: nag_fit_2dspline_evalv (e02de)

## Purpose

nag_fit_2dspline_evalv (e02de) calculates values of a bicubic spline from its B-spline representation.

## Syntax

[ff, ifail] = e02de(x, y, lamda, mu, c, 'm', m, 'px', px, 'py', py)
[ff, ifail] = nag_fit_2dspline_evalv(x, y, lamda, mu, c, 'm', m, 'px', px, 'py', py)

## Description

nag_fit_2dspline_evalv (e02de) calculates values of the bicubic spline $s\left(x,y\right)$ at prescribed points $\left({x}_{\mathit{r}},{y}_{\mathit{r}}\right)$, for $\mathit{r}=1,2,\dots ,m$, from its augmented knot sets $\left\{\lambda \right\}$ and $\left\{\mu \right\}$ and from the coefficients ${c}_{ij}$, for $\mathit{i}=1,2,\dots ,{\mathbf{px}}-4$ and $\mathit{j}=1,2,\dots ,{\mathbf{py}}-4$, in its B-spline representation
 $sx,y=∑ijcijMixNjy.$
Here ${M}_{i}\left(x\right)$ and ${N}_{j}\left(y\right)$ denote normalized cubic B-splines, the former defined on the knots ${\lambda }_{i}$ to ${\lambda }_{i+4}$ and the latter on the knots ${\mu }_{j}$ to ${\mu }_{j+4}$.
This function may be used to calculate values of a bicubic spline given in the form produced by nag_interp_2d_spline_grid (e01da), nag_fit_2dspline_panel (e02da), nag_fit_2dspline_grid (e02dc) and nag_fit_2dspline_sctr (e02dd). It is derived from the function B2VRE in Anthony et al. (1982).

## References

Anthony G T, Cox M G and Hayes J G (1982) DASL – Data Approximation Subroutine Library National Physical Laboratory
Cox M G (1978) The numerical evaluation of a spline from its B-spline representation J. Inst. Math. Appl. 21 135–143

## Parameters

### Compulsory Input Parameters

1:     $\mathrm{x}\left({\mathbf{m}}\right)$ – double array
2:     $\mathrm{y}\left({\mathbf{m}}\right)$ – double array
x and y must contain ${x}_{\mathit{r}}$ and ${y}_{\mathit{r}}$, for $\mathit{r}=1,2,\dots ,m$, respectively. These are the coordinates of the points at which values of the spline are required. The order of the points is immaterial.
Constraint: ${\mathbf{x}}$ and ${\mathbf{y}}$ must satisfy
 $lamda4≤xr≤lamdapx-3$
and
 $mu4≤yr≤mupy- 3, r= 1,2,…,m.$
.
The spline representation is not valid outside these intervals.
3:     $\mathrm{lamda}\left({\mathbf{px}}\right)$ – double array
4:     $\mathrm{mu}\left({\mathbf{py}}\right)$ – double array
lamda and mu must contain the complete sets of knots $\left\{\lambda \right\}$ and $\left\{\mu \right\}$ associated with the $x$ and $y$ variables respectively.
Constraint: the knots in each set must be in nondecreasing order, with ${\mathbf{lamda}}\left({\mathbf{px}}-3\right)>{\mathbf{lamda}}\left(4\right)$ and ${\mathbf{mu}}\left({\mathbf{py}}-3\right)>{\mathbf{mu}}\left(4\right)$.
5:     $\mathrm{c}\left(\left({\mathbf{px}}-4\right)×\left({\mathbf{py}}-4\right)\right)$ – double array
${\mathbf{c}}\left(\left({\mathbf{py}}-4\right)×\left(\mathit{i}-1\right)+\mathit{j}\right)$ must contain the coefficient ${c}_{\mathit{i}\mathit{j}}$ described in Description, for $\mathit{i}=1,2,\dots ,{\mathbf{px}}-4$ and $\mathit{j}=1,2,\dots ,{\mathbf{py}}-4$.

### Optional Input Parameters

1:     $\mathrm{m}$int64int32nag_int scalar
Default: the dimension of the arrays x, y. (An error is raised if these dimensions are not equal.)
$m$, the number of points at which values of the spline are required.
Constraint: ${\mathbf{m}}\ge 1$.
2:     $\mathrm{px}$int64int32nag_int scalar
3:     $\mathrm{py}$int64int32nag_int scalar
Default: For px, the dimension of the array lamda. For py, the dimension of the array mu.
px and py must specify the total number of knots associated with the variables $x$ and $y$ respectively. They are such that ${\mathbf{px}}-8$ and ${\mathbf{py}}-8$ are the corresponding numbers of interior knots.
Constraint: ${\mathbf{px}}\ge 8$ and ${\mathbf{py}}\ge 8$.

### Output Parameters

1:     $\mathrm{ff}\left({\mathbf{m}}\right)$ – double array
${\mathbf{ff}}\left(\mathit{r}\right)$ contains the value of the spline at the point $\left({x}_{\mathit{r}},{y}_{\mathit{r}}\right)$, for $\mathit{r}=1,2,\dots ,m$.
2:     $\mathrm{ifail}$int64int32nag_int scalar
${\mathbf{ifail}}={\mathbf{0}}$ unless the function detects an error (see Error Indicators and Warnings).

## Error Indicators and Warnings

Errors or warnings detected by the function:
${\mathbf{ifail}}=1$
 On entry, ${\mathbf{m}}<1$, or ${\mathbf{py}}<8$, or ${\mathbf{px}}<8$.
${\mathbf{ifail}}=2$
On entry, the knots in array lamda, or those in array mu, are not in nondecreasing order, or ${\mathbf{lamda}}\left({\mathbf{px}}-3\right)\le {\mathbf{lamda}}\left(4\right)$, or ${\mathbf{mu}}\left({\mathbf{py}}-3\right)\le {\mathbf{mu}}\left(4\right)$.
${\mathbf{ifail}}=3$
On entry, at least one of the prescribed points $\left({x}_{r},{y}_{r}\right)$ lies outside the rectangle defined by ${\mathbf{lamda}}\left(4\right)$, ${\mathbf{lamda}}\left({\mathbf{px}}-3\right)$ and ${\mathbf{mu}}\left(4\right)$, ${\mathbf{mu}}\left({\mathbf{py}}-3\right)$.
${\mathbf{ifail}}=-99$
${\mathbf{ifail}}=-399$
Your licence key may have expired or may not have been installed correctly.
${\mathbf{ifail}}=-999$
Dynamic memory allocation failed.

## Accuracy

The method used to evaluate the B-splines is numerically stable, in the sense that each computed value of $s\left({x}_{r},{y}_{r}\right)$ can be regarded as the value that would have been obtained in exact arithmetic from slightly perturbed B-spline coefficients. See Cox (1978) for details.

Computation time is approximately proportional to the number of points, $m$, at which the evaluation is required.

## Example

This program reads in knot sets ${\mathbf{lamda}}\left(1\right),\dots ,{\mathbf{lamda}}\left({\mathbf{px}}\right)$ and ${\mathbf{mu}}\left(1\right),\dots ,{\mathbf{mu}}\left({\mathbf{py}}\right)$, and a set of bicubic spline coefficients ${c}_{ij}$. Following these are a value for $m$ and the coordinates $\left({x}_{\mathit{r}},{y}_{\mathit{r}}\right)$, for $\mathit{r}=1,2,\dots ,m$, at which the spline is to be evaluated.
```function e02de_example

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

% Spline knots and coefficients
lamda = [1    1     1     1     1.3   1.5   1.6   2     2     2     2];
mu    = [0    0     0     0     0.4   0.7   1     1     1     1];
c = [1      1.2    1.5833 2.1433 2.8667 3.4667 4;
1.1333 1.3333 1.7167 2.2767 3      3.6    4.1333;
1.3667 1.5667 1.95   2.51   3.2333 3.8333 4.3667;
1.7    1.9    2.2833 2.8433 3.5667 4.1667 4.7;
1.9    2.1    2.4833 3.0433 3.7667 4.3667 4.9;
2      2.2    2.5833 3.1433 3.8667 4.4667 5];

% Evaluate spline at set of points for displaying

x     = [1    1.1   1.5   1.6   1.9   1.9   2];
y     = [0    0.1   0.7   0.4   0.3   0.8   1];

[ff, ifail] = e02de( ...
x, y, lamda, mu, c);

fprintf('        x          y          fit\n');
fprintf('%11.3f%11.3f%11.3f\n',[x; y; ff']);

% Evaluate spline on mesh for figure
mx = [1:0.05:2];
my = [0:0.05:1];
for i = 1:21
xx(1:21) = mx(i);
[ff(1:21,i), ifail] = e02de( ...
xx, my, lamda, mu, c);
end
fig1 = figure;
meshc(mx,my,ff);
xlabel('x');
ylabel('y');
title('Least-squares bi-cubic spline surface');

```
```e02de example results

x          y          fit
1.000      0.000      1.000
1.100      0.100      1.310
1.500      0.700      2.950
1.600      0.400      2.960
1.900      0.300      3.910
1.900      0.800      4.410
2.000      1.000      5.000
```