e01zac (dimn_grid) : NAG Library CL Interface, Mark 28

2 Specification

#include <nag.h>

void	e01zac (Integer d, const Integer narr[], Nag_Boolean uniform, const double axis[], Integer lx, const double v[], const double point[], Nag_Interp method, Integer k, double wf, double ans, NagError fail)

The function may be called by the names: e01zac, nag_interp_dimn_grid or nag_nd_grid_interp.

3 Description

e01zac interpolates an

n

-dimensional point within a set of gridded data points,

Z = {z_{1 j_{1}}, z_{2 j_{2}}, \dots, z_{d j_{d}}}

, with corresponding data values

F = {f_{1 j_{1}}, f_{2 j_{2}}, \dots, f_{d j_{d}}}

where, for the

i

th dimension,

j_{i} = 1, \dots, n_{i}

and

n_{i}

is the number of ordinates in the

i

th dimension.

A hypercube of

{(2 k)}^{d}

data points

[h_{1}, h_{2}, \dots, h_{{(2 k)}^{d}}] \subset Z

, where

h_{i} = (h_{i 1}, h_{i 2}, \dots, h_{i d})

and the corresponding data values are

f (h_{i}) \in F

, around the given point,

x = (x_{1}, x_{2}, \dots, x_{d})

, is found and then used to interpolate using one of the following three methods.

(i)Weighted Average, that is a modification of Shepard's method (Shepard (1968)) as used for scattered data in e01zmc. This method interpolates the data with the weighted mean

$Q (x) = \frac{\sum_{r = 1}^{{(2 k)}^{d}} w_{r} (x) f_{r}}{\sum_{r = 1}^{{(2 k)}^{d}} w_{r} (x)},$

where $f_{r} = f (h_{r})$ , $w_{r} (x) = \frac{1}{D (| x - h_{r} |)}$ and $D (y) = y_{1}^{ρ} + y_{2}^{ρ} + \dots + y_{d}^{ρ}$ , for a given value of $ρ$ .
(ii)Linear Interpolation, which takes $2^{d}$ surrounding data points ( $k = 1$ ) and performs two one-dimensional linear interpolations in each dimension on data points $h_{a}$ and $h_{b}$ , reducing the dimension every iteration until it has reached an answer. The formula for linear interpolation in dimension $i$ is simply

$f = f_{a} + (x_{i} - h_{a i}) \frac{f_{b} - f_{a}}{h_{b i} - h_{a i}},$

where $f_{r} = f (h_{r})$ and $h_{a i} < x_{i} < h_{b i}$ .

(iii)Cubic Interpolation, based on cubic convolution (Keys (1981)). In a similar way to the Linear Interpolation method, it performs the interpolations in one dimension reducing it each time, however it requires four surrounding data points in each dimension (

k = 2

), two in each direction

(h_{−1}, h_{0}, h_{1}, h_{2})

. The following is used to calculate the one-dimensional interpolant in dimension

i

f = \frac{1}{2} (\begin{matrix} 1 & t & t^{2} & t^{3} \end{matrix}) (\begin{matrix} 0 & 2 & 0 & 0 \\ −1 & 0 & 1 & 0 \\ 2 & −5 & 4 & −1 \\ −1 & 3 & −3 & 1 \end{matrix}) (\begin{matrix} f_{−1} \\ f_{0} \\ f_{1} \\ f_{2} \end{matrix})

where

t = x_{i} - h_{0 i}

and

f_{r} = f (h_{r})

4 References

Keys R (1981) Cubic Convolution Interpolation for Digital Image Processing IEEE Transactions on Acoutstics, Speech, and Signal Processing Vol ASSP-29 No. 6 1153–1160 http://hmi.stanford.edu/doc/Tech_Notes/HMI-TN-2004-004-Interpolation/Keys_cubic_interp.pdf

Shepard D (1968) A two-dimensional interpolation function for irregularly spaced data Proc. 23rd Nat. Conf. ACM 517–523 Brandon/Systems Press Inc., Princeton

5 Arguments

d

– Integer Input

On entry:

d

, the number of dimensions.

Constraint:

d \geq 2

narr [d]

– const Integer Input

On entry: the number of data ordinates in each dimension, with

narr [i - 1] = n_{i}

, for

i = 1, 2, \dots, d

Constraint:

narr [i - 1] \geq 2

uniform

– Nag_Boolean Input

On entry: states whether the data points are uniformly spaced.

$uniform = Nag_TRUE$: The data points are uniformly spaced.
$uniform = Nag_FALSE$: The data points are not uniformly spaced.

Constraint: if

method = Nag_CubicInterp

, uniform must be Nag_TRUE.

axis [lx]

– const double Input

On entry: defines the axis. If the data points are uniformly spaced (see argument uniform) axis should contain the start and end of each dimension

(x_{1 1}, x_{1 n_{1}}, \dots, x_{d 1}, x_{d n_{d}})

If the data points are not uniformly spaced, axis should contain all the data ordinates for each dimension

(x_{1 1}, x_{1 2}, \dots, x_{1 n_{1}}, \dots, x_{d 1}, x_{d 2}, \dots, x_{d n_{d}})

Constraint: axis must be strictly increasing in each dimension.

lx

– Integer Input

On entry: the dimension of the array axis.

Constraints:

if $uniform = Nag_TRUE$ , $lx = 2 d$ ;
if $uniform = Nag_FALSE$ , $lx = \sum_{i = 1}^{d} narr [i - 1]$ .

v [\dim]

– const double Input

Note: the dimension, dim, of the array v must be at least

\prod_{i = 0}^{d - 1} narr [i]

On entry: holds the values of the data points in such an order that the index of a data value with coordinates

(z_{1}, z_{2}, \dots, z_{d})

\sum_{i = 1}^{d} z_{i} \prod_{n \in S_{i}} n,

where

S_{i} = {narr [l - 1] : l = 1, \dots, i - 1}

e.g.,

((x_{11}, x_{21}, \dots, x_{d 1}), (x_{12}, x_{21}, \dots, x_{d 1}), \dots, (x_{1 n_{d}}, x_{21}, \dots, x_{d 1}), (x_{11}, x_{22}, \dots, x_{d 1}), (x_{12}, x_{22}, \dots, x_{d 1}), \dots, (x_{1 n_{d}}, x_{2 n_{d}}, \dots, x_{d n_{d}}))

point [d]

– const double Input

On entry:

x

, the point at which the data value is to be interpolated.

Constraint: the point must lie inside the limits of the data values in each dimension supplied in axis.

method

– Nag_Interp Input

On entry: the method to be used.

$method = Nag_WeightedAverage$: Weighted Average.
$method = Nag_LinearInterp$: Linear Interpolation.
$method = Nag_CubicInterp$: Cubic Interpolation.

Constraint:

method = Nag_WeightedAverage

Nag_LinearInterp

Nag_CubicInterp

k

– Integer Input

On entry: if

method = Nag_WeightedAverage

, k controls the number of data points used in the Weighted Average method, with k points used in each dimension, either side of the interpolation point. The total number of data points used for the interpolation will, therefore, be

{(2 k)}^{d}

method \neq Nag_WeightedAverage

, then k is not referenced and need not be set.

Constraint: if

method = Nag_WeightedAverage

k \geq 1

10:

wf

– double Input

On entry: the power used for the weighted average such that a high power will cause closer points to be more heavily weighted.

Constraint: if

method = Nag_WeightedAverage

1.0 \leq wf \leq 15.0

11:

ans

– double * Output

On exit: holds the result of the interpolation.

12:

fail

– NagError * Input/Output

The NAG error argument (see Section 7 in the Introduction to the NAG Library CL Interface).

6 Error Indicators and Warnings

NE_ALLOC_FAIL

Dynamic memory allocation failed.
See Section 3.1.2 in the Introduction to the NAG Library CL Interface for further information.

NE_BAD_PARAM

On entry, argument

⟨ value ⟩

had an illegal value.

NE_INT

Cubic Interpolation method does not have enough data surrounding point; interpolation not possible.

On entry,

d = ⟨ value ⟩

.
Constraint:

d \geq 2

On entry,

k = ⟨ value ⟩

.
Constraint: if

method = Nag_WeightedAverage

k \geq 1

On entry,

lx = ⟨ value ⟩

d = ⟨ value ⟩

.
Constraint: if

uniform = Nag_TRUE

lx = 2 d

On entry,

lx = ⟨ value ⟩

\sum

narr

= ⟨ value ⟩

.
Constraint: if

uniform = Nag_FALSE

lx = \sum narr

On entry,

method = Nag_CubicInterp

and

uniform = Nag_FALSE

.
Constraint: if

method = Nag_CubicInterp

, uniform must be Nag_TRUE.

NE_INT_2

On entry,

narr [⟨ value ⟩] = ⟨ value ⟩

.
Constraint:

narr [i - 1] \geq 2

NE_INTERNAL_ERROR

An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.
See Section 7.5 in the Introduction to the NAG Library CL Interface for further information.

NE_NO_LICENCE

Your licence key may have expired or may not have been installed correctly.
See Section 8 in the Introduction to the NAG Library CL Interface for further information.

NE_NOT_INCREASING

On entry, axis decreases in dimension

⟨ value ⟩

.
Constraint: axis definition must be strictly increasing.

NE_REAL

On entry,

point [⟨ value ⟩] = ⟨ value ⟩

and data range

= [⟨ value ⟩, ⟨ value ⟩]

.
Constraint: point must be within the data range.

On entry,

wf = ⟨ value ⟩

.
Constraint: if

method = Nag_WeightedAverage

1.0 \leq wf \leq 15.0

NW_INT

Warning: the size of k has been reduced, due to too few data points around point.

7 Accuracy

For most data the Cubic Interpolation method will provide the best interpolation but it is data dependent. If the data is linear, the Linear Interpolation method will be best. For noisy data the Weighted Average method is advised with

wf < 2.0

and

k > 1

. This will include more data points and give them a greater influence to the answer.

NAG CL Interface
e01zac (dimn_grid)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

NAG CL Interfacee01zac (dimn_​grid)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

NAG CL Interface
e01zac (dimn_grid)