EXPERIMENT-1

TITLE OF THE EXPERIMENT:

Implement and verify linear and circular convolution between two given signals.
LINEAR CONVOLUTION
1. AIM: To write a program in MATLAB to compute the response of a discrete LTI
system with input sequence x(n) and impulse response h(h) by using linear
convolution.
2. SOFTWARE REQUIRED: MATLAB
3. THEORY:
Linear convolution is a mathematical operation commonly used in signal
processing, mathematics, and various fields of science and engineering. It
involves combining two sequences, typically represented as functions or
vectors, to produce a third sequence that represents the result of a particular
operation. Linear convolution is often used in the context of discrete signals,
where the sequences are typically finite and discrete.
Convolution Operation:
Given two discrete sequences, usually denoted as (x[n]) and (h[n]), linear
convolution is defined as follows:
y[n] = x[n] * h[n]
Here, (y[n]) represents the convolution result, and (*) denotes the convolution
operation.
∞

𝒚[𝒏] = ∑ 𝒙[𝒌]𝒉[𝒏 − 𝒌]
𝒌=−∞

Convolution has several important properties, including linearity, time-

invariance, and associativity. These properties make it a fundamental operation
in signal processing and linear systems theory.
Linear convolution is widely used in various applications, including image
processing, audio processing, communication systems, and solving differential
equations numerically.
4. PROGRAM CODE:
clc;
clearall;
close;
disp(‘Enter the length of the first sequence m= ‘);
m=input(‘ ‘);
 disp(‘Enter the values of the first sequence x[m]= ‘);
for i=1:m
x[i]=input(‘ ‘);
end
disp(‘Enter the length of the second sequence n= ‘);
n=input(‘ ‘);
disp(‘Enter the values of the second sequence h[n]= ‘);
for j=1:n
h[j]=input(‘ ‘);
end
y= conv(x,h);
figure;
subplot(3,1,1);
stem(x);
ylabel(‘amplitude-->’);
xlabel(‘n-->’);
title(‘x[n] vs n’);
subplot(3,1,2);
stem(h);
ylabel(‘amplitude-->’);
xlabel(‘n-->’);
title(‘h[n] vs n’);
subplot(3,1,3);
stem(y);
ylabel(‘amplitude-->’);
xlabel(‘n-->’);
title(‘y[n] vs n’);
disp(‘linear convolution of x[m] and h[n] is y=’);
5. OUTPUT:
Enter the length of the first sequence m=
4
Enter the values of the first sequence x[m]=
1
2
3
4
Enter the length of the second sequence n=
4
Enter the values of the second sequence h[n]=
1
2
 1
2
linear convolution of x[m] and h[n] is y=1 4 8 14 15 10 8
6. OUTPUT PLOT:

7. ANALYSIS:
Linear convolution is the most common form of convolution used in signal
processing. It operates on two input sequences often represented as vectors.
The operation involves multiplying corresponding elements of the two input
sequences and summing up the results. The output sequence length is the sum
of the lengths of two input sequence minus one.
8. PRECAUTIONS:
 Add comments within the code to clarify complex DSP operations.
 Ensure proper scaling and units for signals and parameters to maintain
accuracy.
9. RESULT:
Hence performed linear convolution of discrete LTI system with input sequence
x[n] and impulse response h[n] and observed the response.
10. APPLICATIONS:
 Filtering
 Image, audio and speech processing
 System identification
 CIRCULAR CONVOLUTION
1. AIM: To write a program in MATLAB to compute the response of a discrete LTI
system with input sequence x(n) and impulse response h(h) by using linear
convolution.
2. SOFTWARE REQUIRED: MATLAB
3. THEORY:
Circular convolution is a mathematical operation that extends the concept of
convolution to cyclic or periodic signals. Unlike linear convolution, which
typically operates on finite-length signals, circular convolution is used for
signals that repeat periodically. It's especially common in digital signal
processing and communication systems where periodicity plays a significant
role.
Circular convolution is suitable for signals that are periodic in nature. This
means that the signal repeats itself after a certain number of samples. For
example, a sine wave or a periodic waveform in a digital system can be
considered a periodic signal.
Circular convolution, denoted as x[n] ʘ h[n] is defined as follows:
y[n]= x[n] ʘ h[n]
Here, (y[n]) represents the circular convolution result, and (ʘ) denotes the
circular convolution operation.
The circular convolution of two sequences (x[n]) and (h[n]) is computed using
modulo arithmetic:
y[n]= ∑𝑁−1
𝑘=0 𝒙[𝒌]𝒉[𝒏 − 𝒌]𝒎𝒐𝒅(𝑵)
Here, (N) is the period of the signals, and (mod) represents the modulo
operation. The modulo operation ensures that the convolution operation
"wraps around" when it reaches the end of the signal.
Circular convolution is commonly used in applications where signal periodicity
is a consideration. This includes applications in digital communication systems,
where signals may be sent repeatedly, and in the analysis of periodic
waveforms, such as the Fourier analysis of periodic signals.
Systems that exhibit circular convolution in their operation are called cyclically
convolved systems. These systems are characterized by having feedback
loops or periodic structures.
4. PROGRAM CODE:
x=input(‘Enter the input sequence x[n]=’);
h=input(‘Enter the impulse response sequence h[n]=’);
N1=length(x);
N2=length(h);
L=N1+N2-1;
n=[Link]L-1;
zpx=[xzeros(1,L-N1)];
 disp(‘Input sequence after zero padding:: x[n]: ‘);
disp(zpx);
zph=[hzeros(1,L-N2)];
disp(‘Impulse response after zero padding:: h[n]: ‘);
disp(zph);
X=fft(zpx);
H=fft(zph);
y=ifft(XʘH);
disp(‘Response of discrete LTI system:: y[n]: ‘);
disp(y);
disp(‘ press “ENTER” for zero padded x[n]’);
pause
subplot(2,2,1);
stem(n,zpx);
title(‘Input sequence after zero padding’);
xlabel(‘Discrete Time’);
ylabel(‘Amplitude’);
disp(‘ press “ENTER” for zero padded h[n]’);
pause
n=[Link]L-1;
subplot(2,2,2);
stem(n,zph);
title(‘Impulse response after zero padding’);
xlabel(‘Discrete Time’);
ylabel(‘Amplitude’);
disp(‘ press “ENTER” for response of the system’);
pause
n=[Link]L-1;
subplot(2,2,3);
stem(n,y);
title(‘Response of discrete LTI system’);
xlabel(‘Discrete Time’);
ylabel(‘Amplitude’);
5. OUTPUT:
Enter the input sequence x[n]=
[1 2 3 4]
Enter the impulse response sequence h[n]=
[1 2 1 2]
Input sequence after zero padding:: x[n]:
1 2 3 4 0 0 0
Impulse response after zero padding:: h[n]:
1 2 1 2 0 0 0
 Response of discrete LTI system:: y[n]:
1.0000 4.0000 8.0000 14.0000 15.0000 10.0000 8.0000

press “ENTER” for zero padded x[n]

press “ENTER” for zero padded h[n]
press “ENTER” for response of the system
6. OUTPUT PLOT:

7. ANALYSIS:
Circular convolution operates on two input sequences often represented as
vectors. The operation involves multiplying corresponding elements of the
two input sequences and summing up the results. The length of output
sequence is the length of largest input sequence.
8. PRECAUTIONS:
 Add comments within the code to clarify complex DSP operations.
 Ensure proper scaling and units for signals and parameters to maintain
accuracy.
9. RESULT:
Hence performed circular convolution of discrete LTI system with input
sequence x[n] and impulse response h[n] and observed the response.
10. APPLICATIONS:
 Filtering
 Circular Buffers
 System Identification
 EXPERIMENT- 2
TITLE OF THE EXPERIMENT:
Implement and verify autocorrelation for the given sequence and cross
correlation between two given signals.
AUTO CORRELATION
1)AIM: To write a program in MATLAB to perform autocorrelation for the given
sequence and cross correlation between two given signals.
2)SOFTWARE REQUIRED: MATLAB
3)THEORY:
Autocorrelation is the measure of the degree of similarity between a given time
series and the lagged version of that time series over successive time periods.
It is similar to calculating the correlation between two different variables except
in Autocorrelation we calculate the correlation between two different versions
Xt and Xt-k of the same time series.
Auto correlation Operation:
∞

𝑹[𝒌] = ∑ 𝒙[𝒏]𝒉[𝒏 − 𝒌]
𝒌=−∞

Autocorrelation in Digital Signal Processing (DSP) is a mathematical operation

used to analyze a signal's similarity to a delayed version of itself. It measures how
well a signal correlates with a time-shifted version of itself at different time lags.
Autocorrelation is often used for tasks such as detecting periodicity, pitch
estimation in audio signals, and finding repeating patterns in data.
4)PROGRAM CODE:
a=input('Enter input sequence:');
la=length(a);
autocorr=zeros(1,la);
for lag=1:la
for n=1:(la-lag+1)
autocorr(lag)=autocorr(lag)+a(n)*a(n+lag-1);
end
end
disp(autocorr);
subplot(2,1,1);
stem(autocorr);
xlabel('n----->');
ylabel('Amplitude');
title('Autocorrelation of a signal');
5)OUTPUT:
Enter input sequence:
1
1
2
1
Auto correlation of input sequence = 7 5 3 1
6)OUTPUT PLOT:

7)ANALYSIS:
The code first obtains the user's input sequence and calculates its length. It then
proceeds to compute the autocorrelation for various time lags, storing the results
in the 'autocorr' array. This calculation involves iterating through the input
sequence, multiplying elements at different time offsets, and summing these
products to determine the autocorrelation value at each lag.
8)PRECAUTIONS:
 Add comments within the code to clarify complex DSP operations.
 Ensure proper scaling and units for signals and parameters to maintain
accuracy.
9)RESULT:
Hence performed autocorrelation of given input signal and observed the response.
10)APPLICATIONS:
 Time series analysis
 Channel estimation
 Synchronization
 Pattern recognition and motion detection
 CROSS CORRELATION
1)AIM: To write a program in MATLAB to perform autocorrelation for the given
sequence and cross correlation between two given signals.
2)SOFTWARE REQUIRED: MATLAB
3)THEORY:
The cross correlation function between two different signals is defined as the
measure of similarity or coherence between one signal and the time delayed
version of another signal.
Cross correlation Operation:
∞

𝑹[𝒌] = ∑ 𝒙[𝒏]𝒚[𝒏 − 𝒌]
𝒌=−∞

Cross-correlation is a mathematical operation used to measure the similarity

between two signals or data sets. It's often used in signal processing, image
processing, and various fields of science and engineering. The result of cross-
correlation is a new signal, called the cross-correlation function, which indicates
how much one signal resembles another at different time shifts or spatial
positions. It's a valuable tool for tasks like pattern recognition, finding similarities
in data, and more. If you have a specific question or need more information about
cross-correlation.
4)PROGRAM CODE:
a=input('Enter input signal 1:');
b=input('Enter input signal 2:');
N=length(a);
cross_corr=zeros(1,2*N-1);
for lag=-N+1:N-1
if lag<0
shifted_a=[zeros(1,abs(lag)),a(1:N+lag)];
corr_value=sum(shifted_a.*b);
else
shifted_b=[zeros(1,lag),b(1:N-lag)];
corr_value=sum(a.*shifted_b);
end
cross_corr(lag+N)=corr_value;
end
lags=-N+1:N-1;
stem(lags,cross_corr);
xlabel('Lag');
ylabel('cross_correlation value');
title('cross correlation of a and b');
5)OUTPUT:
Enter input signal 1:
1
2
3
4
5
Enter input signal 2:
0
1
2
3
4
6)OUTPUT PLOT:

7)ANALYSIS:
The provided MATLAB code calculates the cross-correlation between two input
signals, 'a' and 'b', for various time lags. It initializes arrays to store the results,
iterates through lags, shifts the signals accordingly, computes cross-correlation
values, and then plots the results using a stem plot. This code is useful for
analyzing the similarity or correlation between the two signals over time.
8)PRECAUTIONS:
 Add comments within the code to clarify complex DSP operations.
 Ensure proper scaling and units for signals and parameters to maintain
accuracy.
9)RESULT:
Hence performed cross correlation of given two input signals and observed the
response.
10)APPLICATIONS:
 Echo Cancellation
 Wireless Communication
 EXPERIMENT- 3
TITLE OF EXPERIMENT: Compute and implement the N-point DFT of a
given sequence and compute the power density spectrum of the sequence.
1. AIM: To write a program in MATLAB to compute the Discrete Fourier
transform of a sequence and compute the power density spectrum of the
sequence.
2. SOFTWARE USED: MATLAB
3. THEORY:
Following are the different transforms used to obtain required frequency
domain representation of any given time domain representation.
 Laplace Transform.
 Fourier Transform.
 Z Transform.
 Discrete Fourier Transform.

Laplace transform is used for only continuous time signals and Z transform is
used for only discrete time signals. Fourier transform is used for both continuous
and discrete time signals.
The DFT is used to convert N-point discrete time sequence x(n) to an Npoint
frequency domain sequence X(k).
N 1
X (k )   x(n) Nnk
n 0
where k is ranging from 0 to N – 1.
To compute DFT from above formulae is very difficult, if number of points(N)
increases, to overcome this problem we can for Fast Fourier Transform(FFT).
The FFT is a method or algorithm is used to compute DFT with reduced number
of calculations (Complex additions & Complex multiplication).

4. PROGRAM CODE:

% clearing previous code data and command window

clear;
clc;

% Entering the input sequence and finding it's lenght

x=input('enter input sequence x(n):');
N = length(x);

% Calculating DFT of the sequence

for k=1:N
m=0;
for n=1:N
m=m+x(n)*exp(2*pi*-j*(n-1)*(k-1)/N);
end
X(k)=m;
end

%displaying X(k)
disp('DFT of sequence');
disp(X);

% Ploting stem plot of magnitude of X(k)

set(0,'defaultfigureposition',[0,0,3000,1500]);
subplot(3,1,1);
stem(0:N-1,abs(X));
title('magnitude of X(k)');
xlabel('frequency-->');
ylabel(' |X(k)|');

% Ploting stem plot of phase of X(k)

subplot(3,1,2);
stem(0:N-1,angle(X));
title('phase of X(k)');
xlabel('frequency-->');
ylabel('/_X(k)');

% Calculating and displaying PDS with graphs

subplot(3,1,3);
p=(abs(X).^2)/N;
disp('PDS of sequence');
disp(p);
stem((0:N-1)/N,p);
title('Power density spectrum PDS');
xlabel('frequency-->');
ylabel('Power density');
 5. OUTPUT:

enter input sequence x(n):

[1 0 1 0]
DSP of sequence
2.0000 + 0.0000i 0.0000 - 0.0000i 2.0000 + 0.0000i 0.0000 - 0.0000i

PDS of sequence
1.0000 0.0000 1.0000 0.0000

enter input sequence x(n):

[1 0 1 0 2 0 2 0]
DSP of sequence
6.0000 + 0.0000i -1.0000 + 1.0000i 0.0000 - 0.0000i -1.0000 - 1.0000i 6.0000 +
0.0000i -1.0000 + 1.0000i 0.0000 - 0.0000i -1.0000 - 1.0000i

PDS of sequence
4.5000 0.2500 0.0000 0.2500 4.5000 0.2500 0.0000 0.2500

6. OUTPUT PLOT:
7. ANALYSIS:
DFT converts a discrete signal from the time domain to the frequency domain,
telling the signal's amplitude and phase at various frequencies. PSD quantifies how
signal power is distributed across different frequencies. It helps identify dominant
frequencies and analyze noise characteristics. Both DFT and PSD are fundamental
for understanding and processing signals in fields such as audio, communications,
and vibration analysis.
8. PRECAUTIONS:
 Add comments within the code to clarify complex DSP operations.
 Ensure proper scaling and units for signals and parameters to maintain accuracy.
9. RESULT:
Written a program in MATLAB to compute the Discrete Fourier transform of a sequence
and compute the power density spectrum of the sequence.
10. APPLICATIONS:
 Spectral analysis
 Audio compression and equalization
 Image compression and enhancement
 Target detection
 EXPERIMENT-4
PROPERTIES OF DFT
1. AIM:
Verify the properties of DFT.
2. SOFTWARE USED:
Matlab
3. THEORY: The properties of DFT are as follows:

1. Periodicity
Let x(n) and x(k) be the DFT pair then if

x(n+N) = x(n) for all n then

X(k+N) = X(k) for all k

Thus periodic sequence xp(n) can be given as

2. Linearity

The linearity property states that if

DFT of linear combination of two or more signals is equal to the same linear combination of
DFT of individual signals.

3. Time reversal of a sequence

The Time reversal property states that if

It means that the sequence is circularly folded its DFT is also circularly folded.

4. Circular Time shift

The Circular Time shift states that if

Thus shifting the sequence circularly by „l samples is equivalent to multiplying

its DFT by e –j2 ∏ k l / N

5. Circular frequency shift

The Circular frequency shift states that if

Thus shifting the frequency components of DFT circularly is equivalent to
multiplying its time domain sequence by e –j2 ∏ k l / N

6. Complex conjugate property

The Complex conjugate property states that if

4. CODE:
a) PERIODICITY:
x=input('enter sequence:');
N=input('enter N:');
y=fft(x,N);
disp(y);
disp(circshift(y,N));
b) LINEARITY:
x1=input('enter 1st sequence:');
N1=input('enter N1:');
a1=input('enter a1:');
x2=input('enter 2nd sequence:');
N2=input('enter N2:');
a2=input('enter a2:');
y1=fft(x1,N1);
disp(y1);
 y2=fft(x2,N2);
disp(y2);
x3=a1*x1+a2*x2;
y3=fft(x3);
disp(y3);
disp(a1*y1+a2*y2);
c) TIME REVERSAL:
x=input('enter sequence:');
N=input('enter N:');
y=fft(x,N);
disp(y);
xf=circshift(flip(x),1);
yr=fft(xf,N);
disp(yr);
disp(circshift(flip(y),1));

d) CONJUGATE:
x=input('enter sequence:');
N=input('enter N:');
y=fft(x,N);
disp(y);
xc=conj(x);
yc=fft(xc,N);
disp(yc);
yt=circshift(flip(y),1);
disp(conj(yt));
e) FREQUENCY SHIFTING:
x=input('enter sequence:');
N=input('enter N:');
m=input('enter m:');
y=fft(x,N);
disp(y);
for n=0:N-1
xfs(n+1)=x(n+1)*exp(2j*pi*m*n/N);
end
yfs=fft(xfs,N);
disp(yfs);
disp(circshift(y,m));
f) TIME SHIFTING:
x=input('enter sequence:');
N=input('enter N:');
m=input('enter m:');
y=fft(x,N);
disp(y);
xts=circshift(x,m);
yts=fft(xts,N);
disp(yts);
for k=0:N-1
yt(k+1)=y(k+1)*exp(-2j*pi*m*k/N);
end
disp(yt);
OUTPUT:
a) PERIODICITY:
Enter sequence: [1 1 2 1]
Enter N: 4
RHS: [5 -1 1 -1]
LHS: [5 -1 1 -1]
b) LINEARITY:
Enter 1st sequence: [1 1 2 1]
Enter N1: 4
Enter a1: 2
Enter 2nd sequence: [2 4 0 6]
Enter N2: 4
Enter a2: 5
 𝑋1(𝑘): [5 -1 1 -1]
𝑋2(𝑘): [12 2+2i -8 2-2i]
RHS: [70 8+10i -38 8-10i]
LHS: [70 8+10i -38 8-10i]
c) TIME REVERSAL:
Enter sequence: [2 0 1 4]
Enter N: 4
𝑋(𝑘): [7 1+4i -1 1-4i]
RHS: [7 1-4i -1 1+4i]
LHS: [7 1-4i -1 1+4i]
d) CONJUGATE:
Enter sequence: [-i 2+i 3i 3]
Enter N: 4
𝑋(𝑘): [5+3i 1-3i -5+i -1-5i]
RHS: [5-3i -1+5i -5-i 1+3i]
LHS: [5-3i -1+5i -5-i 1+3i]
e) FREQUENCY SHIFTING:
Enter sequence: [1 1 2 1]
Enter N: 4
Enter m: 3
𝑋(𝑘): [5 -1 1 -1]
RHS: [-1 1 -1 5]
LHS: [-1 1 -1 5]
f) TIME SHIFTING:
Enter sequence: [2 3 0 4]
Enter N: 4
Enter m: 2
𝑋(𝑘): [9 2+i -5 2-i]
RHS: [9 -2-i -5 -2+i]
LHS: [9 -2-i -5 -2+i]
CASES:
PERIODICITY:

LINEARITY:
CONJUGATE :

TIME REVERSAL:

FREQUENCY SHIFTING:

TIME SHIFTING :
6. ANALYSIS:
It is analyzed from experiment that the DFT of a sequence follows PERIODICITY
LINEARITY, TIME REVERSAL,TIME SHIFTING, FREQUENCY SHIFTING
and CONJUGATE properties.

7. PRECAUTIONS:

 Add comments within the code to clarify complex DSP operations.

 Ensure proper scaling and units for signals and parameters to maintain accuracy.

8. RESULT:
Hence , the properties of DFT were verified.
[Link]:
 Spectrograms.
 Correlation Analysis.

.
 EXPERIMENT-5
TITLE OF THE EXPERIMENT:
Implement and verify N-point DIT-FFT of a given sequence and find the
frequency response(magnitude and phase).
1. AIM: To write a program in MATLAB to compute the Decimation in time Fast
Fourier Transform (DIT-FFT) of a sequence.
2. SOFTWARE REQUIRED: MATLAB
3. THEORY:
DITFFT stands for Decimation in Time Fast Fourier Transform and DIFFFT
stands for Decimation in Frequency Fast Fourier Transform. Decimation in
Time (DIT) Radix 2 FFT algorithm converts the time domain N point sequence
x(n) to a frequency domain N-point sequence X(k).
In Decimation in Time algorithm the time domain sequence x(n) is decimated
and smaller point DFT are performed. The results of smaller point DFTs are
combined to get the result of N-point DFT. In DITFFT, input is bit reversed while
the output is in natural order, whereas in DIFFFT, input is in natural order while
the output is in bit reversal order.

[Link] CODE:
clc;
clear all;
close all;
x=input('Enter the sequence : ');
N=input('Enter the Point : ');
n=length(x);
x=[x zeros(1,N-n)];
y=bitrevorder(x);
M=log2(N);
for m=1:M
d=2^m;
for l=[Link]N-d+1
for k=0:(d/2)-1
w=exp(-1i*2*pi*k/d);
z1=y(l+k);
z2=y(l+k+d/2);
y(l+k)=z1+w*z2;
y(l+k+d/2)=z1-w*z2;
end
end
end
disp(y);

subplot(3,1,1)
stem(abs(x));
title('Input Sequence');
subplot(3,1,2)
stem(abs(y));
title('Magnitude Response');
subplot(3,1,3)
stem(angle(y));
title('Phase Response');

[Link]:

4-pt DIT-FFT
Enter the sequence : [1 2 3 4]
Enter the Point : 4
10.0000 + 0.0000i -2.0000 + 2.0000i -2.0000 + 0.0000i -2.0000 - 2.0000i

8-pt DIT-FFT
Enter the sequence :
[1 2 3 4 5 6 7 8]
Enter the Point :
8
36.0000 + 0.0000i -4.0000 + 9.6569i -4.0000 + 4.0000i -4.0000 + 1.6569i
-4.0000 + 0.0000i -4.0000 - 1.6569i -4.0000 - 4.0000i -4.0000 - 9.6569i

[Link] PLOT:

4 Point:
8-Point:

[Link]:
DIT Radix FFT algorithm the time domain sequence x(n) is
decimated and smaller point DTF are performed. It reduces the number
of complex multiplications required from N^2 to N log2N. The DIT FFT
represents the input sequence in terms of its frequency components.
Peaks in the FFT output indicate the frequencies present in the original
sequence, and the height of these peaks represents the amplitude or
strength of each frequency component.
[Link]:
 Add comments within the code to clarify complex DSP operations.
 Ensure proper scaling and units for signals and parameters to maintain
accuracy.

[Link]:
Hence written a program in MATLAB to compute the Decimation in time
Fast Fourier Transform (DIT-FFT) of a sequence and the waveforms were
observed.
[Link]:

1. Filtering
2. Used in complex signal processing techniques
3. Sensor data signals
AIM: To write a program in MATLAB to compute the Inverse Fast Fourier transform of a
sequence.

The Fast Fourier Transform is highly efficient procedure for computing the DFT
of
DFT. It reduces the computations by advantage of the fact that calculation of the
coefficients of the DFT can be carried out iteratively. Due to this,FFT computation
technique is used in digital spectral analysis, filter simulation, autocorrelation and
pattern recognition.
The FFT is based on decomposition and breaking the transform into smaller

[Link]-in-time
[Link]-in-frequency

clc; close
all;for
n=1:8
end
y=fft(x);
b=abs(y);
c=angle(y);

stem(x);
xlabel('n');
ylabel('x(n)');
title('input');
subplot(2,3,2);
stem(real(y));
xlabel('n');
ylabel('x(n)');

subplot(2,3,4);
stem(b);
xlabel('n');
SEQUENCE 1:
Enter 4 point value: 2
Enter 4 point value: 1
Enter 4 point value: 2
Enter 4 point value: 1
 The inverse DFT performs the reverse operation and converts a
very
efficient algorithm technique based on the DFT but with fewer computations

Add comments within the code to clarify complex DSP operations. Ensure
proper scaling and units for signals and parameters to maintainaccuracy.

Written a program in MATLAB to compute the inverse Fast Fourier transform of

asequence and compute the power density spectrum of the sequence.

directly from its frequency domain form, X(m).

domain.