The general concern when it comes to mathematical physics and engineering mathematics is to transform equations into a coordinate system where the expressions analyze, unravel, and are tractable to computation and analysis. The infrastructure to solve this problem of coordinate transformation was introduced by J.B Joseph Fourier in the early 18th century to investigate the theory of heat where he put forward the concept of the Fourier Series.
Fourier Series is a way of approximating arbitrary function (f(x)
) as an infinite sum of sines and cosines of increasingly high frequency that provide an orthogonal basis for the space of solution functions.
The sine and cosine functions present as eigenfunctions of the heat equation. The specific frequencies provided present as eigenvalues that are done according to the geometry with the boundary conditions determining the amplitudes.
You will come across the terms Fourier Series and Fourier Transform frequently. The difference between them is that the Fourier series is an expansion of periodic signal as a linear combination of sines and cosines, while Fourier transform is the process or function used to convert signals from the time domain to frequency domain.
To vividly understand how Fourier Series works the way we use in complex situations, one must also understand the advanced topics of Heat equations, Fourier Series, Complex Fourier Series, Discrete Fourier Transform (DFT), Fast Fourier Transform (FFT), Quantum Fourier Transform, Fourier Transform Spectroscopy, etc. In this shot, we will only go through the basics to understand what Fourier Series is and how it is used.
In summary, the FFT has a more substantial and noteworthy role in shaping the modern world than any algorithm to date.
The Fourier Series function (f(x))
can be represented as a periodic function.
Any function is periodic with period L if it exhibits the same pattern after interval L along the X-axis.
The approximation of Fourier Series function
This is called the Fourier Series expansion of a function. Where $A_{0}$, $A_{k}$, $B_{k}$ are called Fourier Coefficients.
$A_{0}$ represents the area under function f(x)
in one time period (2*Pi
) and is scaled by time period, it represents the average value.
$A_{k}$ and $B_{k}$ represent the functions projected onto the particular cosine and sine wave.
Where, if,
f(x) is even, i.e., f(-x)=-f(x) then $B_{k}$s=0
f(x) is odd, i.e., f(-x)=f(x) then $A_{k}$s=0
For odd function with period 2L
:
For even function with Period 2L
:
Basically, what we aim to achieve while using the Fourier Series is to be able to draw the desired drawing by adding up a lot of waves with different oscillations (or) harmonic motions determined by periodic functions. There are basic waves that can be implemented and used to make other waves. The basic waves are:
In, this shot we will focus on Square waves.
In Python, we can make use of:
SciPy.Signal module
- to access Built-in piece wise continuous functions [square, sawtooth, etc.]SciPy.Integrate module
- use quad
for integration.math module
- to use math
for mathematical functions [sine, cosine, etc.]numPy module
- to use lambda
for defining functions.Python code for generating a square wave:
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import square
from scipy.integrate import quad
from math import* //import all function from math
x=np.arange(-np.pi,np.pi,0.001) //x axis has been chosen from –π to +π, value
//of 1 smallest square along x axis is 0.001
y=square(x) //defining square wave function 𝑦 =−1, 𝑓𝑜𝑟 − 𝜋 ≤ 𝑥 ≤ 0
//y= +1, 𝑓𝑜𝑟 0 ≤ 𝑥 ≤ 𝜋
//define fuction
fc=lambda x:square(x)*cos(i*x) //i :dummy index
fs=lambda x:square(x)*sin(i*x)
n=50 //max value of I, not taken infinity, better result with high value
An=[] // defining array
Bn=[]
sum=0
for i in range(n):
an=quad(fc,-np.pi,np.pi)[0]*(1.0/np.pi)
An.append(an)
for i in range(n):
bn=quad(fs,-np.pi,np.pi)[0]*(1.0/np.pi)
Bn.append(bn) //putting value in array Bn
for i in range(n):
if i==0.0:
sum=sum+An[i]/2
else:
sum=sum+(An[i]*np.cos(i*x)+Bn[i]*np.sin(i*x))
plt.plot(x,sum,'g')
plt.plot(x,y,'r--')
plt.title("fourier series for square wave")
plt.show()
The graph will look like:
Example: Square Wave
𝒇(𝒙) = {𝟎, −𝑳 ≤ 𝒙 ≤ 𝟎}
𝒇(𝒙) = {𝟏, 𝟎 ≤ 𝒙 ≤ 𝑳}
f(x) has period 2L
for L=0.5, Period=1
import matplotlib.pyplot as plt
from scipy.signal import square
L=1
x=np.arange(-L,L,0.001)
y=square(2*np.pi*x)
plt.plot(x,y,'r--')
plt.title("fourier series for square wave ")
plt.show()
The generated graph is: