# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

# 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 = 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 equal to `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.