# Documentation

라이선스가 부여된 사용자만 번역 문서를 볼 수 있습니다. 번역 문서를 보려면 로그인하십시오.

# interpn

Interpolation for 1-D, 2-D, 3-D, and N-D gridded data in ndgrid format

In a future release, `interpn` will not accept mixed combinations of row and column vectors for the sample and query grids. For more information, and recommendations for updating your code, see Functionality being removed or changed.

## Syntax

• `Vq = interpn(X1,X2,...,Xn,V,Xq1,Xq2,...,Xqn)` example
• `Vq = interpn(V,Xq1,Xq2,...,Xqn)`
• `Vq = interpn(V)`
• `Vq = interpn(V,k)` example
• `Vq = interpn(___,method)` example
• `Vq = interpn(___,method,extrapval)` example

## Description

example

````Vq = interpn(X1,X2,...,Xn,V,Xq1,Xq2,...,Xqn)` 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. `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.```
````Vq = interpn(V,Xq1,Xq2,...,Xqn)` assumes a default grid of sample points. The default grid consists of the points, 1,2,3,...ni in each dimension. The value of ni is the length of the ith dimension in `V`. Use this syntax to when you want to conserve memory and are not concerned about the absolute distances between points.```
````Vq = interpn(V)` returns the interpolated values on a refined grid formed by dividing the interval between sample values once in each dimension.```

example

````Vq = interpn(V,k)` returns the interpolated values on a refined grid formed by repeatedly dividing the intervals `k` times in each dimension.```

example

````Vq = interpn(___,method)` specifies an optional, trailing input argument that you can pass with any of the previous syntaxes. The `method` argument can be any of the following strings that specify alternative interpolation methods: `'linear'`, `'nearest'`, `'pchip'`,`'cubic'`, or `'spline'`. The default method is `'linear'`.```

example

````Vq = interpn(___,method,extrapval)` also specifies `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'` method`NaN` values for interpolation methods other than `'spline'````

## Examples

collapse all

### 1-D 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'); ```

### 2-D 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 3-D 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 100-by-50-by-30 random number array, `V`. Use the `gallery` function to create the array.

```V = gallery('uniformdata',100,50,30,0); ```

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 -1 -1 ```

All three points evaluate to `-1` because they are outside the domain of `x1`, `x2`, and `x3`.

### 4-D 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

collapse all

### `X1,X2,...,Xn` — Sample grid pointsarrays | vectors

Sample grid points, specified as real arrays or vectors.

• If `X1,X2,...,Xn` are arrays, then they contain the coordinates of a full grid (in ndgrid format). Use the `ndgrid` function to create the `X1,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 and increasing.

Example: `[X1,X2,X3] = ndgrid(1:30,-10:10,1:5)`

Data Types: `single` | `double`

### `V` — Sample valuesarray

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 (in `ndgrid` format), then the size of `V` matches the size of any array, `X1,X2,...,Xn`.

• If `X1,X2,...,Xn` are grid vectors, then `V` is an array whose `i`th dimension is the same length as grid vector `Xi`, where `i= 1,2,...n`.

Example: `rand(10,5,3,2)`

Data Types: `single` | `double`
Complex Number Support: Yes

### `Xq1,Xq2,...,Xqn` — Query pointsscalars | 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 Rn.

• If `Xq1,Xq2,...,Xqn` are vectors of different orientations, then `Xq1,Xq2,...,Xqn` are treated as grid vectors in Rn.

• If `Xq1,Xq2,...,Xqn` are vectors of the same size and orientation, then `Xq1,Xq2,...,Xqn` are treated as scattered points in Rn.

• If `Xq1,Xq2,...,Xqn` are arrays of the same size, then they represent either a full grid of query points (in `ndgrid` format) or scattered points in Rn.

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^k-1` 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 R2. 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'`

Interpolation method, specified as a string from this table.

`'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.C0
• Requires at least two grid points in each dimension

• Requires more memory than `'nearest'`

`'nearest'`The interpolated value at a query point is the value at the nearest sample grid point. Discontinuous
• Requires two grid points in each dimension.

• Fastest computation with modest memory requirements

`'pchip'`Shape-preserving piecewise cubic interpolation (for 1-D only). The interpolated value at a query point is based on a shape-preserving piecewise cubic interpolation of the values at neighboring grid points.C1
• Requires at least four points

• Requires more memory and computation time than `'linear'`

`'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.C1
• Grid must have uniform spacing in each dimension, but the spacing does not have to be the same for all dimensions

• Requires at least four points in each dimension

• Requires more memory and computation time than `'linear'`

`'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 not-a-knot end conditions.C2
• Requires four points in each dimension

• Requires more memory and computation time than `'cubic'`

### `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

collapse all

### `Vq` — Interpolated valuesscalar | 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.

SyntaxesSpecial ConditionsSize of VqExample
`interpn(X1,...,Xn,V,Xq1,...,Xqn)`
`interpn(V,Xq1,...,Xqn)`
and variations of these syntaxes that include `method` or `extrapval`
`Xq1,...,Xqn` are scalarsScalar`size(Vq) = [1 1]` when you pass `Xq1,...,Xqn` as scalars.
Same as above`Xq1,...,Xqn` are vectors of the same size and orientationVector of same size and orientation as `Xq1,...,Xqn`In 3-D, 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 3-D, 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 sizeArray of the same size as `Xq1,...,Xqn`In 3-D, 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 `i`th dimension is
`2^k * (size(V,i)-1)+1`,

In 3-D, if
`size(V) = [10 12 5]`,
and `k = 3`,
then ```size(Vq) = [73 89 33]```.

collapse all

### 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 Rn. The ith array, `Xi`, 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 R2 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 mixed-orientation that define the points of a grid in Rn.

For example, the following code creates the grid vectors in R3 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 Rn. 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 R3.

```Xq1 = [1 6; 15 0]; Xq2 = [19 40; 33 61]; Xq3 = [10 1; 22 13];```