Department of Electronics and Communication Engineering

MATLAB Laboratory
List of Experiments

S. No Experiment Name Page

No.
1. Operations on Signals and Sequences such as Addition, Multiplication, 2
Scaling, Shifting, Folding, Computation of Energy and Average Power
2. Finding the Even and Odd parts of Signal/Sequence and Real and Imaginary 7
parts of Signal
3. Verification of Linearity and Time Invariance Properties of a given 10
Continuous/Discrete System.
4. Computation of Unit sample, Unit step and Sinusoidal responses of the 14
given LTI system and verifying its physical realizability and stability
properties.
5. Convolution between Signals and sequences 17
6. Auto Correlation and Cross Correlation between Signals and Sequences 19
7. Gibbs Phenomenon 22
8. Finding the Fourier Transform of a given signal and plotting its magnitude 24
andphase spectrum.
9. Sampling Theorem Verification. 26

1
 Experiment No: 1
Basic Operations on Signals and sequences

AIM: perform the operations on signals and sequences such as addition,

multiplication, scaling, shifting, folding and also compute energy and power.

Software Required: Matlab software.

Theory:

Signal Addition
Addition: any two signals can be added to form a third signal, z (t) = x (t) + y (t)

Multiplication
Multiplication of two signals can be obtained by multiplying their values at every instant,
z(t) = x (t) y (t)

Time reversal/Folding
Time reversal of a signal x(t) can be obtained by folding the signal about t=0.Y(t)=y(-t)

Signal Amplification/Scaling : Y(n)=ax(n) if a < 1 attenuation

a >1 amplification

Time shifting:
The time shifting of x(n) obtained by delay or advance the signal in time by using
y(n)=x(n+k)
If k is a positive number, y(n) shifted to the right i e the shifting delays the signal
If k is a negative number, y(n ) it gets shifted left. Signal Shifting advances the signal

Energy:

Average power:

2
Program:
clc; clear all;close all;

% generating two input signals

t=0:.01:1;
x1=sin(2*pi*4*t) x2=sin(2*pi*8*t);
subplot(2,2,1); plot(t,x1);
xlabel('time'); ylabel('amplitude'); title('input signal 1');subplot(2,2,2);plot(t,x2);
xlabel('time'); ylabel('amplitude'); title('input signal 2');

% addition of signals

y1=x1+x2;
subplot(2,2,3);plot(t,y1);
xlabel('time');ylabel('amplitude'); title('addition of two signals');

% multiplication of signals
y2=x1.*x2;
subplot(2,2,4);plot(t,y2);
xlabel('time'); ylabel('amplitude'); title('multiplication of two signals');

% scaling of a signal1

A=2; y3=A*x1;
figure; subplot(2,2,1);plot(t,x1);
xlabel('time');ylabel('amplitude');title('input signal');
subplot(2,2,2);plot(t,y3);
xlabel('time');ylabel('amplitude'); title('amplified input signal');

% folding of a signal1
h=length(x1);
nx=0:h-1;
subplot(2,2,3) plot(nx,x1);
xlabel('nx');ylabel('amplitude');title('input signal');
y4=fliplr(x1); nf=-fliplr(nx);
subplot(2,2,4);plot(nf,y4);
xlabel('nf');ylabel('amplitude'); title('folded signal');

%shifting of a signal 1

figure; subplot(3,1,1);plot(t,x1);
xlabel('time t');ylabel('amplitude'); title('input signal');subplot(3,1,2); plot(t+2,x1);
xlabel('t+2');ylabel('amplitude'); title('right shifted signal');
subplot(3,1,3);plot(t-2,x1);
xlabel('t-2');ylabel('amplitude'); title('left shifted signal');

3
%operations on sequences

n1=1:1:9; s1=[1 2 3 0 5 8 0 2 4];

figure;subplot(2,2,1);stem(n1,s1);
xlabel('n1');ylabel('amplitude'); title('input sequence1');
s2=[1 1 2 4 6 0 5 3 6];
subplot(2,2,2);stem(n1,s2);
xlabel('n2');ylabel('amplitude'); title('input sequence2');

% addition of sequences
s3=s1+s2;
subplot(2,2,3);stem(n1,s3);
xlabel('n1');ylabel('amplitude');title('sum of two sequences');

% multiplication of sequences
s4=s1.*s2;
subplot(2,2,4);stem(n1,s4);
xlabel('n1');ylabel('amplitude'); title('product of two sequences');

% program for energy of a sequence

z1=input('enter the input sequence');
e1=sum(abs(z1).^2);
disp('energy of given sequence is');e1

% program for energy of a signal

t=0:pi:10*pi; z2=cos(2*pi*50*t).^2;
e2=sum(abs(z2).^2);
disp('energy of given signal is');e2

% program for power of a sequencep1=

(sum(abs(z1).^2))/length(z1);
disp('power of given sequence is');p1

% program for power of a signal

p2=(sum(abs(z2).^2))/length(z2);
disp('power of given signal is');
p2

OUTPUT:
enter the input sequence [1 3 2 4 1]
energy of given sequence is E = 31 Units
energy of given signal is = 4.0388 Units
power of given sequence is p1 = 6.2000
power of given signal is p2 = 0.3672

Result: Various operations on signals and sequences are performed.

4
Output:

5
6
 Experiment No-2
Even and odd parts of signal and sequence & Real and imaginary parts of Signal

AIM: Finding even and odd part of the signal and sequence and also find real and imaginary
parts of signal.

Software Required: Matlab software

Theory: One of characteristics of signal is symmetry that may be useful for signal analysis.
Even signals are symmetric around vertical axis, and Odd signals are symmetric about origin.

Even Signal: A signal is referred to as an even if it is identical to its time-reversed counterparts;

x(t) = x(-t).
Odd Signal:
A signal is odd if x(t) = -x(-t).
An odd signal must be 0 at t=0, in other words, odd signal passes the origin.
Using the definition of even and odd signal, any signal may be decomposed into a sum of its
even part, xe(t), and its odd part, xo(t), as follows

Even and odd part of a signal: Any signal x(t) can be expressed as sum of even and odd
components i.e ., x(t)=xe(t)+xo(t)

Program:
clc; close all; clear all;

% Even and odd parts of a signal

t=0:.001:4*pi;
x=sin(t)+cos(t); % x(t)=sint(t)+cos(t)
subplot(2,2,1) plot(t,x);
xlabel('t'); ylabel('amplitude'); title('input signal');

y=sin(-t)+cos(-t); % y(t)=x(-t)
subplot(2,2,2); plot(t,y);
xlabel('t'); ylabel('amplitude'); title('input signal with t= -t')
even=(x+y)/2;
subplot(2,2,3); plot(t,even);
xlabel('t'); ylabel('amplitude'); title('even part of the signal');
odd=(x-y)/2;
subplot(2,2,4); plot(t,odd);
xlabel('t'); ylabel('amplitude'); title('odd part of the signal');

% Even and odd parts of a sequence x1=[0,2,-3,5,-2,-1,6];

n=-3:3;
y1= fliplr(x1);%y1(n)=x1(-n) figure;
subplot(2,2,1); stem(n,x1);
xlabel('n'); ylabel('amplitude'); title('input sequence');
subplot(2,2,2); stem(n,y1);
7
xlabel('n'); ylabel('amplitude'); title('input sequence with n= -n');
even1=.5*(x1+y1);
odd1=.5*(x1-y1);

% plotting even and odd parts of the sequence

subplot(2,2,3); stem(n,even1);
xlabel('n'); ylabel('amplitude'); title('even part of sequence');
subplot(2,2,4); stem(n,odd1);
xlabel('n'); ylabel('amplitude'); title('odd part of sequence');

% plotting real and imginary parts of the signal x2=sin(t)+j*cos(t);

figure;
subplot(3,1,1); plot(t,x2);
xlabel('t'); ylabel('amplitude'); title('input signal');
subplot(3,1,2); plot(t,real(x2));
xlabel('time'); ylabel('amplitude'); title('real part of signal');
subplot(3,1,3); plot(t,imag(x2));
xlabel('time'); ylabel('amplitude'); title('imaginary part of siganl');

RESULT: Even and odd part of the signal and sequence, real and imaginary parts of signal are
computed.

Output:

8
9
 Experiment No-3(a)
Verification of Linearity of a Discrete System

AIM: Verify the Linearity of a given Discrete System.

Software Required: Matlab software 7.0 and above

Theory:
LINEARITY PROPERTY:
Any system is said to be linear if it satisfies the superposition principal. superposition
principal state that Response to a weighted sum of input signal equal to the corresponding
weighted sum of the outputs of the system to each of the individual input signals.

If x(n) is a input signal and y(n) is a output signal then

y(n)=T[x(n)]
y1(n)=T[x1(n)] and y2(n)=T[x2(n)]
x3=[a*x1(n) +b *x2(n) ]
Y3(n)= T [x3(n)]
T [a*x1(n)+b*x2(n) ] = a y1(n)+ b y2(n)
Program:
% Verification of Linearity of a given System.
% a) y(n)=nx(n) b) y=x^2(n)

clc; clear all;close all;

n=0:40;
a1=input('enter the scaling factor a1=');
a2=input('enter the scaling factor a2=');
x1=cos(2*pi*0.1*n); x2=cos(2*pi*0.4*n);x3=a1*x1+a2*x2;

%y(n)=n.x(n);

y1=n.*x1; y2=n.*x2; y3=n.*x3;

yt=a1*y1+a2*y2;
yt=round(yt); y3=round(y3);
if y3==yt
disp('given system [y(n)=n.x(n)]is Linear');else
disp('given system [y(n)=n.x(n)]is non Linear');
end
%y(n)=x(n).^2

x1=[1 2 3 4 5]; x2=[1 4 7 6 4]; x3=a1*x1+a2*x2;

y1=x1.^2; y2=x2.^2; y3=x3.^2;
yt=a1*y1+a2*y2;
if y3==yt
disp('given system [y(n)=x(n).^2 ]is Linear');else
disp('given system is [y(n)=x(n).^2 ]non Linear');
end

Result: The Linearity of a given Discrete System is verified.

10
Output:
enter the scaling factor a1=3
enter the scaling factor a2=5
given system [y(n)=n.x(n)]is Linear
given system is [y(n)=x(n).^2 ]non Linear

11
 Experiment No -3(b)

Theory:
TIME INVARIENT SYSTEMS(TI):

A system is called time invariant if its input – output characteristics do not change with

time X(t)---- input : Y(t) ---output

X(t-k) -----delay input by k seconds: Y(t-k) ------- Delayed output by k seconds
If Y(t)=T[X(t)] then Y(t-k)=T[X(t-k)] then system is time invariant system.

Program:

% Verification of Time Invariance of a Discrete System

% a)y=x^2(n) b) y(n)=nx(n)

clc; clear all;close all;

n=1:9;
x(n)=[1 2 3 4 5 6 7 8 9];
d=3; % time delay
xd=[zeros(1,d),x(n)];%x(n-k)
y(n)=x(n).^2;

yd=[zeros(1,d),y];%y(n-k)
disp('transformation of delay signal yd:');
disp(yd);

dy=xd.^2; % T[x(n-k)]

disp('delay of transformation signal dy:');disp(dy)

if dy==yd
disp('given system [y(n)=x(n).^2 ]is time invariant');
else
disp('given system is [y(n)=x(n).^2 ]not time invariant');
end

y=n.*x;
yd=[zeros(1,d),y(n)];
disp('transformation of delay signal yd:');
disp(yd);
n1=1:length(xd);
dy=n1.*xd;
disp('delay of transformation signal dy:');
disp(dy);
if yd==dy
disp('given system [y(n)=nx(n)]is a time invariant');
else;
disp('given system [y(n)=nx(n)]not a time invariant');
end

Result: The Time Invariance of a given Discrete System is verified.

12
Output:
transformation of delay signal yd: [0 0 0 1 4 9 16 25 36 49 64
81]
delay of transformation signal dy: [0 0 0 1 4 9 16 25 36 49 64 81]

Given system [y(n)=x(n).^2 ]is time invariant transformation of delay signal

yd: [0 0 0 1 4 9 16 25 36 49 64 81]
delay of transformation signal dy: [0 0 0 4 10 18 28 40 54 70 88 108]

Given system [y(n)=nx(n)] not a time invariant.

13
 Experiment No-4
Unit sample, unit step and sinusoidal response of the given LTI system and verifying its
stability
AIM: Compute the Unit sample, unit step and sinusoidal response of the given LTI
system and verifying its stability

Software Required: Matlab software 7.0 and above

Theory:
A discrete time system performs an operation on an input signal based on predefined
criteria to produce a modified output signal. The input signal x(n) is the system
excitation, and y(n) isthe system response. The transform operation is shown as,

If the input to the system is unit impulse i.e. x(n) = δ(n) then the output of the system is
known as impulse response denoted by h(n) where,

h(n) = T[δ(n)]

we know that any arbitrary sequence x(n) can be represented as a weighted sum of
discrete impulses. Now the system response is given by,

For linear system (1) reduces to

%given difference equation y(n)-y(n-1)+.9y(n-2)=x(n);

14
Program:

%given difference equation y(n)-y(n-1)+.9y(n-2)=x(n);

clc; clear all; close all;

b=[1]; a=[1,-1,.9];
n =0:3:100;

%generating impulse signal

x1=(n==0);

%impulse response

y1=filter(b,a,x1);subplot(3,1,1);stem(n,y1);
xlabel('n'); ylabel('y1(n)'); title('impulse response');

%generating step signal

x2=(n>0);

% step response

y2=filter(b,a,x2);subplot(3,1,2);stem(n,y2);
xlabel('n'); ylabel('y2(n)') title('step response');

%generating sinusoidal signal

t=0:0.1:2*pi;
x3=sin(t);

% sinusoidal response
y3=filter(b,a,x3);
subplot(3,1,3); stem(t,y3);
xlabel('n'); ylabel('y3(n)'); title('sin response');

% verifing stability
figure; zplane(b,a);

Result: The Unit sample, unit step and sinusoidal response of the given LTI system is
computed and its stability verified. Hence all the poles lie inside the unit circle, so
system is stable.

15
Output:

16
 Experiment No-5
Convolution between signals & sequences

Aim: Write the program for convolution between two signals and also between
twosequences.
Software Required: Matlab software
Theory:

Convolution involves the following operations.

1. Folding
2. Multiplication
3. Addition
4. Shifting
Y [n] = ∑+∞
𝑘=−∞ 𝑥[𝑘]. 𝛿(𝑛 − 𝑘)

These operations can be represented by a Mathematical Expression as follows:

x[n]= Input signal Samples
h[ n-k]= Impulse response co-
efficient.y[ n]= Convolution output.
n = No. of Input samples
h = No. of Impulse response co-efficient.
Example : X(n)={1 2 -1 0 1}, h(n)={ 1,2,3,-1}

Program:
clc; close all; clear all;

%program for convolution of two sequences

x=input('enter input sequence: ');

h=input('enter impulse response: ');
y=conv(x,h);
subplot(3,1,1);stem(x);
xlabel('n'); ylabel('x(n)'); title('input sequence');
subplot(3,1,2); stem(h);
xlabel('n'); ylabel('h(n)'); title('impulse response sequence');subplot(3,1,3); stem(y);
xlabel('n'); ylabel('y(n)'); title('linear convolution')
disp('linear convolution y=');
disp(y)

%program for signal convolution

t=0:0.1:10;
x1=sin(2*pi*t);h1=cos(2*pi*t);y1=conv(x1,h1);
figure;
subplot(3,1,1);plot(x1);
xlabel('t'); ylabel('x(t)'); title('input signal')
subplot(3,1,2); plot(h1);
17
xlabel('t');ylabel('h(t)'); title('impulse response')
subplot(3,1,3); plot(y1);
xlabel('n'); ylabel('y(n)'); title('linear convolution');

RESULT: Convolution between signals and sequences is computed.

Output:
enter input sequence: [1 3 4 5]
enter impulse response: [2 1 4]
Linear convolution y= [2 7 15 26 21 20]

18
 Experiment No-6
Auto correlation and Cross correlation

Aim: To compute Auto correlation and Cross correlation between signals and sequences.

Software Required: Matlab software

Theory:
Correlations of sequences:
It is a measure of the degree to which two sequences are similar. Given two real-valued
sequences x(n) and y(n) of finite energy,
Convolution involves the following operations.
1. Shifting
2. Multiplication
3. Addition
These operations can be represented by a Mathematical Expression as follows:

Cross correlation
rx,y = ∑+∞
−∞ 𝑥 (𝑛)𝑦(𝑛 − 𝑙)

Autocorrelation
Rx,x = ∑+∞
−∞ 𝑥 (𝑛)𝑥(𝑛 − 𝑙)
The index l is called the shift or lag parameter

Program:

clc; close all; clear all;

% two input sequences

x=input('enter input sequence');

h=input('enter the impulse sequence');
subplot(2,2,1); stem(x);
xlabel('n'); ylabel('x(n)');
title('input sequence');
subplot(2,2,2); stem(h);
xlabel('n'); ylabel('h(n)');
title('impulse sequence');

% cross correlation between two sequences

y=xcorr(x,h);
subplot(2,2,3) stem(y);
xlabel('n'); ylabel('y(n)');
title(' cross correlation between two sequences ');

% auto correlation of input sequence

z=xcorr(x,x);
subplot(2,2,4) stem(z);
19
xlabel('n'); ylabel('z(n)');
title('auto correlation of input sequence');

% cross correlation between two signals

% generating two input signals

t=0:0.2:10;
x1=3*exp(-2*t); h1=exp(t);
figure; subplot(2,2,1);plot(t,x1);
xlabel('t'); ylabel('x1(t)');
title('input signal');
subplot(2,2,2); plot(t,h1);
xlabel('t'); ylabel('h1(t)');
title('impulse signal');

% cross correlation

z1=xcorr(x1,h1); subplot(2,2,3);plot(z1);
xlabel('t'); ylabel('z1(t)');
title('cross correlation ');

% auto correlation

z2=xcorr(x1,x1);
subplot(2,2,4); plot(z2);
xlabel('t'); ylabel('z2(t)');
title('auto correlation ');

Result: Auto correlation and Cross correlation between signals and sequences is computed.

Output: enter input sequence [1 2 5 7]

enter the impulse sequence [2 6 0 5 3]

20
21
 Experiment No-7
Gibbs phenomenon

AIM: Verify the Gibbs phenomenon.

Software Required: Matlab software
Theory:
The Gibbs phenomenon, the Fourier series of a piecewise continuously differentiable
periodic function behaves at a jump discontinuity. The nth approximated function shows
amounts of ripples at the points of discontinuity. This is known as the Gibbs Phenomena.
partial sum of the Fourier series has large oscillations near the jump, which might
increase the maximum of the partial sum above that of the function itself. The overshoot
does not die out as the frequency increases, but approaches a finite limit
The Gibbs phenomenon involves both the fact that Fourier sums overshoot at a
jumpdiscontinuity, and that this overshoot does not die out as the frequency increases.

Program:

% Gibb's phenomenon.

clc;
clear all;
close all;
t=linspace(-2,2,2000);
u=linspace(-2,2,2000);
sq=[zeros(1,500),2*ones(1,1000),zeros(1,500)];k=2;
N=[1,3,7,19,49,70];
for n=1:6;an=[];
for m=1:N(n)
an=[an,2*k*sin(m*pi/2)/(m*p)];
end;
fN=k/2;
for m=1:N(n)
fN=fN+an(m)*cos(m*pi*t/2);
end;
nq=int2str(N(n)); subplot(3,2,n),
plot(u,sq,'r');
hold on;
plot(t,fN);
hold off;
axis([-2 2 -0.5 2.5]);
grid;
xlabel('Time');
ylabel('y_N(t)');
title(['N= ',nq]);
end;

Result: In this experiment Gibbs phenomenona have been demonstrated using MATLAB.

22
Output:

23
 Experiment No-8
Finding the Fourier Transform of a given signal and plotting its magnitude and phase
spectrum

AIM: To find the Fourier Transform of a given signal and plotting its magnitude and
phase spectrum.

Software Required: Matlab software

Theory:
Fourier Transform:
The Fourier transform as follows. Suppose that ƒ is a function which is zero outside of
some interval [−L/2, L/2]. Then for any T ≥ L we may expand ƒ in a Fourier series on the
interval [−T/2,T/2], where the "amount" of the wave e2πinx/T in the Fourier series of ƒ is
given by
+∞
By definition Fourier Transform of signal f(t) is defined as ∫−∞ 𝑓(𝑡)𝑒 −𝑖𝜔𝑡 𝑑𝑡
Inverse Fourier Transform of signal F(w) is defined as

Program:

clc; clear all;close all;

fs=1000;
N=1024; % length of fft sequence
t=[0:N-1]*(1/fs);
x=0.8*cos(2*pi*100*t); % input signal
subplot(3,1,1);plot(t,x);
axis([0 0.05 -1 1]); grid;
xlabel('t'); ylabel('amplitude'); title('input signal');

% Fourier transform of given signal

x1=fft(x);
% magnitude spectrum

k=0:N-1;
Xmag=abs(x1);
subplot(3,1,2); plot(k,Xmag); grid;
xlabel('t'); ylabel('amplitude'); title('magnitude of fft signal')

%phase spectrum
Xphase=angle(x1);
subplot(3,1,3);plot(k,Xphase);
grid; xlabel('t'); ylabel('angle'); title('phase of fft signal');

Result: Magnitude and phase spectrum of FFT of a given signal is plotted.

24
Output:

25
 Experiment No-09
Sampling Theorem Verification

AIM: Verify the sampling theorem.

Software Required: Matlab software
Theory:
Sampling Theorem:
A bandlimited signal can be reconstructed exactly if it is sampled at a rate atleast twice the
maximum frequency component in it." Figure 1 shows a signal g(t) that is bandlimited.

Figure 1: Spectrum of band limited signal g(t)

The maximum frequency component of g(t) is fm. To recover the signal g(t) exactly from its
samples it has to be sampled at a rate fs ≥ 2fm.
The minimum required sampling rate fs = 2fm is called ' Nyquist rate

Proof: Let g(t) be a bandlimited signal whose bandwidth is fm (wm = 2πfm).

Figure 2: (a) Original signal g(t) (b) Spectrum G(w)δ (t) is the sampling signal with fs = 1/T > 2fm.

Figure 3: (a) sampling signal δ (t) ) (b) Spectrum δ (w)

Figure 4: (a) sampled signal26gs(t) (b) Spectrum Gs(w)

To recover the original signal G(w):
1. Filter with a Gate function, H2wm(w) of width 2wmScale
it by T.

Figure 5: Recovery of signal by filtering with a fiter of width 2wm Aliasing ws < 2wm.

Figure 6: Aliasing due to inadequate sampling

Aliasing leads to distortion in recovered signal. This is the reason why sampling frequency
should be atleast twice thebandwidth of the signal. Oversampling ws >2wm. This condition
avoid aliasing.

Figure 7 : Oversampled signal-avoids aliasing

Program:

clc; clear all;close all;

t=-10:.01:10;T=4;
fm=1/T;
x=cos(2*pi*fm*t);
subplot(2,2,1);plot(t,x);
xlabel('time'); ylabel('x(t)'); title('continous time signal');
grid;
n1=-4:1:4;
fs1=1.6*fm;fs2=2*fm; fs3=8*fm;
x1=cos(2*pi*fm/fs1*n1);
27
subplot(2,2,2); stem(n1,x1);
xlabel('time'); ylabel('x(n)'); title('discrete time signal with fs<2fm');
hold on;
subplot(2,2,2); plot(n1,x1);
grid;
n2=-5:1:5;
x2=cos(2*pi*fm/fs2*n2);
subplot(2,2,3); stem(n2,x2);
xlabel('time'); ylabel('x(n)'); title('discrete time signal with fs=2fm');
hold on;
subplot(2,2,3);plot(n2,x2);
grid;
n3=-20:1:20;
x3=cos(2*pi*fm/fs3*n3);
subplot(2,2,4); stem(n3,x3);
xlabel('time'); ylabel('x(n)'); title('discrete time signal with fs>2fm');
hold on;
subplot(2,2,4);plot(n3,x3);
grid;

Result: Sampling theorem is verified.

OUTPUT:

28