Implementing the Fourier Rework Numerically in Python: A Step-by-Step Information

import numpy as np
import matplotlib.pyplot as plt

nu = 5 / 2
t1 = np.linspace(-8, 8, 1000)
t2 = np.linspace(-4, 4, 1000)

f = lambda t: np.exp(-t**2)
phi = lambda t: f

f_vals = f(t1)
phi_vals = phi(t2)

# Plot
fig, axs = plt.subplots(1, 2, figsize=(10, 4))

axs[0].plot(t1, f_vals, 'okay', linewidth=2)
axs[0].set_xlim(-8, 8)
axs[0].set_ylim(0, 1)
axs[0].set_title(r"$f
axs[0].grid(True)

axs[1].plot(t2, np.actual(phi_vals), 'b', label=r"$Re(phi)$", linewidth=2)
axs[1].plot(t2, np.imag(phi_vals), 'r', label=r"$Im(phi)$", linewidth=2)
axs[1].set_xlim(-4, 4)
axs[1].set_ylim(-1, 1)
axs[1].set_title(r"$phi
axs[1].legend()
axs[1].grid(True)

plt.tight_layout()
plt.present()

• The approximation obtained utilizing the left rectangle quadrature technique is periodic in nature.

  We observe that even when the perform f is not periodic, its Fourier rework approximation f̂ seems to be periodic.

  Actually, the perform Ŝₙ, obtained from the quadrature technique, is periodic with a interval given by:

This periodicity of Ŝₙ implies that it’s not attainable to compute the Fourier rework for all frequencies ν ∈ ℝ utilizing the quadrature technique when the parameters T and n are fastened.

Actually, it turns into unattainable to compute f̂(ν) precisely when

|ν| ≥ ν_max,

the place v = n/T represents the most frequency that may be resolved due to the periodic nature of Ŝₙ.

Because of this, in follow, to compute the Fourier rework for bigger frequencies, one should enhance both the time window (T) or the variety of factors (n).

Moreover, by evaluating the error in approximating f̂(ν) utilizing the left rectangle quadrature technique, we are able to present that the approximation is dependable at frequency ν when the next situation holds:

|ν| ≪ n/T or equivalently, (|ν|T)/n ≪ 1.

In line with Epstein (2005), when utilizing the Quick Fourier Rework (FFT) algorithm, it’s attainable to precisely compute the Fourier rework of a perform f for all frequencies ν ∈ ℝ, even when (|ν|T)⁄n is near 1, offered that f is piecewise steady and has compact help.

2.2 Computing the Fourier Rework at Frequency ν Utilizing the FFT Algorithm

On this part, we denote by Ŝₙ(ν) the approximation of the Fourier rework f̂(ν) of the perform f at some extent ν ∈ [−ν_max/2, ν_max/2], the place ν_max = n/T, that’s,

I now current the Fourier rework algorithm used to approximate f̂(ν).
I cannot go into the small print of the Quick Fourier Rework (FFT) algorithm on this article.
For a simplified clarification, I check with Balac (2011), and for a extra technical and complete remedy, to the authentic work by Cooley and Tukey (1965).

It is very important perceive that using the FFT algorithm to approximate the Fourier rework of a perform f relies on the end result established by Epstein (2005). This end result states that when Ŝₙ(ν) is evaluated on the frequencies v_j = j/T, for j = 0, 1, …, n − 1, it supplies a very good approximation of the continual Fourier rework f̂(ν).

Furthermore, Ŝₙ is understood to be periodic. This periodicity assigns a symmetric position to the indices j ∈ {0, 1, …, n − 1} and okay ∈ {−n/2, −n/2 + 1, …, −1}.

Actually, the values of the Fourier rework of f over the interval [−ν_max/2, ν_max/2] could be derived from the values of Ŝₙ on the factors ν_j = j/T, for j = 0, 1, …, n − 1, as follows:

the place we used the relation:

This relationship reveals that the Fourier rework Ŝₙ(j/T) could be computed for j = −n⁄2, …, n⁄2 − 1.

Furthermore, when n is an influence of two, the computation turns into considerably quicker (see Balac, 2011). This course of is named the Quick Fourier Rework (FFT).

To summarize, I’ve proven that the Fourier rework of the perform f could be approximated over the interval [−T⁄2, T⁄2] on the frequencies v_j = j/T, for j = −n/2, …, n/2 − 1, the place n = 2ᵐ for some integer m ≥ 0, by making use of the Quick Fourier Rework (FFT) algorithm as follows:

• Step 1: Assemble the finite sequence F of values
  f((2k − n)T/(2n)), for okay = 0, 1, …, n − 1.
• Step 2: Compute the discrete Fourier rework (DFT) of the sequence F utilizing the FFT algorithm, given by:

• Step 3: Reindex and symmetrize the values to span j = −n/2, …, −1.
• Step 4: Multiply every worth within the array by (T/n)(−1)^j-1, the place j ∈ {1, …, n}.

This course of yields an array representing the values of the Fourier rework f̂(νⱼ), with ν_j = j/T for j = −n⁄2, …, n⁄2 − 1.

The Python perform tffft under implements these steps to compute the Fourier rework of a given perform.

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

def tffft(f, T, n):
    """
    Calcule la transformée de Fourier approchée d'une fonction f à help dans [-T/2, T/2],
    en utilisant l’algorithme FFT.

    Paramètres
    ----------
    f : callable
        Fonction à transformer (doit être vectorisable avec numpy).
    T : float
        Largeur de la fenêtre temporelle (intervalle [-T/2, T/2]).
    n : int
        Nombre de factors de discrétisation (doit être une puissance de 2 pour FFT efficace).

    Retours
    -------
    tf : np.ndarray
        Valeurs approximées de la transformée de Fourier aux fréquences discrètes.
    freq_nu : np.ndarray
        Fréquences discrètes correspondantes (de -n/(2T) à (n/2 - 1)/T).
    """
    h = T / n
    t = -0.5 * T + np.arange(n) * h  # noeuds temporels
    F = f
    tf = h * (-1) ** np.arange(n) * fftshift(fft(F))  # TF approximée
    freq_nu = -n / (2 * T) + np.arange(n) / T              # fréquences ν_j = j/T

    return tf, freq_nu, t

The next program illustrates easy methods to compute the Fourier rework of the Gaussian perform f

# Parameters
a = 10
f = lambda t: np.exp(-a * t**2)
T = 10
n = 2**8  # 256

# Compute the Fourier rework utilizing FFT
tf, nu, t = tffft(f, T, n)

# Plotting
fig, axs = plt.subplots(1, 2, figsize=(7.24, 4.07), dpi=100)

axs[0].plot(t, f
axs[0].set_xlabel("time")
axs[0].set_title("Thought of Operate")
axs[0].set_xlim(-6, 6)
axs[0].set_ylim(-0.5, 1.1)
axs[0].grid(True)

axs[1].plot(nu, np.abs(tf), '-b', linewidth=3)
axs[1].set_xlabel("frequency")
axs[1].set_title("Fourier Rework utilizing FFT")
axs[1].set_xlim(-15, 15)
axs[1].set_ylim(-0.5, 1)
axs[1].grid(True)

plt.tight_layout()
plt.present()

The strategy I simply introduced makes it attainable to compute and visualize the Fourier rework of a perform f at discrete factors v_j = j/T, for j = −n/2, …, n/2 − 1, the place n is an influence of two.

These factors lie inside the interval [−n/(2T), n/(2T)].
Nevertheless, this technique doesn’t permit us to judge the Fourier rework at arbitrary frequencies ν that aren’t of the shape v_j = j/T.

To compute the Fourier rework of a perform f at a frequency ν that doesn’t match one of many sampled frequencies νⱼ, interpolation strategies can be utilized, akin to linear, polynomial, or spline interpolation.

On this article, we use the method proposed by Balac (2011), which depends on Shannon’s interpolation theorem to compute the Fourier rework of f at any frequency ν.

Utilizing Shannon’s Interpolation Theorem to Compute the Fourier Rework of a Operate f at a Level ν

What does Shannon’s theorem inform us?

It states that for a band-limited perform g — that’s, a perform whose Fourier rework ĝ is zero outdoors the interval [−B⁄2, B⁄2] — the perform g could be reconstructed from its samples gₖ = g(okay⁄B) for okay ∈ ℤ.

If we let ν_c be the smallest optimistic quantity such that ĝ(ν) is zero outdoors the interval [−2πν_c, 2πν_c], then the Shannon interpolation components applies.
For each t ∈ ℝ, and any optimistic actual quantity α ≥ 1/(2ν_c), we have now:

the place sinc(x) = sin(x)/x is the sinc perform (cardinal sine).

Balac (2011) reveals that when a perform f has a bounded help within the interval [−T⁄2, T⁄2], Shannon’s interpolation theorem can be utilized to compute its Fourier rework f̂(ν) for any ν ∈ ℝ.
That is performed by utilizing the values of the discrete Fourier rework Ŝₙ(νⱼ) for j = −n/2, …, (n/2 − 1).

By setting α = 1/T, Balac derives the next Shannon interpolation components, legitimate for all ν ∈ ℝ:

The next program illustrates easy methods to use Shannon’s interpolation theorem to compute the Fourier rework of a perform f at a given frequency ν.

To compute the Fourier rework at any frequency ν, we are able to use Shannon’s interpolation theorem.

The thought is to estimate the worth of the Fourier rework from its discrete samples obtained by the FFT.

The perform under, shannon, implements this interpolation technique in Python.

def shannon(tf, nu, T):
    """
    Approximates the worth of the Fourier rework of perform f at frequency 'nu'
    utilizing its discrete values computed from the FFT.

    Parameters:
    - tf : numpy array, discrete Fourier rework values (centered with fftshift) at frequencies j/T for j = -n/2, ..., n/2 - 1
    - nu : float, frequency at which to approximate the Fourier rework
    - T  : float, time window width used for the FFT

    Returns:
    - tfnu : approximation of the Fourier rework at frequency 'nu'
    """
    n = len(tf)
    tfnu = 0.0
    for j in vary(n):
        okay = j - n // 2  # correspond à l'indice j dans {-n/2, ..., n/2 - 1}
        tfnu += tf[j] * np.sinc(T * nu - okay)  # np.sinc(x) = sin(pi x)/(pi x) en numpy

    return tfnu

The following perform, fourier_at_nu, combines two steps.
It first computes the discrete Fourier rework of a perform utilizing the FFT (tffft), then applies Shannon interpolation to estimate the Fourier rework at a selected frequency ν.

This makes it attainable to judge the rework at any arbitrary level ν, not simply on the FFT sampling frequencies.

We will now take a look at our implementation utilizing a easy instance.
Right here, we outline a perform f

a = 0.5
f = lambda t: np.exp(-a * np.abs
fhat_exact = lambda nu: (2 * a) / (a**2 + 4 * np.pi**2 * nu**2)  # Actual Fourier rework

T = 40     # Time window
n = 2**10  # Variety of discretization factors

# Compute for nu = 3/T

nu = 3 / T

exact_value = fhat_exact(nu)
approx_value = fourier_at_nu(f, T, n, nu)
print(f"Actual worth at nu={nu}: {exact_value}")
print(f"Approximation at nu={nu}: {np.actual(approx_value)}")

# Compute for nu = pi/T

nu = np.pi / T

exact_value = fhat_exact(nu)
approx_value = fourier_at_nu(f, T, n, nu)
print(f"Actual worth at nu={nu}: {exact_value}")
print(f"Approximation at nu={nu}: {np.actual(approx_value)}")

Actual worth at ν = 3/T: 2.118347413776218  
Approximation at ν = 3/T: (2.1185707502943534)

Actual worth at ν = π/T: 2.0262491352594427  
Approximation at ν = π/T: (2.0264201680784835)