n-dimensional data interpolation (table lookup) - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Numerical Computations : Interpolation and Curve Fitting : CurveFitting Package : CurveFitting/ArrayInterpolation

CurveFitting[ArrayInterpolation] - n-dimensional data interpolation (table lookup)

Calling Sequence

ArrayInterpolation(xdata, ydata, xvalues, options)

ArrayInterpolation(xydata, xvalues, options)

Parameters

xdata

-

a list, Array, Vector, or Matrix containing the independent coordinate(s) of each of the data points, given in one of several possible forms

ydata

-

a list, Array, or Vector containing the dependent coordinate of each of the data points

xydata

-

alternate input; a list, Array, or Matrix containing both the dependent and independent coordinates of each of the data points

xvalues

-

a numeric value, list, Vector, or Array containing the independent coordinate(s) of one or more points whose dependent coordinate will be approximated using interpolation

options

-

(optional) equation(s) of the form keyword = value, where keyword is one of method, degree, endpoints, knots, uniform, verify, extrapolate, or container.

Description

• 

The ArrayInterpolation command takes a finite set of distinct data points given by xdata and ydata (or xydata), and interpolates to approximate the y-values corresponding to the points given in xvalues.  It considers an interpolant function f such that fx=y for all respective pairs x,y in xdata and ydata (or xydata). Such a function can be constructed using one of various methods (see below).  It then computes and returns fxi for all xi in xvalues.

• 

The focus of the ArrayInterpolation command is the performance of quick and efficient data resampling and table lookup.  To actually compute and return interpolants, functions such as CurveFitting[Spline] and CurveFitting[RationalInterpolation] can be used instead.

• 

The ArrayInterpolation function can interpolate numeric data in n dimensions, where n is any positive integer.

• 

The list of independent coordinates of the data points, given in xdata, can be input in a number of different ways.  xdata can be:

– 

(preferred if n=1) a Vector, list, or 1-dimensional Array of strictly increasing x-coordinates. The dataset will then have size a1, where a1 is the length of xdata.

– 

(preferred if 1<n) a list of n Vectors, lists, or 1-dimensional Arrays, one for each dimension of the data.  The jth Vector, list, or Array in the input must contain, in increasing order, all of the possible jth coordinates of the data points.  In this case, the block of data points will be assumed to lie on an a1 by a2 by ... by an grid, where aj is the length of the jth Vector or Array in the input.  The pth coordinate of the data point at index &lsqb;j1, j2, ..., jn&rsqb; (where 1jiai) will be equal to the apth element of the pth Array in the input.

– 

an Array of size a1 by a2 by ... by an by n, giving the independent coordinate(s) of each of a1 by a2 by ... by an data points as an ordered n-tuple. These coordinates must form a proper "grid" of values, and must be sorted in strictly increasing order along each dimension.  More formally,xdata&lsqb;j1, j2, ..., jn, p&rsqb; - xdata&lsqb;k1, k2, ..., kn, p&rsqb; must be zero if jp&equals;kp, and must be positive if kp<jp.

– 

a list of n Arrays of size a1 by a2 by ... by an, where the jth array contains the jth independent coordinate of each of the a1 by a2 by ... by an data points.  The coordinates must form a proper "grid" of values, and must be sorted in strictly increasing order along each dimension.  More formally,opp&comma;xdata&lsqb;j1, j2, ..., jn] - opp&comma;xdata&lsqb;k1, k2, ..., kn&rsqb; must be zero if jp&equals;kp, and must be positive if kp<jp.

  

The preferred methods minimize memory usage and execution time by avoiding unnecessary storage and verification of redundant data.  In all cases, xdata must contain real values of type numeric.

• 

The list of dependent coordinates of the data points, given in ydata, must be input as an Array (or a Matrix, Vector, or list for appropriate values of n) of size a1 by a2 by ... by an, so that the value of ydata&lsqb;j1, j2, ..., jn&rsqb; corresponds to the element in xdata of index&lsqb;j1, j2, ..., jn&rsqb;. Values in ydata must be real numbers of type numeric.

• 

As an alternate form of input, a single structure xydata containing all coordinates of the data points can be entered.  It can be formatted in one of the following ways:

– 

an Array or Matrix of size a1 by a2 by ... by an by (n&plus;1), giving the independent and dependent coordinate(s) of each of a1 by a2 by ... by an data points as an ordered (n&plus;1)-tuple.  The first n elements in each (n&plus;1)-tuple represent the independent coordinates of each point, and must adhere to the same restrictions as above (a proper "grid" must be formed, and the independent coordinates must be sorted in strictly increasing order along each dimension).  The n&plus;1st coordinate in each (n&plus;1)-tuple then represents the dependent coordinate of the respective data point.

– 

a list of n&plus;1 Arrays, Vectors, Matrices, or lists of size a1 by a2 by ... by an, where the jth array contains the jth independent coordinate of each of the a1 by a2 by ... by an data points for 1jn, and the n&plus;1st Array contains the dependent coordinates of each point.  As above, the independent coordinates must adhere to certain restrictions (a proper "grid" must be formed, and the independent coordinates must be sorted in strictly increasing order along each dimension).

  

For multidimensional data, these methods are not recommended, since space is wasted storing the full grid of independent coordinates instead of a list of all the possible coordinates in each dimension. In both cases, the coordinates must be real values of type numeric.

• 

The list of values to interpolate at, given in xvalues, may be input in one of the following formats:

– 

for one-dimensional data, a single numeric value, or a Vector, list, or 1-dimensional Array of numeric values can be input.  The output will be returned in a format matching the format of the input.

– 

for multidimensional data, an Array or Matrix of size u1 by u2 by ... by uk by n of numeric values can be input.  It must contain the n coordinates of each of u1 by u2 by ... by uk values to interpolate at, with the value of xvalues&lsqb;j1, j2, ..., jk, p&rsqb; giving the pth coordinate of the respective point.  The output will be returned in an array of size u1 by u2 by ... by uk containing the interpolated results.

– 

alternatively, a list of n Vectors, lists, or 1-dimensional Arrays can be input. The jth Vector, list, or Array in the input will be assumed to contain all of the possible jth coordinates of the values to interpolate at.  In this case, interpolation will be performed on an a1 by a2 by ... by an block of points, where aj is the length of the jth Vector or Array in the input.  The output will then be returned in a Vector, Matrix, list, or Array of size a1 by a2 by ... by an.

• 

If any of the data points in xvalues lie outside the rectangular bounding box specified by the input, then extrapolation will be performed to approximate their corresponding y-values.  The method by which extrapolation is performed can be controlled by using option extrapolate; see below.

• 

This routine has separate numeric methods for handling hardware and software floats.  The decision about which routine to use can be controlled by setting the UseHardwareFloats environment variable.  If UseHardwareFloats remains unset, then hardware floats are used if and only if Digits <= evalhf(Digits), in which case all software floats in the input will be converted to hardware floats.

• 

Only computations involving numeric floating point data are supported by this routine. If the input does not contain floating point data, an error will be thrown.

• 

For optimal performance, all rtables in the input should be Fortran order with rectangular storage (the default). Otherwise, a conversion will take place.  All rtables in the output will be Fortran order rtables with rectangular storage.

• 

This function is part of the CurveFitting package, so it can be used in the short form ArrayInterpolation(..) only after executing the command with(CurveFitting).  However, it can always be accessed through the long form of the command by using CurveFitting[Interpolation](..).

Examples

withCurveFitting&colon;

withplots&colon;

An introductory example.  Suppose a signal is sampled several times over a given interval of time:

Times:=0.00&comma;0.01&comma;0.02&comma;0.03&comma;0.04&comma;0.05&comma;0.06&comma;0.07&comma;0.08&comma;0.09&comma;0.10&colon;

Amplitudes:=0.6&comma;0.0&comma;0.4&comma;0.6&comma;0.3&comma;0.1&comma;0.2&comma;0.0&comma;0.1&comma;0.3&comma;0.6&colon;

pointplotTimes&comma;Amplitudes

ArrayInterpolation to resample the data at a higher sampling frequency:

NewTimes:=seq0.001i&comma;i&equals;0..100&colon;

NewAmplitudes:=ArrayInterpolationTimes&comma;Amplitudes&comma;NewTimes&colon;

pointplotNewTimes&comma;NewAmplitudes

Use a cubic spline to achieve a smoother, more realistic resampling of the data:

NewAmplitudes:=ArrayInterpolationTimes&comma;Amplitudes&comma;NewTimes&comma;method&equals;spline&colon;

pointplotNewTimes&comma;NewAmplitudes

Try again, using a spline that assumes the data is sampled from a periodic waveform:

NewAmplitudes:=ArrayInterpolationTimes&comma;Amplitudes&comma;NewTimes&comma;method&equals;spline&comma;endpoints&equals;periodic&colon;

pointplotNewTimes&comma;NewAmplitudes

A 2-dimensional example: a tiny grayscale image stored in a Matrix:

Ranges:=seq1..10&comma;seq1..16&colon;

Img:=evalfMatrix255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;208&comma;93&comma;22&comma;0&comma;16&comma;98&comma;210&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;196&comma;16&comma;0&comma;0&comma;0&comma;0&comma;0&comma;19&comma;200&comma;255&comma;255&comma;54&comma;54&comma;212&comma;255&comma;255&comma;61&comma;34&comma;156&comma;231&comma;255&comma;230&comma;154&comma;26&comma;58&comma;255&comma;255&comma;61&comma;0&comma;59&comma;255&comma;255&comma;5&comma;205&comma;255&comma;255&comma;255&comma;255&comma;255&comma;196&comma;7&comma;255&comma;255&comma;230&comma;91&comma;7&comma;255&comma;255&comma;20&comma;235&comma;255&comma;255&comma;255&comma;255&comma;255&comma;235&comma;36&comma;255&comma;255&comma;255&comma;233&comma;32&comma;255&comma;255&comma;125&comma;129&comma;255&comma;255&comma;255&comma;255&comma;255&comma;133&comma;186&comma;255&comma;255&comma;217&comma;89&comma;147&comma;255&comma;255&comma;255&comma;125&comma;50&comma;91&comma;99&comma;93&comma;40&comma;22&comma;121&comma;93&comma;58&comma;10&comma;140&comma;255&comma;255&comma;255&comma;255&comma;255&comma;216&comma;131&comma;75&comma;14&comma;5&comma;7&comma;12&comma;59&comma;121&comma;214&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&comma;255&colon;

listdensityplotImg&comma;style&equals;PATCHNOGRID&comma;axes&equals;none&comma;range&equals;0..255

Upsample it to a larger image using bilinear interpolation:

NewRanges:=seq3..52&comma;seq3..825.0&colon;

NewImg:=ArrayInterpolationRanges&comma;Img&comma;NewRanges&comma;extrapolate&equals;255&colon;

listdensityplotNewImg&comma;style&equals;PATCHNOGRID&comma;axes&equals;none&comma;range&equals;0..255

Try again, using bicubic interpolation instead for a smoother fit:

NewImg:=ArrayInterpolationRanges&comma;Img&comma;NewRanges&comma;extrapolate&equals;255&comma;method&equals;cubic&colon;

listdensityplotNewImg&comma;style&equals;PATCHNOGRID&comma;axes&equals;none&comma;range&equals;0..255

A non-uniform multidimensional example.  Create some 3-D mesh structures to pass through a given set of points defined by a mathematical function:

f:=i&comma;j&rarr;3sini23j2&colon;

plot3df&comma;0..10&comma;0..10&comma;axes&equals;normal

Define a non-uniform grid of points, and sample f over them:

v:=Array0&comma;1.5&comma;3.5&comma;5&comma;6&comma;8&comma;9&colon;

w:=Array0&comma;3&comma;5&comma;6&comma;6.5&comma;7.5&colon;

y:=Matrix7&comma;6&comma;a&comma;b&rarr;evalffva&comma;wb&colon;

Plot the data so far:

pointplot3dseqseqvi&comma;wj&comma;yi&comma;j&comma;j&equals;1..6&comma;i&equals;1..7&comma;axes&equals;normal&comma;symbol&equals;sphere

Create a finer mesh to interpolate over:

a1:=Matrix50&comma;50&comma;i&comma;j&rarr;i5&colon;

a2:=Matrix50&comma;50&comma;i&comma;j&rarr;j5&colon;

A:=ArrayTools&lsqb;Concatenate&rsqb;3&comma;a1&comma;a2&colon;

Linear interpolation produces a quick approximation to f:

B:=ArrayInterpolationv&comma;w&comma;y&comma;A&comma;method&equals;linear&colon;

matrixplotMatrixB&comma;axes&equals;normal

Nearest-neighbor interpolation can also be used for quick lookup purposes:

B:=ArrayInterpolationv&comma;w&comma;y&comma;A&comma;method&equals;nearest&colon;

matrixplotMatrixB&comma;axes&equals;normal

Spline interpolation produces a smoother approximation to the original function f:

B:=ArrayInterpolationv&comma;w&comma;y&comma;A&comma;method&equals;spline&colon;

matrixplotMatrixB&comma;axes&equals;normal

Increasing the degree of the spline approximation can increase the smoothness of the result, but results in a longer computation time, greater numerical instability, and can cause large oscillations around the edges of a data set:

B:=ArrayInterpolationv&comma;w&comma;y&comma;A&comma;method&equals;spline&comma;degree&equals;5&colon;

matrixplotMatrixB&comma;axes&equals;normal

Finally, a large example to illustrate a few tips for increasing the speed of computations:

A:=evalfVectorseq0..50000&colon;

B:=evalfVectorseqi2&comma;i&equals;0..50000&colon;

C:=evalfVectorseq0..2000004&colon;

timeArrayInterpolationA&comma;B&comma;C

0.476

(1)

On such a large 1-dimensional example, a significant portion of the execution time is spent verifying the integrity of the input data.  Disabling this verification will produce a significant speedup in the execution time of the routine, but will produce incorrect results if the input is not correctly formatted or sorted:

timeArrayInterpolationA&comma;B&comma;C&comma;verify&equals;false

0.383

(2)

Asserting that the data is uniform allows a faster lookup method to be used:

timeArrayInterpolationA&comma;B&comma;C&comma;verify&equals;false&comma;uniform&equals;true

0.333

(3)

Cubic interpolation takes longer than the default, linear method:

timeArrayInterpolationA&comma;B&comma;C&comma;verify&equals;false&comma;uniform&equals;true&comma;method&equals;cubic

0.516

(4)

See Also

CurveFitting, CurveFitting[PolynomialInterpolation], CurveFitting[RationalInterpolation], CurveFitting[Spline], CurveFitting[SplineConditions], CurveFitting[ThieleInterpolation]


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam