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 (x)

x \in ℝ^{d}

of a set of scattered data points

(x_{r}, f_{r})

, for

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

x_{i}

, for

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: $x (d, m)$ – double array: Note: the $i$ th ordinate of the point $x_{j}$ is stored in $x (i, j)$ .

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: $f (m)$ – 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: $iq (2 \times m + 1)$ – 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: $rq (*)$ – double array: The dimension of the array rq must be at least $((d + 1) \times (d + 2) / 2) \times m + 2 \times 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: $xe (d, n)$ – double array: Note: the $i$ th ordinate of the point $x_{j}$ is stored in $xe (i, j)$ .

$xe (1 : d, j)$ must be set to the evaluation point $x_{j}$ , for $j = 1, 2, \dots, n$ .

Optional Input Parameters

1: $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: $d \geq 2$ .
2: $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: $m \geq (d + 1) \times (d + 2) / 2 + 2$ .
3: $n$ – int64int32nag_int scalar: Default: the second dimension of the array xe.
$n$ , the number of evaluation points.

Constraint: $n \geq 1$ .

Output Parameters

1: $q (n)$ – double array: $q (i)$ contains the value of the interpolant, at $x_{i}$ , for $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 $ifail = 3$ .
2: $qx (d, n)$ – double array: $qx (i, j)$ contains the value of the partial derivatives with respect to the $i$ th independent variable (dimension) of the interpolant $Q (x)$ at $x_{j}$ , for $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 $ifail = 3$ .
3: $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$: Constraint: $d \geq 2$ .

Constraint: $m \geq (d + 1) \times (d + 2) / 2 + 2$ .

Constraint: $n \geq 1$ .

On entry, $((d + 1) \times (d + 2) / 2) \times m + 2 \times d + 1$ exceeds the largest machine integer.

$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).

$ifail = 3$: On entry, at least one evaluation point lies outside the region of definition of the interpolant.

$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

Computational errors should be negligible in most practical situations.

Further Comments

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

O (n)

. At worst

O (m n)

time will be required.

Example

This program evaluates the function (in six variables)

f (x) = \frac{x_{1} x_{2} x_{3}}{1 + 2 x_{4} x_{5} x_{6}}

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

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.

See also Example in nag_interp_nd_scat_shep (e01zm).

Open in the MATLAB editor: e01zn_example

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

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

Chapter Contents

Chapter Introduction

NAG Toolbox