Inverse fast Fourier transform

`y = ifft(X)`

y = ifft(X,n)

y = ifft(X,[],dim)

y = ifft(X,n,dim)

y = ifft(..., 'symmetric')

y = ifft(..., 'nonsymmetric')

`y = ifft(X)`

returns the
inverse discrete Fourier transform (DFT) of vector `X`

,
computed with a fast Fourier transform (FFT) algorithm. If `X`

is
a matrix, `ifft`

returns the inverse DFT of each
column of the matrix.

`ifft`

tests `X`

to see
whether vectors in `X`

along the active dimension
are *conjugate symmetric*. If so, the computation
is faster and the output is real. An `N`

-element
vector `x`

is conjugate symmetric if ```
x(i)
= conj(x(mod(N-i+1,N)+1))
```

for each
element of `x`

.

If `X`

is a multidimensional array, `ifft`

operates
on the first non-singleton dimension.

`y = ifft(X,n)`

returns the `n`

-point
inverse DFT of vector `X`

.

`y = ifft(X,[],dim)`

and `y = ifft(X,n,dim)`

return the inverse DFT of `X`

across
the dimension `dim`

.

`y = ifft(..., 'symmetric')`

causes `ifft`

to
treat `X`

as conjugate symmetric along the active
dimension. This option is useful when `X`

is not
exactly conjugate symmetric, merely because of round-off error.

`y = ifft(..., 'nonsymmetric')`

is
the same as calling `ifft(...)`

without the argument `'nonsymmetric'`

.

For any `X`

, `ifft(fft(X))`

equals `X`

to
within roundoff error.

`ifft`

supports inputs of data types `double`

and `single`

.
If you call `ifft`

with the syntax ```
y =
ifft(X, ...)
```

, the output `y`

has the same
data type as the input `X`

.

Was this topic helpful?