One dimensional discrete Fourier Transform

from scipy.fftpack import fft, ifft #Return discrete inverse Fourier transform of real or complex sequence.
x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])
y = fft(x) # fft Return discrete Fourier transform of real or complex sequence. 
y

yinv = ifft(y) #Return discrete inverse Fourier transform of real or complex sequence.
yinv

from scipy.fftpack import fftfreq
freq = fftfreq(8, 0.125)
freq

from scipy.fftpack import fft
# Number of sample points
N = 600
# sample spacing
T = 1.0 / 800.0
x = np.linspace(0.0, N*T, N)
a = np.sin(50.0 * 2.0*np.pi*x)
b = 0.5*np.sin(80.0 * 2.0*np.pi*x)
y = a+b
yf = fft(y)
xf = np.linspace(0.0, 1.0/(2.0*T), N//2)
import matplotlib.pyplot as plt
plt.plot(xf, 2.0/N * np.abs(yf[0:N//2]))
plt.grid()
plt.show()

The following example demonstrates a 2-dimensional inverse fast fourier transform.

from scipy.fftpack import ifftn
import matplotlib.pyplot as plt
import matplotlib.cm as cm
N = 30
f, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(2, 3, sharex='col', sharey='row')
xf = np.zeros((N,N))
xf[0, 5] = 1
xf[0, N-5] = 1
Z = ifftn(xf)
ax1.imshow(xf, cmap=cm.Reds)
ax4.imshow(np.real(Z), cmap=cm.gray)
xf = np.zeros((N, N))
xf[5, 0] = 1
xf[N-5, 0] = 1
Z = ifftn(xf)
ax2.imshow(xf, cmap=cm.Reds)
ax5.imshow(np.real(Z), cmap=cm.gray)
xf = np.zeros((N, N))
xf[5, 10] = 1
xf[N-5, N-10] = 1
Z = ifftn(xf)
ax3.imshow(xf, cmap=cm.Reds)
ax6.imshow(np.real(Z), cmap=cm.gray)
plt.show()

import numpy as np
from scipy import fftpack
import matplotlib.pyplot as plt

img = plt.imread('lion.png')
plt.figure()
plt.imshow(img)

# First a 1-D  Gaussian
t = np.linspace(-10, 10, 30)
bump = np.exp(-0.1*t**2)
bump /= np.trapz(bump) # normalize the integral to 1

# make a 2-D kernel out of it
kernel = bump[:, np.newaxis] * bump[np.newaxis, :]

kernel_ft = fftpack.fft2(kernel, shape=img.shape[:2], axes=(0, 1))

img_ft = fftpack.fft2(img, axes=(0, 1))

img2_ft = kernel_ft[:, :, np.newaxis] * img_ft # the 'newaxis' is to match to color direction
img2 = fftpack.ifft2(img2_ft, axes=(0, 1)).real

img2 = np.clip(img2, 0, 1) # clip values to range

# plot 
plt.figure()
plt.imshow(img2)

import matplotlib.pyplot as plt
from scipy.io import wavfile as wav
from scipy.fftpack import fft
import numpy as np

rate, data = wav.read('whistle.wav')
fft_out = fft(data)
%matplotlib inline
plt.plot(data, np.abs(fft_out))
#plt.axis([0,250,0,50000])
plt.show()

rate, data = wav.read('Movie-06.wav')
fft_out = fft(data)
%matplotlib inline
plt.plot(data, np.abs(fft_out))
plt.show()

#Solution 1
from numpy import fft
import numpy as np
import matplotlib.pyplot as plt
n = 1000 # Number of data points
dx = 5.0 # Sampling period (in meters)
x = dx*np.arange(0,n) # x coordinates
w1 = 100.0 # wavelength (meters)
w2 = 20.0 # wavelength (meters)
fx = np.sin(2*np.pi*x/w1) + 2*np.cos(2*np.pi*x/w2) # signal
Fk = fft.fft(fx)/n # Fourier coefficients (divided by n)
nu = fft.fftfreq(n,dx) # Natural frequencies
Fk = fft.fftshift(Fk) # Shift zero freq to center
nu = fft.fftshift(nu) # Shift zero freq to center
f, ax = plt.subplots(3,1,sharex=True)
ax[0].plot(nu, np.real(Fk)) # Plot Cosine terms
ax[0].set_ylabel(r'$Re[F_k]$', size = 'x-large')
ax[1].plot(nu, np.imag(Fk)) # Plot Sine terms
ax[1].set_ylabel(r'$Im[F_k]$', size = 'x-large')
ax[2].plot(nu, np.absolute(Fk)**2) # Plot spectral power
ax[2].set_ylabel(r'$\vert F_k \vert ^2$', size = 'x-large')
ax[2].set_xlabel(r'$\widetilde{\nu}$', size = 'x-large')
plt.show()

#solution 2

#2a. downloaded bowling.wav

#2b.
import matplotlib.pyplot as plt
from scipy.io import wavfile as wav
from scipy.fftpack import fft
import numpy as np
rate, data = wav.read('bowling.wav')
fft_out = fft(data)
%matplotlib inline
plt.plot(data, np.abs(fft_out))
plt.show()

#2c
#The plot displays the most prominent frequency in the file. This application of fft is used in sound editing and audio engineerine. One can pinpoint the highest frequency and cancel out the whitenoise. The white noise can be extracted to create a smaller file, such as an MP3.