N-D inverse fast Fourier transform

`Y = ifftn(X)`

Y = ifftn(X,siz)

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

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

`Y = ifftn(X)`

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

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

is the same size as `X`

.

`ifftn`

tests `X`

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

-by-`N2`

-by-
... `Nk`

array `X`

is conjugate
symmetric if

X(i1,i2, ...,ik) = conj(X(mod(N1-i1+1,N1)+1, mod(N2-i2+1,N2)+1, ... mod(Nk-ik+1,Nk)+1))

for each element of `X`

.

`Y = ifftn(X,siz)`

pads `X`

with
zeros, or truncates `X`

, to create a multidimensional
array of size `siz`

before performing the inverse
transform. The size of the result `Y`

is `siz`

.

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

causes `ifftn`

to
treat `X`

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

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

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

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

without the argument `'nonsymmetric'`

.

`ifftn`

supports inputs of data types `double`

and `single`

.
If you call `ifftn`

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

, the output `y`

has the
same data type as the input `X`

.

Was this topic helpful?