SciPy - ifft() Function

This function is used to calculate the 1-D n-point discrete Fourier transform.

Syntax

The syntax for the Scipy ifft() method is as follows −

.ifft(x, n=None, axis=-1, norm=None, overwrite_x=False, workers=None, *, plan=None)

Parameters

This method accepts the following parameters −

• x (array_like) − Input array in the frequency domain to be transformed back into the time domain. Can be complex or real.

• n (int, optional) − Length of the transformed axis. If n is larger than the input, the array is zero-padded. If smaller, the array is truncated. Default is the length of the input.

• axis (int, optional) − Axis along which the IFFT is performed. Default is -1 (the last axis).

• norm ("backward", "ortho", "forward", optional) − The normalization mode for IFFT allows control over scaling: "backward" (default, no scaling), "ortho" (unitary scaling for energy preservation), and "forward" (scales the output by 1/n, where n is the transform length).

• overwrite_x (bool, optional) − If True, allows the input array x to be overwritten for improved performance. Default is False.

• workers (int, optional) − Number of parallel workers to use for computation. Default is None, which means a single thread is used. Use a higher value for faster computation with large arrays.

• plan (optional) − Precomputed plan for FFT optimization (advanced use). Default is None.

Return Value

y (ndarray) − The result of the inverse FFT, which is the reconstructed signal in the time domain. The output is complex, even if the input is real.

Example 1

The ifft() metho reconstructs the time-domain signal from its frequency-domain representation. This example demonstrates the basic usage of ifft() to transform data back to the time domain.

import numpy as np
from scipy.fft import ifft

# Frequency domain signal
freq_data = np.array([4, 2+1j, 0, 2-1j])

# Compute the inverse FFT
time_data = ifft(freq_data)

print("Time-domain signal:", time_data)

When we run above program, it produces following result

Time-domain signal: [2. +0.j 0.5+0.j 0. +0.j 1.5+0.j]

Example 2

import numpy as np
from scipy.fft import ifft

# Frequency domain signal
freq_data = np.array([1, 2, 3])

# Compute the inverse FFT with zero-padding
time_data = ifft(freq_data, n=6)

print("Zero-padded time-domain signal:", time_data)

Following is an output of the above code −

Zero-padded time-domain signal: [ 1.        -0.j          0.08333333+0.72168784j -0.25      -0.14433757j
  0.33333333-0.j         -0.25      +0.14433757j  0.08333333-0.72168784j]

Example 3

import numpy as np
from scipy.fft import fft, ifft

# Original time-domain signal
time_data = np.array([1, 2, 3, 4])

# Transform to frequency domain and back to time domain
freq_data = fft(time_data)
reconstructed_data = ifft(freq_data)

print("Original signal:", time_data)
print("Reconstructed signal:", reconstructed_data)

Output of the above code is as follows −

Original signal: [1 2 3 4]
Reconstructed signal: [1.+0.j 2.+0.j 3.-0.j 4.+0.j]