2-D inverse fast Fourier transform

`Y = ifft2(X)`

Y = ifft2(X,m,n)

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

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

`Y = ifft2(X)`

returns the
two-dimensional inverse discrete Fourier transform (DFT) of `X`

,
computed with a fast Fourier transform (FFT) algorithm. The result `Y`

is
the same size as `X`

.

`ifft2`

tests `X`

to see
whether it is *conjugate symmetric*. If so, the
computation is faster and the output is real. An `M`

-by-`N`

matrix `X`

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

for each element of `X`

.

`Y = ifft2(X,m,n)`

returns
the `m-`

by`-n`

inverse fast Fourier
transform of matrix `X`

.

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

causes `ifft2`

to
treat `X`

as conjugate symmetric. This option is
useful when `X`

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

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

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

without the argument `'nonsymmetric'`

.

For any `X`

, `ifft2(fft2(X))`

equals `X`

to
within roundoff error.

`ifft2`

supports inputs of data types `double`

and `single`

.
If you call `ifft2`

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

, the output `y`

has the
same data type as the input `X`

.

Was this topic helpful?