MATLAB Code for Linear Convolution, Cross-Correlation, and Auto-Correlation
Linear Convolution
Using Built-in Function
% Define two discrete signals
x = [1, 2, 3, 4];
h = [2, 1];
% Linear convolution using built-in function
linear_conv_builtin = conv(x, h);
% Display the result
disp('Linear Convolution (using built-in function):');
disp(linear_conv_builtin);
Without Using Built-in Function
% Define two discrete signals
x = [1, 2, 3, 4];
h = [2, 1];
% Get the lengths of the signals
N = length(x);
M = length(h);
L = N + M - 1; % Length of the result
% Zero-pad the signals to the result length
x_padded = [x, zeros(1, M - 1)];
h_padded = [h, zeros(1, N - 1)];
% Linear convolution calculation (manual)
linear_conv_manual = zeros(1, L);
for n = 1:L % Iterate over each output sample
for m = 1:N % Iterate over each element of x
if (n - m + 1 > 0) % Check if the index is valid
linear_conv_manual(n) = linear_conv_manual(n) + x_padded(m) * h_padded(n - m + 1);
end
end
end
% Display the result
disp('Linear Convolution (manual calculation):');
disp(linear_conv_manual);
Cross-Correlation
Using Built-in Function
% Define two discrete signals
x = [1, 2, 3, 4];
y = [4, 3, 2, 1];
% Cross-correlation using built-in function
cross_corr_builtin = xcorr(x, y);
% Display the result
disp('Cross-correlation (using built-in function):');
disp(cross_corr_builtin);
Without Using Built-in Function
% Define two discrete signals
x = [1, 2, 3, 4];
y = [4, 3, 2, 1];
% Get the lengths of the signals
N = length(x);
M = length(y);
L = N + M - 1; % Length of the result
% Zero-pad the signals to the result length
x_padded = [x, zeros(1, M - 1)];
y_padded = [y, zeros(1, N - 1)];
% Cross-correlation calculation (manual)
cross_corr_manual = zeros(1, L);
for n = 1:L % Iterate over each output sample
for m = 1:N % Iterate over each element of x
if (n - m + 1 > 0 && n - m + 1 <= M) % Check if the index is valid for y
cross_corr_manual(n) = cross_corr_manual(n) + x_padded(m) * y_padded(n - m + 1);
end
end
end
% Display the result
disp('Cross-correlation (manual calculation):');
disp(cross_corr_manual);
Auto-Correlation
Using Built-in Function
% Define a discrete signal
x = [1, 2, 3, 4];
% Auto-correlation using built-in function
auto_corr_builtin_x = xcorr(x);
% Display the result
disp('Auto-correlation of x (using built-in function):');
disp(auto_corr_builtin_x);
Without Using Built-in Function
% Define a discrete signal
x = [1, 2, 3, 4];
% Get the length of the signal
N = length(x);
L = 2 * N - 1; % Length of the result
% Zero-pad the signal to the result length
x_padded = [x, zeros(1, N - 1)];
% Auto-correlation calculation (manual)
auto_corr_manual_x = zeros(1, L);
for n = 1:L % Iterate over each output sample
for m = 1:N % Iterate over each element of x
if (n - m + 1 > 0 && n - m + 1 <= N) % Check if the index is valid
auto_corr_manual_x(n) = auto_corr_manual_x(n) + x_padded(m) * x_padded(n - m + 1);
end
end
end
% Display the result
disp('Auto-correlation of x (manual calculation):');
disp(auto_corr_manual_x);
Matlab Code for ODE
% Define the parameters
k = 0.1; % Decay constant
y0 = 10; % Initial condition y(0) = 10
% Define the ODE as a function handle
odefun = @(t, y) -k * y;
% Set the time span for the solution
tspan = [0 50]; % From t = 0 to t = 50
% Solve the ODE using ode45
[t, y] = ode45(odefun, tspan, y0);
% Plot the results
figure;
plot(t, y, 'LineWidth', 2);
xlabel('Time (t)');
ylabel('Function value (y)');
title('Solution of ODE dy/dt = -ky');
grid on;
MATLAB Code to Find the Impulse Response
% Define the system (transfer function coefficients)
b = [0.5, 1]; % Numerator coefficients (for example, H(z) = 0.5 + z^-1)
a = [1, -0.3]; % Denominator coefficients (H(z) = (0.5 + z^-1)/(1 - 0.3z^-1))
% 1. Using impz to find impulse response
figure;
subplot(3, 1, 1);
impz(b, a); % Impulse response of the system
title('Impulse Response using impz');
xlabel('Samples');
ylabel('Amplitude');
% 2. Using filter to find impulse response
n_samples = 100; % Number of samples for the impulse response
impulse = [1; zeros(n_samples-1, 1)]; % Create an impulse signal
response_filter = filter(b, a, impulse); % Filter the impulse
subplot(3, 1, 2);
stem(response_filter); % Plot the response
title('Impulse Response using filter');
xlabel('Samples');
ylabel('Amplitude');
% 3. Using deconv to find impulse response
response_deconv = deconv(response_filter, impulse); % Deconvolve to find response
subplot(3, 1, 3);
stem(response_deconv); % Plot the response
title('Impulse Response using deconv');
xlabel('Samples');
ylabel('Amplitude');
% Adjust the layout
sgtitle('Impulse Response of LTI System using Different Methods');
MATLAB Code to Compute DFT and IDFT
% Define the input discrete time sequence
x = [1, 2, 3, 4]; % Example discrete time sequence
% 1. Compute the DFT of the sequence
N = length(x); % Length of the input sequence
X = zeros(1, N); % Initialize the DFT output array
for k = 0:N-1
for n = 0:N-1
% Compute the DFT using the formula
X(k+1) = X(k+1) + x(n+1) * exp(-1j * 2 * pi * k * n / N);
end
end
% Display the DFT result
disp('DFT of the input sequence:');
disp(X);
% 2. Compute the IDFT of the sequence
x_reconstructed = zeros(1, N); % Initialize the IDFT output array
for n = 0:N-1
for k = 0:N-1
% Compute the IDFT using the formula
x_reconstructed(n+1) = x_reconstructed(n+1) + X(k+1) * exp(1j * 2 * pi * k * n / N);
end
x_reconstructed(n+1) = x_reconstructed(n+1) / N; % Normalize the result
end
% Display the IDFT result
disp('Reconstructed sequence from IDFT:');
disp(x_reconstructed);
% Plot the original sequence
figure;
subplot(3, 1, 1);
stem(0:N-1, x, 'filled');
title('Original Discrete Time Sequence');
xlabel('Sample Index');
ylabel('Amplitude');
% Plot the magnitude of the DFT result
subplot(3, 1, 2);
stem(0:N-1, abs(X), 'filled');
title('Magnitude Spectrum of DFT');
xlabel('Frequency Index');
ylabel('Magnitude');
% Plot the reconstructed sequence from IDFT
subplot(3, 1, 3);
stem(0:N-1, real(x_reconstructed), 'filled'); % Use real part to avoid numerical noise
title('Reconstructed Sequence from IDFT');
xlabel('Sample Index');
ylabel('Amplitude');
% Adjust layout
sgtitle('DFT and IDFT Results');
MATLAB Code to Compute FFT and IFFT of the Signal
% Parameters for the signal
fs = 10000; % Sampling frequency in Hz
N = 1024; % Number of points for FFT
n = 0:N-1; % Sample index
% Define the signal X[n] = cos(2*pi*1000*n/fs) + cos(2*pi*500*n/fs)
X_n = cos(2 * pi * 1000 * n / fs) + cos(2 * pi * 500 * n / fs);
% Compute the FFT of the signal
X_fft = fft(X_n);
% Compute the IFFT of the signal to reconstruct it
X_ifft = ifft(X_fft);
% Plot the original signal
figure;
subplot(3, 1, 1);
plot(n, X_n);
title('Original Signal X[n]');
xlabel('Sample Index');
ylabel('Amplitude');
% Plot the magnitude spectrum of the FFT
subplot(3, 1, 2);
f = (0:N-1) * (fs / N); % Frequency vector
plot(f, abs(X_fft));
title('Magnitude Spectrum of FFT');
xlabel('Frequency (Hz)');
ylabel('Magnitude');
% Plot the reconstructed signal from IFFT
subplot(3, 1, 3);
plot(n, real(X_ifft));
title('Reconstructed Signal from IFFT');
xlabel('Sample Index');
ylabel('Amplitude');
% Adjust layout
sgtitle('FFT and IFFT of X[n]');
MATLAB Code for Circular Convolution
% Define two finite-duration discrete signals
x = [1, 2, 3, 4]; % First input sequence
h = [1, 1, 1]; % Second input sequence
% Perform circular convolution using inbuilt function
N = max(length(x), length(h)); % Length of the circular convolution
y_circular_inbuilt = cconv(x, h, N);
% Display the result
disp('Circular Convolution using inbuilt function:');
disp(y_circular_inbuilt);
% Define two finite-duration discrete signals
x = [1, 2, 3, 4]; % First input sequence
h = [1, 1, 1]; % Second input sequence
% Zero-pad both sequences to the length of N
N = max(length(x), length(h)); % Length of the circular convolution
x = [x, zeros(1, N - length(x))];
h = [h, zeros(1, N - length(h))];
% Initialize the result array
y_circular_manual = zeros(1, N);
% Perform circular convolution manually
for n = 1:N
for m = 1:N
% Use modulo operation for circular indexing
index = mod(n - m, N);
if index < 0
index = index + N; % Ensure positive indexing
end
y_circular_manual(n) = y_circular_manual(n) + x(m) * h(index + 1);
end
end
% Display the result
disp('Circular Convolution without using inbuilt function:');
disp(y_circular_manual);
MATLAB Code to Design FIR Filters Using Window Techniques
% Sampling frequency
fs = 1000; % Hz
% Normalized cutoff frequencies (relative to Nyquist frequency)
f_cutoff_low = 0.2; % 0.2 * (fs/2) = 100 Hz
f_cutoff_high = 0.5; % 0.5 * (fs/2) = 250 Hz
filter_order = 50; % Filter order
% Frequency specifications for band-pass and band-stop filters
f_band = [0.2, 0.5]; % 100 Hz to 250 Hz
% Designing the filters
% Low-pass filter
lp_rectangular = fir1(filter_order, f_cutoff_low, 'low', rectwin(filter_order + 1));
lp_hanning = fir1(filter_order, f_cutoff_low, 'low', hanning(filter_order + 1));
lp_hamming = fir1(filter_order, f_cutoff_low, 'low', hamming(filter_order + 1));
lp_blackman = fir1(filter_order, f_cutoff_low, 'low', blackman(filter_order + 1));
% High-pass filter
hp_rectangular = fir1(filter_order, f_cutoff_low, 'high', rectwin(filter_order + 1));
hp_hanning = fir1(filter_order, f_cutoff_low, 'high', hanning(filter_order + 1));
hp_hamming = fir1(filter_order, f_cutoff_low, 'high', hamming(filter_order + 1));
hp_blackman = fir1(filter_order, f_cutoff_low, 'high', blackman(filter_order + 1));
% Band-pass filter
bp_rectangular = fir1(filter_order, f_band, 'bandpass', rectwin(filter_order + 1));
bp_hanning = fir1(filter_order, f_band, 'bandpass', hanning(filter_order + 1));
bp_hamming = fir1(filter_order, f_band, 'bandpass', hamming(filter_order + 1));
bp_blackman = fir1(filter_order, f_band, 'bandpass', blackman(filter_order + 1));
% Band-stop filter
bs_rectangular = fir1(filter_order, f_band, 'stop', rectwin(filter_order + 1));
bs_hanning = fir1(filter_order, f_band, 'stop', hanning(filter_order + 1));
bs_hamming = fir1(filter_order, f_band, 'stop', hamming(filter_order + 1));
bs_blackman = fir1(filter_order, f_band, 'stop', blackman(filter_order + 1));
% Plotting frequency responses
figure;
freqz(lp_rectangular, 1, 1024, fs);
title('Low-Pass Filter using Rectangular Window');
figure;
freqz(lp_hanning, 1, 1024, fs);
title('Low-Pass Filter using Hanning Window');
figure;
freqz(lp_hamming, 1, 1024, fs);
title('Low-Pass Filter using Hamming Window');
figure;
freqz(lp_blackman, 1, 1024, fs);
title('Low-Pass Filter using Blackman Window');
MATLAB Code to Design IIR Filters
% Sampling frequency
fs = 2000; % Hz
% Normalized cutoff frequencies (relative to Nyquist frequency)
f_cutoff_low = 0.2; % 0.2 * (fs/2) = 200 Hz
f_cutoff_high = 0.5; % 0.5 * (fs/2) = 500 Hz
f_band = [0.2, 0.5]; % 200 Hz to 500 Hz
% Filter order
filter_order = 4; % Chosen filter order for demonstration
% Butterworth Filter
[b_butter_low, a_butter_low] = butter(filter_order, f_cutoff_low, 'low');
[b_butter_high, a_butter_high] = butter(filter_order, f_cutoff_low, 'high');
[b_butter_band, a_butter_band] = butter(filter_order, f_band, 'bandpass');
[b_butter_stop, a_butter_stop] = butter(filter_order, f_band, 'stop');
% Chebyshev Type I Filter
[b_cheby1_low, a_cheby1_low] = cheby1(filter_order, 0.5, f_cutoff_low, 'low');
[b_cheby1_high, a_cheby1_high] = cheby1(filter_order, 0.5, f_cutoff_low, 'high');
[b_cheby1_band, a_cheby1_band] = cheby1(filter_order, 0.5, f_band, 'bandpass');
[b_cheby1_stop, a_cheby1_stop] = cheby1(filter_order, 0.5, f_band, 'stop');
% Chebyshev Type II Filter
[b_cheby2_low, a_cheby2_low] = cheby2(filter_order, 20, f_cutoff_low, 'low');
[b_cheby2_high, a_cheby2_high] = cheby2(filter_order, 20, f_cutoff_low, 'high');
[b_cheby2_band, a_cheby2_band] = cheby2(filter_order, 20, f_band, 'bandpass');
[b_cheby2_stop, a_cheby2_stop] = cheby2(filter_order, 20, f_band, 'stop');
% Elliptic Filter
[b_ellip_low, a_ellip_low] = ellip(filter_order, 0.5, 20, f_cutoff_low, 'low');
[b_ellip_high, a_ellip_high] = ellip(filter_order, 0.5, 20, f_cutoff_low, 'high');
[b_ellip_band, a_ellip_band] = ellip(filter_order, 0.5, 20, f_band, 'bandpass');
[b_ellip_stop, a_ellip_stop] = ellip(filter_order, 0.5, 20, f_band, 'stop');
% Plotting frequency responses
figure;
freqz(b_butter_low, a_butter_low, 1024, fs);
title('Butterworth Low-Pass Filter');
figure;
freqz(b_cheby1_low, a_cheby1_low, 1024, fs);
title('Chebyshev Type I Low-Pass Filter');
figure;
freqz(b_cheby2_low, a_cheby2_low, 1024, fs);
title('Chebyshev Type II Low-Pass Filter');
figure;
freqz(b_ellip_low, a_ellip_low, 1024, fs);
title('Elliptic Low-Pass Filter');
First experiment
% Clear workspace and close all figures
clear; close all; clc;
%% Continuous-Time Signals
% Define time vector for continuous-time signals
t_continuous = 0:0.01:2; % Time from 0 to 2 seconds with 0.01s interval
% Define continuous-time signals
signal_sine = sin(2 * pi * 1 * t_continuous); % 1 Hz sine wave
signal_square = square(2 * pi * 1 * t_continuous); % 1 Hz square wave
signal_exponential = exp(-t_continuous); % Exponential decay
% Plot continuous-time signals
figure;
subplot(3, 1, 1);
plot(t_continuous, signal_sine, 'LineWidth', 1.5);
title('Continuous-Time Signal: Sine Wave (1 Hz)');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
subplot(3, 1, 2);
plot(t_continuous, signal_square, 'LineWidth', 1.5);
title('Continuous-Time Signal: Square Wave (1 Hz)');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
subplot(3, 1, 3);
plot(t_continuous, signal_exponential, 'LineWidth', 1.5);
title('Continuous-Time Signal: Exponential Decay');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
%% Discrete-Time Signals
% Define discrete time vector
n_discrete = 0:0.1:2; % Discrete time from 0 to 2 seconds with 0.1s interval
% Define discrete-time signals
discrete_signal_sine = sin(2 * pi * 1 * n_discrete); % 1 Hz sine wave
discrete_signal_square = square(2 * pi * 1 * n_discrete); % 1 Hz square wave
discrete_signal_exponential = exp(-n_discrete); % Exponential decay
% Plot discrete-time signals
figure;
subplot(3, 1, 1);
stem(n_discrete, discrete_signal_sine, 'filled', 'LineWidth', 1.5);
title('Discrete-Time Signal: Sine Wave (1 Hz)');
xlabel('n (Samples)');
ylabel('Amplitude');
grid on;
subplot(3, 1, 2);
stem(n_discrete, discrete_signal_square, 'filled', 'LineWidth', 1.5);
title('Discrete-Time Signal: Square Wave (1 Hz)');
xlabel('n (Samples)');
ylabel('Amplitude');
grid on;
subplot(3, 1, 3);
stem(n_discrete, discrete_signal_exponential, 'filled', 'LineWidth', 1.5);
title('Discrete-Time Signal: Exponential Decay');
xlabel('n (Samples)');
ylabel('Amplitude');
grid on;
%% Basic Elementary Discrete-Time Functions
% Define time vector for basic functions
n_basic = -5:5; % Range from -5 to 5
% Define basic discrete-time functions
impulse_signal = (n_basic == 0); % Impulse function
step_signal = (n_basic >= 0); % Step function
ramp_signal = n_basic .* (n_basic >= 0); % Ramp function
% Plot basic elementary functions
figure;
subplot(3, 1, 1);
stem(n_basic, impulse_signal, 'filled', 'LineWidth', 1.5);
title('Elementary Function: Discrete-Time Impulse Function');
xlabel('n (Samples)');
ylabel('Amplitude');
grid on;
subplot(3, 1, 2);
stem(n_basic, step_signal, 'filled', 'LineWidth', 1.5);
title('Elementary Function: Discrete-Time Step Function');
xlabel('n (Samples)');
ylabel('Amplitude');
grid on;
subplot(3, 1, 3);
stem(n_basic, ramp_signal, 'filled', 'LineWidth', 1.5);
title('Elementary Function: Discrete-Time Ramp Function');
xlabel('n (Samples)');
ylabel('Amplitude');
grid on;
Second experiment
% Define the input signal
t = 0:0.01:1; % Time vector from 0 to 1 seconds with 0.01s interval
input_signal = sin(2 * pi * 5 * t); % Example input signal (5 Hz sine wave)
% Scaling Transformation
scale_factor = 2; % Scale factor for amplitude
scaled_signal = scale_factor * input_signal;
% Time Shifting Transformation
time_shift = 0.1; % Time shift in seconds
t_shifted = t + time_shift; % Shift time vector
time_shifted_signal = sin(2 * pi * 5 * (t_shifted)); % Time-shifted signal
% Time Reversal Transformation
reversed_signal = fliplr(input_signal); % Reverse the input signal
t_reversed = fliplr(t); % Reverse the time vector
% Frequency Shifting Transformation (Modulation)
frequency_shift = 2; % Frequency shift amount
modulated_signal = cos(2 * pi * frequency_shift * t) .* input_signal; % Modulation with cosine
% Filter Transformation
fs = 100; % Sampling frequency
fc = 10; % Cut-off frequency
[b, a] = butter(2, fc/(fs/2)); % 2nd-order Butterworth filter design
filtered_signal = filter(b, a, input_signal); % Apply the filter
% Visualization
figure;
% Original Signal
subplot(5, 1, 1);
plot(t, input_signal, 'LineWidth', 1.5);
title('Original Signal (5 Hz Sine Wave)');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
% Scaled Signal
subplot(5, 1, 2);
plot(t, scaled_signal, 'LineWidth', 1.5);
title('Scaled Signal (Amplitude x2)');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
% Time-Shifted Signal
subplot(5, 1, 3);
plot(t_shifted, time_shifted_signal, 'LineWidth', 1.5);
title('Time-Shifted Signal (Shifted by 0.1s)');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
% Reversed Signal
subplot(5, 1, 4);
plot(t_reversed, reversed_signal, 'LineWidth', 1.5);
title('Time-Reversed Signal');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
% Filtered Signal
subplot(5, 1, 5);
plot(t, filtered_signal, 'LineWidth', 1.5);
title('Filtered Signal (Low-Pass Filter)');
xlabel('Time (s)');
ylabel('Amplitude');
grid on;
