# 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.

# dsp.IFFT System object

Package: dsp

Inverse discrete Fourier transform (IDFFT)

## Description

The `IFFT` object computes the inverse discrete Fourier transform (IDFFT) of the 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

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

To compute the IFFT of the input:

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

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

 Note:   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.

## Construction

`ift = dsp.IFFT` returns an `IFFT` object, `ift`, that computes the IDFT of a column vector or N-D array. For column vectors or N-D arrays, the `IFFT` object computes the IDFT along the first dimension of the array. If the input is a row vector, the `IFFT` object computes a row of single-sample IDFTs and issues a warning.

```ift = dsp.IFFT('PropertyName',PropertyValue, ...)``` returns an `IFFT` object, `ift`, with each property set to the specified value.

## Properties

 `FFTImplementation` 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. `BitReversedInput` Enable bit-reversed order interpretation of input elements Set this property to`true` if the order of Fourier transformed input elements to the `IFFT` object are in bit-reversed order. This property applies only when the `FFTLengthSource` property is `Auto`. The default is `false`, which denotes linear ordering. `ConjugateSymmetricInput` Enable conjugate symmetric interpretation of input Set this property to `true` if the input is conjugate symmetric to yield real-valued outputs. The discrete Fourier transform of a real valued sequence is conjugate symmetric, and setting this property to `true` optimizes the IDFT computation method. Setting this property to `false` for conjugate symmetric inputs may result in complex output values with nonzero imaginary parts. This occurs due to rounding errors. Setting this property to `true` for nonconjugate symmetric inputs results in invalid outputs. This property applies only when the`FFTLengthSource` property is `Auto`. The default is `false`. `Normalize` Enable dividing output by FFT length Specify whether to divide the IFFT output by the FFT length. The default is `true` and each element of the output is divided by the FFT length. `FFTLengthSource` 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. This property applies only when both the `BitReversedInput` and `ConjugateSymmetricInput` properties are `false`. The default is `Auto`. `FFTLength` FFT length Specify the FFT length as a numeric scalar. This property applies when you set the `BitReversedInput` and `ConjugateSymmetricInput` properties to `false`, and 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 `FFTImplementation` property to `Radix-2`. When you set the `FFT implementation` property to `Radix-2`, or when you set the `BitReversedOutput` property to `true`, this value must be a power of two. `WrapInput` Boolean value of wrapping or truncating input Wrap input data when `FFTLength` is shorter than input length. If this property is set to true, modulo-length data wrapping occurs before the FFT operation, given `FFTLength` is shorter than the input length. If this property is set to false, truncation of the input data to the `FFTLength` occurs before the FFT operation. The default is `true`.

## Methods

 step Inverse discrete Fourier transform of input
Common to All System Objects
`clone`

Create System object with same property values

`getNumInputs`

Expected number of inputs to a System object

`getNumOutputs`

Expected number of outputs of a System object

`isLocked`

Check locked states of a System object (logical)

`release`

Allow System object property value changes

## Examples

expand all

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).

This example analyzes the energy content in a sequence.

``` Fs = 40; L = 128; t = (0:L-1)'/Fs; x = sin(2*pi*10*t) + 0.75*cos(2*pi*15*t); y = x + .5*randn(size(x)); % noisy signal ft = dsp.FFT; ift = dsp.IFFT('ConjugateSymmetricInput', true); X = ft(x); [XX, ind] = sort(abs(X),1,'descend'); XXn = sqrt(cumsum(XX.^2))/norm(XX); ii = find(XXn > 0.999, 1); disp('Number of FFT coefficients that represent 99.9% ') disp(['of the total energy in the sequence: ', num2str(ii)]); XXt = zeros(128,1); XXt(ind(1:ii)) = X(ind(1:ii)); xt = ift(XXt); ```
```Number of FFT coefficients that represent 99.9% of the total energy in the sequence: 4 ```

Verify that the reconstructed signal matches the original signal.

``` norm(x-xt) ```
```ans = 1.2012e-13 ```

## Algorithms

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

 Output sampling mode parameter is not supported by `dsp.IFFT`.

## References

[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.