interpn
Interpolation for 1D, 2D, 3D, and ND gridded data in ndgrid format
Syntax
Description
returns
interpolated values of a function of n variables
at specific query points using linear interpolation. The results always
pass through the original sampling of the function. Vq
= interpn(X1,X2,...,Xn
,V
,Xq1,Xq2,...,Xqn
)X1,X2,...,Xn
contain
the coordinates of the sample points. V
contains
the corresponding function values at each sample point. Xq1,Xq2,...,Xqn
contain
the coordinates of the query points.
assumes a default grid of sample points. The default grid consists of the
points, 1,2,3,...n_{i} in each dimension. The value of
n_{i} is the length of the ith dimension in
Vq
= interpn(V
,Xq1,Xq2,...,Xqn
)V
. Use this syntax when you want to conserve memory and
are not concerned about the absolute distances between points.
also
specifies Vq
= interpn(___,method
,extrapval
)extrapval
, a scalar value that is assigned
to all queries that lie outside the domain of the sample points.
If you omit the extrapval
argument for queries
outside the domain of the sample points, then based on the method
argument interpn
returns
one of the following:
The extrapolated values for the
'spline'
and'makima'
methodsNaN
values for other interpolation methods
Examples
1D Interpolation
Define the sample points and values.
x = [1 2 3 4 5]; v = [12 16 31 10 6];
Define the query points, xq
, and interpolate.
xq = (1:0.1:5);
vq = interpn(x,v,xq,'cubic');
Plot the result.
figure plot(x,v,'o',xq,vq,''); legend('Samples','Cubic Interpolation');
2D Interpolation
Create a set of grid points and corresponding sample values.
[X1,X2] = ndgrid((5:1:5)); R = sqrt(X1.^2 + X2.^2)+ eps; V = sin(R)./(R);
Interpolate over a finer grid using ntimes=1
.
Vq = interpn(V,'cubic');
mesh(Vq);
Evaluate Outside Domain of 3D Function
Create the grid vectors, x1
, x2
, and x3
. These vectors define the points associated with the values in V
.
x1 = 1:100; x2 = (1:50)'; x3 = 1:30;
Define the sample values to be a 100by50by30 random number array, V
. Use the gallery
function to create the array.
rng('default')
V = rand(100,50,30);
Evaluate V
at three points outside the domain of x1
, x2
, and x3
. Specify extrapval = 1
.
xq1 = [0 0 0];
xq2 = [0 0 51];
xq3 = [0 101 102];
vq = interpn(x1,x2,x3,V,xq1,xq2,xq3,'linear',1)
vq = 1×3
1 1 1
All three points evaluate to 1
because they are outside the domain of x1
, x2
, and x3
.
4D Interpolation
Define an anonymous function that represents .
f = @(x,y,z,t) t.*exp(x.^2  y.^2  z.^2);
Create a grid of points in . Then, pass the points through the function to create the sample values, V
.
[x,y,z,t] = ndgrid(1:0.2:1,1:0.2:1,1:0.2:1,0:2:10); V = f(x,y,z,t);
Now, create the query grid.
[xq,yq,zq,tq] = ...
ndgrid(1:0.05:1,1:0.08:1,1:0.05:1,0:0.5:10);
Interpolate V
at the query points.
Vq = interpn(x,y,z,t,V,xq,yq,zq,tq);
Create a movie to show the results.
figure('renderer','zbuffer'); nframes = size(tq, 4); for j = 1:nframes slice(yq(:,:,:,j),xq(:,:,:,j),zq(:,:,:,j),... Vq(:,:,:,j),0,0,0); caxis([0 10]); M(j) = getframe; end movie(M);
Input Arguments
X1,X2,...,Xn
— Sample grid points
arrays  vectors
Sample grid points, specified as real arrays or vectors. The sample grid points must be unique.
If
X1,X2,...,Xn
are arrays, then they contain the coordinates of a full grid (in ndgrid format). Use thendgrid
function to create theX1,X2,...,Xn
arrays together. These arrays must be the same size.If
X1,X2,...,Xn
are vectors, then they are treated as grid vectors. The values in these vectors must be strictly monotonic, either increasing or decreasing.
Example: [X1,X2,X3,X4] = ndgrid(1:30,10:10,1:5,10:13)
Data Types: single
 double
V
— Sample values
array
Sample values, specified as a real or complex array. The size
requirements for V
depend on the size of X1,X2,...,Xn
:
If
X1,X2,...,Xn
are arrays representing a full grid (inndgrid
format), then the size ofV
matches the size of any array,X1,X2,...,Xn
.If
X1,X2,...,Xn
are grid vectors, thenV
is an array whosei
th dimension is the same length as grid vectorXi
, wherei= 1,2,...n
.
If V
contains complex numbers, then interpn
interpolates
the real and imaginary parts separately.
Example: rand(10,5,3,2)
Data Types: single
 double
Complex Number Support: Yes
Xq1,Xq2,...,Xqn
— Query points
scalars  vectors  arrays
Query points, specified as a real scalars, vectors, or arrays.
If
Xq1,Xq2,...,Xqn
are scalars, then they are the coordinates of a single query point in R^{n}.If
Xq1,Xq2,...,Xqn
are vectors of different orientations, thenXq1,Xq2,...,Xqn
are treated as grid vectors in R^{n}.If
Xq1,Xq2,...,Xqn
are vectors of the same size and orientation, thenXq1,Xq2,...,Xqn
are treated as scattered points in R^{n}.If
Xq1,Xq2,...,Xqn
are arrays of the same size, then they represent either a full grid of query points (inndgrid
format) or scattered points in R^{n}.
Example: [X1,X2,X3,X4] = ndgrid(1:10,1:5,7:9,10:11)
Data Types: single
 double
k
— Refinement factor
1
(default)  real, nonnegative, integer scalar
Refinement factor, specified as a real, nonnegative, integer
scalar. This value specifies the number of times to repeatedly divide
the intervals of the refined grid in each dimension. This results
in 2^k1
interpolated points between sample values.
If k
is 0
, then Vq
is
the same as V
.
interpn(V,1)
is the same as interpn(V)
.
The following illustration depicts k=2
in R^{2}.
There are 72 interpolated values in red and 9 sample values in black.
Example: interpn(V,2)
Data Types: single
 double
method
— Interpolation method
'linear'
(default)  'nearest'
 'pchip'
 'cubic'
 'spline'
 'makima'
Interpolation method, specified as one of the options in this table.
Method  Description  Continuity  Comments 

'linear'  The interpolated value at a query point is based on linear interpolation of the values at neighboring grid points in each respective dimension. This is the default interpolation method.  C^{0} 

'nearest'  The interpolated value at a query point is the value at the nearest sample grid point.  Discontinuous 

'pchip'  Shapepreserving piecewise cubic interpolation (for 1D only). The interpolated value at a query point is based on a shapepreserving piecewise cubic interpolation of the values at neighboring grid points.  C^{1} 

'cubic'  The interpolated value at a query point is based on a cubic interpolation of the values at neighboring grid points in each respective dimension. The interpolation is based on a cubic convolution.  C^{1} 

'makima'  Modified Akima cubic Hermite interpolation. The interpolated value at a query point is based on a piecewise function of polynomials with degree at most three evaluated using the values of neighboring grid points in each respective dimension. The Akima formula is modified to avoid overshoots.  C^{1} 

'spline'  The interpolated value at a query point is based on a cubic interpolation of the values at neighboring grid points in each respective dimension. The interpolation is based on a cubic spline using notaknot end conditions.  C^{2} 

extrapval
— Function value outside domain of X1,X2,...,Xn
scalar
Function value outside domain of X1,X2,...,Xn
,
specified as a real or complex scalar. interpn
returns
this constant value for all points outside the domain of X1,X2,...,Xn
.
Example: 5
Example: 5+1i
Data Types: single
 double
Complex Number Support: Yes
Output Arguments
Vq
— Interpolated values
scalar  vector  array
Interpolated values, returned as a real or complex scalar, vector,
or array. The size and shape of Vq
depends on the
syntax you use and, in some cases, the size and value of the input
arguments.
Syntaxes  Special Conditions  Size of Vq  Example 

interpn(X1,...,Xn,V,Xq1,...,Xqn) interpn(V,Xq1,...,Xqn) and variations of these syntaxes that include method or extrapval  Xq1,...,Xqn are scalars  Scalar  size(Vq) = [1 1] when you pass Xq1,...,Xqn as
scalars. 
Same as above  Xq1,...,Xqn are vectors of the same size
and orientation  Vector of same size and orientation as Xq1,...,Xqn  In 3D, if size(Xq1) = [100 1] ,and size(Xq2) = [100 1] , and size(Xq3)
= [100 1] , then size(Vq) = [100
1] . 
Same as above  Xq1,...,Xqn are vectors of mixed orientation  size(Vq) = [length(Xq1),...,length(Xqn)]  In 3D, if size(Xq1) = [1 100] ,and size(Xq2) = [50 1] , and size(Xq3)
= [1 5] ,then size(Vq) = [100 50
5] . 
Same as above  Xq1,...,Xqn are arrays of the same size  Array of the same size as Xq1,...,Xqn  In 3D, if size(Xq1) = [50 25] ,and size(Xq2) = [50 25] , and size(Xq3)
= [50 25] , then size(Vq) = [50
25] . 
interpn(V,k) and variations of this syntax that include method or extrapval  None  Array in which the length of the  In 3D, if size(V) = [10 12 5] ,and k = 3 , then size(Vq)
= [73 89 33] . 
More About
Strictly Monotonic
A set of values that are always increasing
or decreasing, without reversals. For example, the sequence, a
= [2 4 6 8]
is strictly monotonic and increasing. The sequence, b
= [2 4 4 6 8]
is not strictly monotonic because there is
no change in value between b(2)
and b(3)
.
The sequence, c = [2 4 6 8 6]
contains a reversal
between c(4)
and c(5)
, so it
is not monotonic at all.
Full Grid (in ndgrid Format)
For interpn
, the full
grid consists of n arrays, X1,X2,...,Xn
,
whose elements represent a grid of points in R^{n}.
The ith array, X_{i}
, contains strictly monotonic,
increasing values that vary most rapidly along the ith dimension.
Use the ndgrid
function
to create a full grid that you can pass to interpn
.
For example, the following code creates a full grid in R^{2} for
the region, 1 ≤ X1 ≤ 3, 1≤ X2 ≤
4.
[X1,X2] = ndgrid(1:3,(1:4))
X1 = 1 1 1 1 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 X2 = 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4
Grid Vectors
For interpn
, grid vectors
consist of n vectors of mixedorientation that
define the points of a grid in R^{n}.
For example, the following code creates the grid vectors in R^{3} for the region, 1 ≤ x1 ≤ 3, 4 ≤ x2 ≤ 5, and 6 ≤x3≤ 8:
x1 = 1:3; x2 = (4:5)'; x3 = 6:8;
Scattered Points
For interpn
, scattered
points consist of n arrays or vectors, Xq1,Xq2,...,Xqn
,
that define a collection of points scattered in R^{n}.
The i
th array, Xi
, contains
the coordinates in the i
th dimension.
For example, the following code specifies the points, (1, 19, 10), (6, 40, 1), (15, 33, 22), and (0, 61, 13) in R^{3}.
Xq1 = [1 6; 15 0]; Xq2 = [19 40; 33 61]; Xq3 = [10 1; 22 13];
Extended Capabilities
C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.
Usage notes and limitations:
For best results, provide
X1,X2,...,Xn
as vectors. The values in these vectors must be strictly monotonic and increasing.Code generation does not support the
'makima'
interpolation method.Code generation does not support the
'cubic'
or'spline'
interpolation methods for 2D and higher interpolation.The interpolation method must be a constant character vector.
ThreadBased Environment
Run code in the background using MATLAB® backgroundPool
or accelerate code with Parallel Computing Toolbox™ ThreadPool
.
This function fully supports threadbased environments. For more information, see Run MATLAB Functions in ThreadBased Environment.
GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.
Usage notes and limitations:
A maximum of five dimensions is supported.
V
must be a double or single ND array.V
can be real or complex.X1,X2,...,Xn
,Y
must:Have the same type (double or single).
Be finite vectors or ND arrays with increasing and nonrepeating elements in corresponding dimensions.
Align with Cartesian axes when
X1,X2,...,Xn
are ND arrays (as if they were produced byndgrid
).Have dimensions consistent with
V
.
X1,X2,...,Xn
must be vectors or arrays of the same type (double or single). IfX1,X2,...,Xn
are arrays, then they must have the same size. If they are vectors with different lengths, then one of them must have a different orientation.method
must be'linear'
or'nearest'
.The extrapolation for the outofboundary input is not supported.
For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).
Distributed Arrays
Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.
This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).
Version History
Open Example
You have a modified version of this example. Do you want to open this example with your edits?
MATLAB Command
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
You can also select a web site from the following list:
How to Get Best Site Performance
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.
Americas
 América Latina (Español)
 Canada (English)
 United States (English)
Europe
 Belgium (English)
 Denmark (English)
 Deutschland (Deutsch)
 España (Español)
 Finland (English)
 France (Français)
 Ireland (English)
 Italia (Italiano)
 Luxembourg (English)
 Netherlands (English)
 Norway (English)
 Österreich (Deutsch)
 Portugal (English)
 Sweden (English)
 Switzerland
 United Kingdom (English)