TE COMPS

EXPERIMENT 4
Aim : To perform correlation of two discrete signals using graphical method.

Theory :

A signal operation similar to signal convolution, but with completely different

physical meaning, is signal correlation. The signal correlation operation can be
performed either with one signal (autocorrelation) or between two different
signals (crosscorrelation). Physically, signal autocorrelation indicates how the
signal energy (power) is distributed within the signal, and as such is used to
measure the signal power. Typical applications of signal autocorrelation are in
radar, sonar, satellite, and wireless communications systems. Devices that
measure signal power using signal correlation are known as signal correlators.
There are also many applications of signal crosscorrelation in signal
processing systems, especially when the signal is corrupted by another
undesirable signal (noise) so that the signal estimation (detection) from a
noisy signal has to be performed. Signal crosscorrelation can be also
considered as a measure of similarity of two signals.

Given two discrete-time real signals (sequences) and . The

autocorrelation and croosscorrelation functions are respectively defined by

where the parameter is any integer, .

Using the definition for the total discrete-time signal energy, we see that for
 , the autocorrelation function represents the total signal energy,
that is

Naturally, the autocorrelation and crosscorrelation sums are convergent under

assumptions that the signals and have finite total energy. It can

be observed that . In addition, it is easy to show

that the

autocorrelation function is an even function, that is

Hence, the autocorrelation function is symmetric with respect to the vertical

axis.

Also, it can shown that

Code :

import matplotlib.pyplot as plt

from tabulate import tabulate

def cross_corelate(x,y,x_start,y_start):

print("x(n) :",x)
print("x(n) origin:", x_start)

print("y(n) :",y)

print("y(n) origin:", y_start)

old_y = y[:]

y.reverse()

y_start = len(y) - y_start - 1

table = [['x(n)\\y(-n)',]+y,]

r_xy = [0]*(len(x) + len(y) - 1)

r_xy_start = max(x_start,y_start)

for i,x_i in enumerate(x):

row,s = [x_i,],0

for j,y_i in enumerate(y):

r_xy[i+j] += x_i*y_i

row.append(x_i*y_i)

table.append(row)

print("y(-n) :",y)

print("y(-n) origin:", y_start)

print("\nTable:")

print(tabulate(table, headers="firstrow", tablefmt="pretty"))

print("\nr_xy(n) :", r_xy)

print("r_xy(n) origin:", r_xy_start)

plot_signals(x,y,r_xy,x_start,y_start,r_xy_start,"x(n)","y(-n)","r_xy")
print("-----------------------------------------------------\n\n\n\n")

print("y(n) :",y)

print("y(n) origin:", y_start)

print("x(n) :",x)

print("x(n) origin:", x_start)

x.reverse()

x_start = len(x) - x_start - 1

y = old_y

y_start = len(y) - y_start - 1

table = [['y(n)\\x(-n)',]+x,]

r_yx = [0]*(len(x) + len(y) - 1)

r_yx_start = max(x_start,y_start)

for j,y_i in enumerate(y):

row,s = [y_i,],0

for i,x_i in enumerate(x):

r_yx[i+j] += x_i*y_i

row.append(x_i*y_i)

table.append(row)
 print("x(-n) :",x)

print("x(-n) origin:", x_start)

print("\nTable:")

print(tabulate(table, headers="firstrow", tablefmt="pretty"))

print("\nr_yx(n) :", r_yx)

print("r_yx(n) origin:", r_yx_start)

plot_signals(y,x,r_xy,y_start,x_start,r_xy_start,"y(n)","x(-n)","r_yx")

print("-----------------------------------------------------\n\n\n\n")

def auto_corelate(x,y,x_start,y_start):

x_rev = list(reversed(x))

x_rev_start = len(x) - x_start - 1

y_rev = list(reversed(y))

y_rev_start = len(y) - y_start - 1

print("x(n) :",x)

print("x(n) origin:", x_start)

print("x(-n) :",x_rev)

print("x(-n) origin:", x_rev_start)

table = [['x(n)\\x(-n)',]+x_rev,]

r_xx = [0]*(len(x) + len(x_rev) - 1)

r_xx_start = max(x_start,x_rev_start)
for i,x_i in enumerate(x):

row,s = [x_i,],0

for j,y_i in enumerate(x_rev):

r_xx[i+j] += x_i*y_i

row.append(x_i*y_i)

table.append(row)

print("\nTable:")

print(tabulate(table, headers="firstrow", tablefmt="pretty"))

print("\nr_xx(n) :", r_xx)

print("r_xx(n) origin:", r_xx_start)

plot_signals(x,x_rev,r_xx,x_start,x_rev_start,r_xx_start,"x(n)","x(-n)","r_xx")

print("-----------------------------------------------------\n\n\n\n")

print("y(n) :",y)

print("y(n) origin:", y_start)

print("y(-n) :",y_rev)

print("y(-n) origin:", y_rev_start)

table = [['y(n)\\y(-n)',]+y_rev,]

r_yy = [0]*(len(y) + len(y_rev) - 1)

r_yy_start = max(y_start,y_rev_start)

for i,x_i in enumerate(y):

 row,s = [x_i,],0

for j,y_i in enumerate(y_rev):

r_yy[i+j] += x_i*y_i

row.append(x_i*y_i)

table.append(row)

print("\nTable:")

print(tabulate(table, headers="firstrow", tablefmt="pretty"))

print("\nr_yy(n) :", r_yy)

print("r_yy(n) origin:", r_yy_start)

plot_signals(y,y_rev,r_yy,y_start,y_rev_start,r_yy_start,"y(n)","y(-n)","r_yy")

print("-----------------------------------------------------\n\n\n\n")

def plot_signals(x,y,r,x_start,y_start,r_start,x_str,y_str,r_str):

x_ticks = list(range(-x_start,1,1)) + list(range(1,len(x) - x_start))

y_ticks = list(range(-y_start,1,1)) + list(range(1,len(y) - y_start))

r_ticks = list(range(-r_start,1,1)) + list(range(1,len(r) - r_start))

ax = plt.subplot(3,1,1)

plt.stem(x_ticks,x)

start, end = ax.get_ylim()

plt.yticks(range(int(start), int(end+1)))

plt.xticks(x_ticks)

plt.title(x_str)

ax = plt.subplot(3,1,2)

plt.stem(y_ticks,y)
 start, end = ax.get_ylim()

plt.yticks(range(int(start), int(end+1)))

plt.xticks(y_ticks)

plt.title(y_str)

ax = plt.subplot(3,1,3)

plt.stem(r_ticks,r)

start, end = ax.get_ylim()

plt.yticks(range(int(start), int(end+1)))

plt.xticks(r_ticks)

plt.title(r_str)

plt.tight_layout()

plt.show()

cross_corelate([3,3,4,5],[2,6,2],0,0)

auto_corelate([3,3,4,5],[2,6,2],0,0)

Output :
Conclusion :

 Learnt and performed auto correlation and cross correlation using

python and used matplot function to plot the graphs.