Main Content

# dsp.IFFT

Inverse discrete Fourier transform (IDFT)

## Description

The `dsp.IFFT` System object™ computes the inverse discrete Fourier transform (IDFT) 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

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

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

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

To compute the IFFT of the input:

1. Create the `dsp.IFFT` object and set its properties.

2. Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?.

## Creation

### Syntax

``ift = dsp.IFFT``
``ift = dsp.IFFT(Name,Value)``

### Description

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

example

````ift = dsp.IFFT(Name,Value)` returns an `IFFT` object, `ift`, with each property set to the specified value. Enclose each property name in single quotes. Unspecified properties have default values.```

## Properties

expand all

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the `release` function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

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

Set this property to `true` if the order of Fourier transformed input elements to the `IFFT` object are in bit-reversed order. The default is `false`, which denotes linear ordering.

#### Dependencies

This property applies only when the `FFTLengthSource` property is `Auto`.

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.

#### Dependencies

This property applies only when the `FFTLengthSource` property is `Auto`.

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.

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.

#### Dependencies

This property applies only when both the `BitReversedInput` and `ConjugateSymmetricInput` properties are `false`.

Specify the FFT length as an integer greater than or equal to 2.

This property must be a power of two if any of these conditions apply:

• The input is a fixed-point data type.

• The FFTImplementation property is `Radix-2`.

#### Dependencies

This property applies when you set the `BitReversedInput` and `ConjugateSymmetricInput` properties to `false`, and the `FFTLengthSource` property to `'Property'`.

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

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.

### Fixed-Point Properties

Specify the rounding method.

Specify the overflow action as `Wrap` or `Saturate`.

Specify the sine table data type as `Same word length as input` or `Custom`.

Specify the sine table fixed-point type as an unscaled `numerictype` (Fixed-Point Designer) object with a `Signedness` of `Auto`.

#### Dependencies

This property applies when you set the `SineTableDataType` property to `Custom`.

Specify the product data type as `Full precision`, ```Same as input```, or `Custom`.

Specify the product fixed-point type as a scaled `numerictype` (Fixed-Point Designer) object with a `Signedness` of `Auto`.

#### Dependencies

This property applies when you set the `ProductDataType` property to `Custom`.

Specify the accumulator data type as `Full precision`, `Same as input`, `Same as product`, or `Custom`.

Specify the accumulator fixed-point type as a scaled `numerictype` (Fixed-Point Designer) object with a `Signedness` of `Auto`.

#### Dependencies

This property applies when you set the `AccumulatorDataType` property to `Custom`.

Specify the output data type as `Full precision`, ```Same as input```, or `Custom`.

Specify the output fixed-point type as a scaled `numerictype` (Fixed-Point Designer) object with a `Signedness` of `Auto`.

#### Dependencies

This property applies when you set the `OutputDataType` property to `Custom`.

## Usage

### Syntax

``y = ift(x)``

### Description

example

````y = ift(x)` computes the inverse discrete Fourier transform (IDFT) , `y`, of the input `x` along the first dimension of `x`.```

### Input Arguments

expand all

Data input, specified as a vector, matrix, or N-D array.

When the `FFTLengthSource` property is `Auto`, the length of `x` along the first dimension must be a positive integer power of two. When the `FFTLengthSource` property is `'Property'`, the length of `x` along the first dimension can be any positive integer and the `FFTLength` property must be a positive integer power of two.

Variable-size input signals are only supported when the `FFTLengthSource` property is set to `'Auto'`.

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

### Output Arguments

expand all

Inverse discrete Fourier transform of input signal, returned as a vector, matrix, or N-D array.

When `FFTLengthSource` property is set to `'Auto'`, the FFT length is same as the number of rows in the input signal. When `FFTLengthSource` property is set to `'Property'`, the FFT length is specified through the `FFTLength` property.

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

## Object Functions

To use an object function, specify the System object as the first input argument. For example, to release system resources of a System object named `obj`, use this syntax:

`release(obj)`

expand all

 `step` Run System object algorithm `release` Release resources and allow changes to System object property values and input characteristics `reset` Reset internal states of System object

## Examples

collapse all

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 $\mathit{x}\left[\mathit{n}\right]$, which is defined over the finite time interval $0\le \mathit{n}\le \mathit{N}-1$. The energy of the signal $\mathit{x}\left[\mathit{n}\right]$ is given by the following equation:

`${\mathit{E}}_{\mathit{N}}\text{\hspace{0.17em}}=\text{\hspace{0.17em}}{\sum }_{\mathit{n}=0}^{\mathit{N}-1}{|\mathit{x}\left[\mathit{n}\right]|}^{2}$`

FFT coefficients, $\mathit{X}\left[\mathit{k}\right]$, are considered signal values in the frequency domain. The energy of the signal $\mathit{x}\left[\mathit{n}\right]$ in the frequency-domain is therefore the sum of the squares of the magnitude of the FFT coefficients:

`${\mathit{E}}_{\mathit{N}}\text{\hspace{0.17em}}=\text{\hspace{0.17em}}\frac{1}{\mathit{N}}{\sum }_{\mathit{k}=0}^{\mathit{N}-1}{|\mathit{X}\left[\mathit{k}\right]|}^{2}$`

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

`${\mathit{E}}_{\mathit{N}}\text{\hspace{0.17em}}=\text{\hspace{0.17em}}{\sum }_{\mathit{n}=0}^{\mathit{N}-1}{|\mathit{x}\left[\mathit{n}\right]|}^{2}\text{\hspace{0.17em}}=\text{\hspace{0.17em}}\frac{1}{\mathit{N}}{\sum }_{\mathit{k}=0}^{\mathit{N}-1}{|\mathit{X}\left[\mathit{k}\right]|}^{2}\text{\hspace{0.17em}}$`

Initialization

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, so select the `'FFTImplementation'` as `'FFTW'`.

```L = 1020; Sineobject = dsp.SineWave('SamplesPerFrame',L,'PhaseOffset',10,... 'SampleRate',44100,'Frequency',1000); ft = dsp.FFT('FFTImplementation','FFTW'); ift = dsp.IFFT('FFTImplementation','FFTW','ConjugateSymmetricInput',true); rng(1);```

Streaming

Stream in the noisy input signal. Compute the FFT of each frame and determine the coefficients that 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); end```

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

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

`max(abs(Input-ReconstrSignal))`
```ans = 0.0431 ```
```plot(Input,'*'); hold on; plot(ReconstrSignal,'o'); hold off;```

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

## See Also

### Objects

Introduced in R2012a

Watch now