This is machine translation

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

Note: This page has been translated by MathWorks. Please click here
To view all translated materials including this page, select Japan from the country navigator on the bottom of this page.

dsp.FFT System object

Discrete Fourier transform


The FFT object computes the discrete Fourier transform (DFT) of an input. The object uses one or more of the following fast Fourier transform (FFT) algorithms depending on the complexity of the input and whether the output is in linear or bit-reversed order:

  • Double-signal algorithm

  • Half-length algorithm

  • Radix-2 decimation-in-time (DIT) algorithm

  • Radix-2 decimation-in-frequency (DIF) algorithm

  • An algorithm chosen by FFTW [1] , [2]

To compute the DFT of an input:

  1. Define and set up your FFT object. See Construction.

  2. Call step to compute the DFT of the input according to the properties of dsp.FFT. The behavior of step is specific to each object in the toolbox.


Starting in R2016b, instead of using the step method to perform the operation defined by the System object™, you can call the object with arguments, as if it were a function. For example, y = step(obj,x) and y = obj(x) perform equivalent operations.


fft = dsp.FFT returns a FFT object, H, that computes the DFT of an N-D array. For column vectors or multidimensional arrays, the FFT object computes the DFT along the first dimension. If the input is a row vector, the FFT object computes a row of single-sample DFTs and issues a warning.

H = dsp.FFT('PropertyName',PropertyValue, ...) returns a FFT object, H, with each property set to the specified value.



FFT implementation

Specify the implementation used for the FFT as one of Auto | Radix-2 | FFTW. When you set this property to Radix-2, the FFT length must be a power of two.


Order of output elements relative to input elements

Designate order of output channel elements relative to order of input elements. Set this property to true to output the frequency indices in bit-reversed order. The default is false, which corresponds to a linear ordering of frequency indices.


Divide butterfly outputs by two

Set this property to true if the output of the FFT should be divided by the FFT length. This option is useful when you want the output of the FFT to stay in the same amplitude range as its input. This is particularly useful when working with fixed-point data types.

The default value of this property is false with no scaling.


Source of FFT length

Specify how to determine the FFT length as Auto or Property. When you set this property to Auto, the FFT length equals the number of rows of the input signal. The default is Auto.


FFT length

Specify the FFT length. This property applies when you set the FFTLengthSource property to Property. The default is 64.

This property must be a power of two when the input is a fixed-point data type, or when you set the BitReversedOutput property to true, or when you set the FFTImplementation property to Radix-2.


Boolean value of wrapping or truncating input

Wrap input data when FFT length is shorter than input length. If this property is set to true, modulo-length data wrapping occurs before the FFT operation, given FFT length is shorter than the input length. If this property is set to false, truncation of the input data to the FFT length occurs before the FFT operation. The default is true.

 Fixed-Point Properties


stepDiscrete Fourier transform of input
Common to All System Objects

Create System object with same property values


Expected number of inputs to a System object


Expected number of outputs of a System object


Check locked states of a System object (logical)


Allow System object property value changes


expand all

Find frequency components of a signal in additive noise.

Note: This example runs only in R2016b or later. If you are using an earlier release, replace each call to the function with the equivalent step syntax. For example, myObject(x) becomes step(myObject,x).

Fs = 800; L = 1000;
t = (0:L-1)'/Fs;
x = sin(2*pi*250*t) + 0.75*cos(2*pi*340*t);
y = x + .5*randn(size(x)); % noisy signal
ft = dsp.FFT('FFTLengthSource', 'Property', ...
    'FFTLength', 1024);
Y = ft(y);

Plot the single-sided amplitude spectrum

plot(Fs/2*linspace(0,1,512), 2*abs(Y(1:512)/1024));
title('Single-sided amplitude spectrum of noisy signal y(t)');
xlabel('Frequency (Hz)'); ylabel('|Y(f)|');

Compute the FFT of a noisy sinusoidal input signal. The energy of the signal is stored as the magnitude square of the FFT coefficients. Determine the FFT coefficients which occupy 99.99% of the signal energy and reconstruct the time-domain signal by taking the IFFT of these coefficients. Compare the reconstructed signal with the original signal.

Note: If you are using R2016a or an earlier release, replace each call to the object with the equivalent step syntax. For example, obj(x) becomes step(obj(x).

Consider a time-domain signal , which is defined over the finite time interval . The energy of the signal is given by the following equation:

FFT Coefficients, are considered as signal values in the frequency domain. The energy of the signal in the frequency-domain is hence the sum of the squares of the magnitude of the FFT coefficients:

According to Parseval's theorem, the total energy of the signal in time or frequency-domain is the same.


Initialize a dsp.SineWave System object to generate a sine wave sampled at 44.1 kHz and has a frequency of 1000 Hz. Construct a dsp.FFT and dsp.IFFT objects to compute the FFT and the IFFT of the input signal.

The 'FFTLengthSource' property of each of these transform objects is set to 'Auto'. The FFT length is hence considered as the input frame size. The input frame size in this example is 1020, which is not a power of 2. Hence, select the 'FFTImplementation' as 'FFTW'.

L = 1020;
Sineobject = dsp.SineWave('SamplesPerFrame',L,'PhaseOffset',10,...
ft = dsp.FFT('FFTImplementation','FFTW');
ift = dsp.IFFT('FFTImplementation','FFTW','ConjugateSymmetricInput',true);


Stream in the noisy input signal. Compute the FFT of each frame and determine the coefficients which constitute 99.99% energy of the signal. Take IFFT of these coefficients to reconstruct the time-domain signal.

numIter = 1000;
for Iter = 1:numIter
    Sinewave1 = Sineobject();
    Input = Sinewave1 + 0.01*randn(size(Sinewave1));
    FFTCoeff = ft(Input);
    FFTCoeffMagSq = abs(FFTCoeff).^2;
    EnergyFreqDomain = (1/L)*sum(FFTCoeffMagSq);
    [FFTCoeffSorted, ind] = sort(((1/L)*FFTCoeffMagSq),1,'descend');
    CumFFTCoeffs = cumsum(FFTCoeffSorted);
    EnergyPercent = (CumFFTCoeffs/EnergyFreqDomain)*100;
    Vec = find(EnergyPercent > 99.99);
    FFTCoeffsModified = zeros(L,1);
    FFTCoeffsModified(ind(1:Vec(1))) = FFTCoeff(ind(1:Vec(1)));
    ReconstrSignal = ift(FFTCoeffsModified);

99.99% of the signal energy can be represented by the number of FFT coefficients given by Vec(1):

ans = 296

The signal is reconstructed efficiently using these coefficients. If you compare the last frame of the reconstructed signal with the original time-domain signal, you can see that the difference is very small and the plots match closely.

ans = 0.0431
hold on;
hold off;


This object implements the algorithm, inputs, and outputs described on the FFT block reference page. The object properties correspond to the block parameters.


[2] Frigo, M. and S. G. Johnson, “FFTW: An Adaptive Software Architecture for the FFT,”Proceedings of the International Conference on Acoustics, Speech, and Signal Processing, Vol. 3, 1998, pp. 1381-1384.

Extended Capabilities

See Also

System Objects

Introduced in R2012a

Was this topic helpful?