# ifft

Inverse fast Fourier transform

## Syntax

``X = ifft(Y)``
``X = ifft(Y,n)``
``X = ifft(Y,n,dim)``
``X = ifft(___,symflag)``

## Description

example

````X = ifft(Y)` computes the inverse discrete Fourier transform of `Y` using a fast Fourier transform algorithm. `X` is the same size as `Y`. If `Y` is a vector, then `ifft(Y)` returns the inverse transform of the vector.If `Y` is a matrix, then `ifft(Y)` returns the inverse transform of each column of the matrix.If `Y` is a multidimensional array, then `ifft(Y)` treats the values along the first dimension whose size does not equal 1 as vectors and returns the inverse transform of each vector. ```

example

````X = ifft(Y,n)` returns the `n`-point inverse Fourier transform of `Y` by padding `Y` with trailing zeros to length `n`.```

example

````X = ifft(Y,n,dim)` returns the inverse Fourier transform along the dimension `dim`. For example, if `Y` is a matrix, then `ifft(Y,n,2)` returns the `n`-point inverse transform of each row.```

example

````X = ifft(___,symflag)` specifies the symmetry of `Y`. For example, `ifft(Y,'symmetric')` treats `Y` as conjugate symmetric.```

## Examples

collapse all

The Fourier transform and its inverse convert between data sampled in time and space and data sampled in frequency.

Create a vector and compute its Fourier transform.

```X = [1 2 3 4 5]; Y = fft(X)```
```Y = 1×5 complex 15.0000 + 0.0000i -2.5000 + 3.4410i -2.5000 + 0.8123i -2.5000 - 0.8123i -2.5000 - 3.4410i ```

Compute the inverse transform of `Y`, which is the same as the original vector `X`.

`ifft(Y)`
```ans = 1×5 1 2 3 4 5 ```

The `ifft` function allows you to control the size of the transform.

Create a random 3-by-5 matrix and compute the 8-point inverse Fourier transform of each row. Each row of the result has length 8.

```Y = rand(3,5); n = 8; X = ifft(Y,n,2); size(X)```
```ans = 1×2 3 8 ```

For nearly conjugate symmetric vectors, you can compute the inverse Fourier transform faster by specifying the `'symmetric'` option, which also ensures that the output is real. Nearly conjugate symmetric data can arise when computations introduce round-off error.

Create a vector `Y` that is nearly conjugate symmetric and compute its inverse Fourier transform. Then, compute the inverse transform specifying the `'symmetric'` option, which eliminates the nearly 0 imaginary parts.

`Y = [1 2:4+eps(4) 4:-1:2]`
```Y = 1×7 1.0000 2.0000 3.0000 4.0000 4.0000 3.0000 2.0000 ```
`X = ifft(Y)`
```X = 1×7 complex 2.7143 + 0.0000i -0.7213 + 0.0000i -0.0440 - 0.0000i -0.0919 + 0.0000i -0.0919 - 0.0000i -0.0440 + 0.0000i -0.7213 - 0.0000i ```
`Xsym = ifft(Y,'symmetric')`
```Xsym = 1×7 2.7143 -0.7213 -0.0440 -0.0919 -0.0919 -0.0440 -0.7213 ```

## Input Arguments

collapse all

Input array, specified as a vector, a matrix, or a multidimensional array. If `Y` is of type `single`, then `ifft` natively computes in single precision, and `X` is also of type `single`. Otherwise, `X` is returned as type `double`.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `uint8` | `uint16` | `uint32` | `logical`
Complex Number Support: Yes

Inverse transform length, specified as `[]` or a nonnegative integer scalar. Padding `Y` with zeros by specifying a transform length larger than the length of `Y` can improve the performance of `ifft`. The length is typically specified as a power of 2 or a product of small prime numbers. If `n` is less than the length of the signal, then `ifft` ignores the remaining signal values past the `n`th entry and returns the truncated result. If `n` is 0, then `ifft` returns an empty matrix.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `uint8` | `uint16` | `uint32` | `logical`

Dimension to operate along, specified as a positive integer scalar. By default, `dim` is the first array dimension whose size does not equal 1. For example, consider a matrix `Y`.

• `ifft(Y,[],1)` returns the inverse Fourier transform of each column.

• `ifft(Y,[],2)` returns the inverse Fourier transform of each row.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `uint8` | `uint16` | `uint32` | `logical`

Symmetry type, specified as `'nonsymmetric'` or `'symmetric'`. When `Y` is not exactly conjugate symmetric due to round-off error, `ifft(Y,'symmetric')` treats `Y` as if it were conjugate symmetric. For more information on conjugate symmetry, see Algorithms.

collapse all

### Discrete Fourier Transform of Vector

`Y = fft(X)` and ```X = ifft(Y)``` implement the Fourier transform and inverse Fourier transform, respectively. For `X` and `Y` of length `n`, these transforms are defined as follows:

`$\begin{array}{l}Y\left(k\right)=\sum _{j=1}^{n}X\left(j\right)\text{\hspace{0.17em}}{W}_{n}^{\left(j-1\right)\text{​}\left(k-1\right)}\\ X\left(j\right)=\frac{1}{n}\sum _{k=1}^{n}Y\left(k\right)\text{\hspace{0.17em}}{W}_{n}{}^{-\left(j-1\right)\text{​}\left(k-1\right)},\end{array}$`

where

`${W}_{n}={e}^{\left(-2\pi i\right)/n}$`

is one of n roots of unity.

## Algorithms

• The `ifft` function tests whether the vectors in `Y` are conjugate symmetric. A vector `v` is conjugate symmetric when it equals `conj(v([1,end:-1:2]))`. If the vectors in `Y` are conjugate symmetric, then the inverse transform computation is faster and the output is real.