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_interp_nd_scat_shep_eval (e01zn)

## Purpose

nag_interp_nd_scat_shep_eval (e01zn) evaluates the multidimensional interpolating function generated by nag_interp_nd_scat_shep (e01zm) and its first partial derivatives.

## Syntax

[q, qx, ifail] = e01zn(x, f, iq, rq, xe, 'd', d, 'm', m, 'n', n)
[q, qx, ifail] = nag_interp_nd_scat_shep_eval(x, f, iq, rq, xe, 'd', d, 'm', m, 'n', n)

## Description

nag_interp_nd_scat_shep_eval (e01zn) takes as input the interpolant $Q\left(\mathbf{x}\right)$, $\mathbf{x}\in {ℝ}^{d}$ of a set of scattered data points $\left({\mathbf{x}}_{\mathit{r}},{f}_{\mathit{r}}\right)$, for $\mathit{r}=1,2,\dots ,m$, as computed by nag_interp_nd_scat_shep (e01zm), and evaluates the interpolant and its first partial derivatives at the set of points ${\mathbf{x}}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,n$.
nag_interp_nd_scat_shep_eval (e01zn) must only be called after a call to nag_interp_nd_scat_shep (e01zm).
nag_interp_nd_scat_shep_eval (e01zn) is derived from the new implementation of QS3GRD described by Renka (1988). It uses the modification for high-dimensional interpolation described by Berry and Minser (1999).

## References

Berry M W, Minser K S (1999) Algorithm 798: high-dimensional interpolation using the modified Shepard method ACM Trans. Math. Software 25 353–366
Renka R J (1988) Algorithm 661: QSHEP3D: Quadratic Shepard method for trivariate interpolation of scattered data ACM Trans. Math. Software 14 151–152

## Parameters

### Compulsory Input Parameters

1:     $\mathrm{x}\left({\mathbf{d}},{\mathbf{m}}\right)$ – double array
Note: the $i$th ordinate of the point ${x}_{j}$ is stored in ${\mathbf{x}}\left(i,j\right)$.
must be the same array supplied as argument x in the preceding call to nag_interp_nd_scat_shep (e01zm). It must remain unchanged between calls.
2:     $\mathrm{f}\left({\mathbf{m}}\right)$ – double array
must be the same array supplied as argument f in the preceding call to nag_interp_nd_scat_shep (e01zm). It must remain unchanged between calls.
3:     $\mathrm{iq}\left(2×{\mathbf{m}}+1\right)$int64int32nag_int array
must be the same array returned as argument iq in the preceding call to nag_interp_nd_scat_shep (e01zm). It must remain unchanged between calls.
4:     $\mathrm{rq}\left(*\right)$ – double array
The dimension of the array rq must be at least $\left(\left({\mathbf{d}}+1\right)×\left({\mathbf{d}}+2\right)/2\right)×{\mathbf{m}}+2×{\mathbf{d}}+1$
must be the same array returned as argument rq in the preceding call to nag_interp_nd_scat_shep (e01zm). It must remain unchanged between calls.
5:     $\mathrm{xe}\left({\mathbf{d}},{\mathbf{n}}\right)$ – double array
Note: the $i$th ordinate of the point ${x}_{j}$ is stored in ${\mathbf{xe}}\left(i,j\right)$.
${\mathbf{xe}}\left(1:{\mathbf{d}},\mathit{j}\right)$ must be set to the evaluation point ${\mathbf{x}}_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,n$.

### Optional Input Parameters

1:     $\mathrm{d}$int64int32nag_int scalar
Default: the first dimension of the arrays xe, x. (An error is raised if these dimensions are not equal.)
must be the same value supplied for argument d in the preceding call to nag_interp_nd_scat_shep (e01zm).
Constraint: ${\mathbf{d}}\ge 2$.
2:     $\mathrm{m}$int64int32nag_int scalar
Default: the dimension of the array f and the second dimension of the array x. (An error is raised if these dimensions are not equal.)
must be the same value supplied for argument m in the preceding call to nag_interp_nd_scat_shep (e01zm).
Constraint: ${\mathbf{m}}\ge \left({\mathbf{d}}+1\right)×\left({\mathbf{d}}+2\right)/2+2$.
3:     $\mathrm{n}$int64int32nag_int scalar
Default: the second dimension of the array xe.
$n$, the number of evaluation points.
Constraint: ${\mathbf{n}}\ge 1$.

### Output Parameters

1:     $\mathrm{q}\left({\mathbf{n}}\right)$ – double array
${\mathbf{q}}\left(\mathit{i}\right)$ contains the value of the interpolant, at ${\mathbf{x}}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,n$. If any of these evaluation points lie outside the region of definition of the interpolant the corresponding entries in q are set to the largest machine representable number (see nag_machine_real_largest (x02al)), and nag_interp_nd_scat_shep_eval (e01zn) returns with ${\mathbf{ifail}}={\mathbf{3}}$.
2:     $\mathrm{qx}\left({\mathbf{d}},{\mathbf{n}}\right)$ – double array
${\mathbf{qx}}\left(i,j\right)$ contains the value of the partial derivatives with respect to the $i$th independent variable (dimension) of the interpolant $Q\left(\mathbf{x}\right)$ at ${\mathbf{x}}_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,n$, and for each of the partial derivatives $i=1,2,\dots ,d$. If any of these evaluation points lie outside the region of definition of the interpolant, the corresponding entries in qx are set to the largest machine representable number (see nag_machine_real_largest (x02al)), and nag_interp_nd_scat_shep_eval (e01zn) returns with ${\mathbf{ifail}}={\mathbf{3}}$.
3:     $\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$
Constraint: ${\mathbf{d}}\ge 2$.
Constraint: ${\mathbf{m}}\ge \left({\mathbf{d}}+1\right)×\left({\mathbf{d}}+2\right)/2+2$.
Constraint: ${\mathbf{n}}\ge 1$.
On entry, $\left(\left({\mathbf{d}}+1\right)×\left({\mathbf{d}}+2\right)/2\right)×{\mathbf{m}}+2×{\mathbf{d}}+1$ exceeds the largest machine integer.
${\mathbf{ifail}}=2$
On entry, values in iq appear to be invalid. Check that iq has not been corrupted between calls to nag_interp_nd_scat_shep (e01zm) and nag_interp_nd_scat_shep_eval (e01zn).
On entry, values in rq appear to be invalid. Check that rq has not been corrupted between calls to nag_interp_nd_scat_shep (e01zm) and nag_interp_nd_scat_shep_eval (e01zn).
${\mathbf{ifail}}=3$
On entry, at least one evaluation point lies outside the region of definition of the interpolant.
${\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

Computational errors should be negligible in most practical situations.

The time taken for a call to nag_interp_nd_scat_shep_eval (e01zn) will depend in general on the distribution of the data points. If the data points are approximately uniformly distributed, then the time taken should be only $\mathit{O}\left(n\right)$. At worst $\mathit{O}\left(mn\right)$ time will be required.

## Example

This program evaluates the function (in six variables)
 $fx = x1 x2 x3 1 + 2 x4 x5 x6$
at a set of randomly generated data points and calls nag_interp_nd_scat_shep (e01zm) to construct an interpolating function ${Q}_{x}$. It then calls nag_interp_nd_scat_shep_eval (e01zn) to evaluate the interpolant at a set of points on the line ${x}_{i}=x$, for $\mathit{i}=1,2,\dots ,6$. To reduce the time taken by this example, the number of data points is limited. Increasing this value to the suggested minimum of $4000$ improves the interpolation accuracy at the expense of more time.
```function e01zn_example

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

genid = int64(1);
subid = int64(1);
seed = [int64(1762543)];
m = 120; % Number of data points
n = 9; % Number of evaluation points
d = 6; % Number of dimensions

% Initialize the generator to a repeatable sequence
[state, ifail] = g05kf(genid, subid, seed);

% Generate the data points X
[state, x, ifail] = g05sa(int64(d*m), state);

x = reshape(x, d, m);

% Evaluate f
f = x(1, :).*x(2, :).*x(3, :)./(1+2.*x(4, :).*x(5, :).*x(6, :));

% Generate the interpolant
[iq, rq, ifail] = e01zm(x, f);

% Generate a set of evaluation points lying on diagonal line.
xe = zeros(d, n);
for i = 1:n
xe(:, i) = i/(n+1);
end

% Evaluate the interpolant
[q, qx, ifail] = e01zn(x, f, iq, rq, xe);

fprintf('\ni  |  f(i)      q(i)    | |f(i)-q(i)|\n');
fprintf('---|--------------------+--------------\n');
for i=1:n
fun = xe(1, i)*xe(2, i)*xe(3, i)/(1+2*xe(4, i)*xe(5, i)*xe(6, i));
fprintf('%d %10.4f%10.4f %10.4f\n', i, fun, q(i), abs(fun-q(i)));
end

```
```e01zn example results

i  |  f(i)      q(i)    | |f(i)-q(i)|
---|--------------------+--------------
1     0.0010    0.0043     0.0033
2     0.0079    0.0040     0.0039
3     0.0256    0.0210     0.0046
4     0.0567    0.0536     0.0031
5     0.1000    0.0988     0.0012
6     0.1508    0.1526     0.0018
7     0.2034    0.2077     0.0043
8     0.2530    0.2570     0.0040
9     0.2966    0.2953     0.0013
```