Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

Gridded data interpolation

Use `griddedInterpolant`

to perform interpolation on a 1-D,
2-D, 3-D, or N-D gridded data set.
`griddedInterpolant`

returns the interpolant
`F`

for the given dataset. You can evaluate `F`

at a
set of query points, such as `(xq,yq)`

in 2-D, to produce interpolated
values `vq = F(xq,yq)`

.

Use `scatteredInterpolant`

to perform
interpolation with scattered data.

`F = griddedInterpolant`

`F = griddedInterpolant(x,v)`

`F = griddedInterpolant(X1,X2,...,Xn,V)`

`F = griddedInterpolant(V)`

`F = griddedInterpolant(gridVecs,V)`

`F = griddedInterpolant(___,Method)`

`F = griddedInterpolant(___,Method,ExtrapolationMethod)`

creates an
empty gridded data interpolant object.`F`

= griddedInterpolant

creates a 2-D, 3-D, or N-D interpolant using a full
grid of sample points passed as a set of
`F`

= griddedInterpolant(`X1`

,`X2`

,...,`Xn`

,`V`

)`n`

-dimensional arrays `X1,X2,...,Xn`

. The
`V`

array contains the sample values associated with the
point locations in `X1,X2,...,Xn`

. Each of the arrays
`X1,X2,...,Xn`

must be the same size as
`V`

.

uses the default grid to create the interpolant. When you use this syntax,
`F`

= griddedInterpolant(`V`

)`griddedInterpolant`

defines the grid as a
set of points whose spacing is `1`

and range is
[`1`

, `size(V,i)`

] in the
`i`

th dimension. Use this syntax when you want to conserve
memory and are not concerned about the absolute distances between points.

specifies a cell array `F`

= griddedInterpolant(`gridVecs`

,`V`

)`gridVecs`

that contains
`n`

grid vectors to
describe an `n`

-dimensional grid of sample points. Use this
syntax when you want to use a specific grid and also conserve memory.

specifies an alternative interpolation method: `F`

= griddedInterpolant(___,`Method`

)`'linear'`

,
`'nearest'`

, `'next'`

,
`'previous'`

, `'pchip'`

,
`'cubic'`

, `'makima'`

, or
`'spline'`

. You can specify `Method`

as
the last input argument in any of the previous syntaxes.

specifies both the interpolation and extrapolation methods. `F`

= griddedInterpolant(___,`Method`

,`ExtrapolationMethod`

)`griddedInterpolant`

uses
`ExtrapolationMethod`

to estimate the value when your query
points fall outside the domain of your sample points.

Use `griddedInterpolant`

to create the interpolant, `F`

. Then you can evaluate
`F`

at specific points using any of the following syntaxes:

`Vq = F(Xq)`

Vq = F(xq1,xq2,...,xqn)

Vq = F(Xq1,Xq2,...,Xqn)

Vq = F({xgq1,xgq2,...,xgqn})

`Vq = F(Xq)`

specifies the query points in the matrix`Xq`

. Each row of`Xq`

contains the coordinates of a query point.`Vq = F(xq1,xq2,...,xqn)`

specifies the query points`xq1,xq2,...,xqn`

as column vectors of length`m`

representing`m`

points scattered in`n`

-dimensional space.`Vq = F(Xq1,Xq2,...,Xqn)`

specifies the query points using the`n`

-dimensional arrays`Xq1,Xq2,...,Xqn`

, which define a full grid of points.`Vq = F({xgq1,xgq2,...,xgqn})`

specifies the query points as grid vectors. Use this syntax to conserve memory when you want to query a large grid of points.

It is quicker to evaluate a

`griddedInterpolant`

object`F`

at many different sets of query points than it is to compute the interpolations separately using`interp1`

,`interp2`

,`interp3`

, or`interpn`

. For example:% Fast to create interpolant F and evaluate multiple times F = griddedInterpolant(X1,X2,V) v1 = F(Xq1) v2 = F(Xq2) % Slower to compute interpolations separately using interp2 v1 = interp2(X1,X2,V,Xq1) v2 = interp2(X1,X2,V,Xq2)

`fillmissing`

| `filloutliers`

| `interp1`

| `interp2`

| `interp3`

| `interpn`

| `meshgrid`

| `ndgrid`

| `scatteredInterpolant`

Was this topic helpful?