Documentation

# fftn

N-D fast Fourier transform

## Syntax

``Y = fftn(X)``
``Y = fftn(X,sz)``

## Description

example

````Y = fftn(X)` returns the multidimensional Fourier transform of an N-D array using a fast Fourier transform algorithm. The N-D transform is equivalent to computing the 1-D transform along each dimension of `X`. The output `Y` is the same size as `X`.```

example

````Y = fftn(X,sz)` truncates `X` or pads `X` with trailing zeros before taking the transform according to the elements of the vector `sz`. Each element of `sz` defines the length of the corresponding transform dimensions. For example, if `X` is a 5-by-5-by-5 array, then `Y = fftn(X,[8 8 8])` pads each dimension with zeros resulting in an 8-by-8-by-8 transform `Y`.```

## Examples

collapse all

You can use the `fftn` function to compute a 1-D fast Fourier transform in each dimension of a multidimensional array.

Create a 3-D signal `X`. The size of `X` is 20-by-20-by-20.

```x = (1:20)'; y = 1:20; z = reshape(1:20,[1 1 20]); X = cos(2*pi*0.01*x) + sin(2*pi*0.02*y) + cos(2*pi*0.03*z);```

Compute the 3-D Fourier transform of the signal, which is also a 20-by-20-by-20 array.

`Y = fftn(X);`

Pad `X` with zeros to compute a 32-by-32-by-32 transform.

```m = nextpow2(20); Y = fftn(X,[2^m 2^m 2^m]); size(Y)```
```ans = 1×3 32 32 32 ```

## Input Arguments

collapse all

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

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

Length of the transform dimensions, specified as a vector of positive integers. The elements of `sz` correspond to the transformation lengths of the corresponding dimensions of `X`. `length(sz)` must be at least `ndims(X)`.

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

collapse all

### N-D Fourier Transform

The discrete Fourier transform Y of an N-D array X is defined as

`${Y}_{{p}_{1},{p}_{2},...,{p}_{N}}=\sum _{{j}_{1}=0}^{{m}_{1}-1}{\omega }_{{m}_{1}}^{{p}_{1}{j}_{1}}\sum _{{j}_{2}=0}^{{m}_{2}-1}{\omega }_{{m}_{2}}^{{p}_{2}{j}_{2}}...\sum _{{j}_{N}}^{{m}_{N}-1}{\omega }_{{m}_{N}}^{{p}_{N}{j}_{N}}{X}_{{j}_{1},{j}_{2},...,{j}_{N}}.$`

Each dimension has length mk for k = 1,2,...,N, and ${\omega }_{{m}_{k}}={e}^{-2\pi i/{m}_{k}}$ are complex roots of unity where i is the imaginary unit.