DSP LAB

1 LAB.SINE wave program

clear all;
close all;

x = linspace(0, 2*pi, 1000);

y = sin(x);

plot(x, y);
title('Sine Wave');
xlabel('Angle (radians)');
ylabel('sin(x)');
grid on;

2 LAB.Unit Impulse signal

clear all;
close all;

t = -10:10;

impulse_signal = zeros(size(t));

for i = 1:length(t)
if t(i) == 0
impulse_signal(i) = 1;
end
end

stem(t, impulse_signal);
title('Unit Impulse Signal');
xlabel('Time');
ylabel('Amplitude');
grid on;

//EXPLANATION -> This MATLAB code generates a unit impulse signal and plots it using the stem function. Here's an

1. **Initialization**:
- `clear all; close all;` are used to clear any existing variables and figures in the MATLAB workspace.

2. **Time Index**:
- `t = -10:10;` defines a time range from -10 to 10. This range determines the duration of the signal.

3. **Unit Impulse Signal Generation**:

- `impulse_signal = zeros(size(t));` initializes an array `impulse_signal` with the same size as `t`, filled with zeros.

- The `for` loop iterates over each element of `t`.

- If the current element `t(i)` is equal to 0 (indicating the current time instant is at the origin), the corresponding e
it impulse at that instant.

4. **Plotting**:
- `stem(t, impulse_signal);` plots the unit impulse signal.
- `title('Unit Impulse Signal');` sets the title of the plot.
- `xlabel('Time'); ylabel('Amplitude');` sets the labels for the x-axis and y-axis, respectively.
- `grid on;` displays the grid on the plot for better readability.

5. **Result**:
- The plot shows a unit impulse signal with an amplitude of 1 at the time instant t=0 and 0 elsewhere. The stem fun
###3 LAB. Unit Step Signal

clear all;
close all;

t = -10:10;

step_signal = zeros(size(t));

for i = 1:length(t)
if t(i) >= 0
step_signal(i) = 1;
end
end

stem(t, step_signal);
title('Unit Step Signal');
xlabel('Time');
ylabel('Amplitude');
grid on;

//EXPLANATION

This MATLAB code generates a unit step signal and plots it using the stem function. Here's an explanation of the cod

1. **Initialization**:
- `clear all; close all;` are used to clear any existing variables and figures in the MATLAB workspace.

2. **Time Index**:
- `t = -10:10;` defines a time range from -10 to 10. This range determines the duration of the signal.

3. **Unit Step Signal Generation**:

- `step_signal = zeros(size(t));` initializes an array `step_signal` with the same size as `t`, filled with zeros.

- The `for` loop iterates over each element of `t`.

- If the current element `t(i)` is greater than or equal to 0 (indicating the current time instant is at or after the orig
to 1, creating the unit step signal.

4. **Plotting**:
- `stem(t, step_signal);` plots the unit step signal.
- `title('Unit Step Signal');` sets the title of the plot.
- `xlabel('Time'); ylabel('Amplitude');` sets the labels for the x-axis and y-axis, respectively.
- `grid on;` displays the grid on the plot for better readability.

5. **Result**:
- The plot shows a unit step signal with an amplitude of 1 for times greater than or equal to 0, and 0 for times less t
nature of the signal.

####4 LAB .growing exponential signal without using inbuilt libraryof exp function in digtal signal processing lab ma
% Parameters
A = 1; % Amplitude
alpha = 0.1; % Growth rate
N = 100; % Number of samples
n = 0:N-1; % Time index

% Generate the signal without using exp function

x = zeros(1, N);
for i = 1:N
x(i) = A * (1 + alpha)^i;
end

% Plot the signal

stem(n, x);
xlabel('n');
ylabel('Amplitude');
title('Growing Exponential Signal (Approximated)');

//EXPLANATION
Certainly! Here's an explanation of the code:

1. **Parameters**:
- `A`: Amplitude of the exponential signal.
- `alpha`: Growth rate of the exponential signal.
- `N`: Number of samples to generate.
- `n`: Time index from 0 to `N-1`.

2. **Initialization**:
- We initialize an array `x` of size `N` to store the values of the exponential signal.

3. **Signal Generation**:
- We use a `for` loop to iterate from 1 to `N`.
- For each iteration `i`, we calculate the value of the exponential signal at index `i` using the formula \( A \times (1

4. **Plotting**:
- We use the `stem` function to plot the generated signal `x` against the time index `n`.
- The x-axis represents the time index `n`, and the y-axis represents the amplitude of the signal.
- The title of the plot is "Growing Exponential Signal (Approximated)".

###5 LAB. Plot a decaying exponential signal without using inbuilt library of exp function in digtal signal processing l

% Parameters
A = 1; % Amplitude
alpha = -0.1; % Decay rate (negative for decay)
N = 100; % Number of samples
n = 0:N-1; % Time index

% Generate the signal without using exp function

x = zeros(1, N);
for i = 1:N
x(i) = A * (1 + alpha)^i;
end

% Plot the signal

stem(n, x);
xlabel('n');
ylabel('Amplitude');
title('Decaying Exponential Signal (Approximated)');
//EXPLANATION
Certainly! Here's an explanation of the code:

1. **Parameters**:
- `A`: Amplitude of the decaying exponential signal.
- `alpha`: Decay rate of the exponential signal (negative for decay).
- `N`: Number of samples to generate.
- `n`: Time index from 0 to `N-1`.

2. **Initialization**:
- We clear any existing variables and close any open figures using `clear all; close all;`.

3. **Signal Generation**:
- We initialize an array `x` of size `N` to store the values of the decaying exponential signal.

- The `for` loop iterates over each element of `n` (from 1 to `N`).
- For each iteration `i`, we calculate the value of the decaying exponential signal at index `i` using the formula \(

4. **Plotting**:
- We use the `stem` function to plot the decaying exponential signal `x` against the time index `n`.
- The x-axis represents the time index `n`, and the y-axis represents the amplitude of the signal.
- We set the title of the plot to "Decaying Exponential Signal (Approximated)" using `title('Decaying Exponential Sign
- We set the labels for the x-axis and y-axis using `xlabel('n'); ylabel('Amplitude');`.

###6 LAB.PLOT THE CIRCULAR CONVOLUTION FOR THE TWO SEQUENCES WITH FOUR VALUES OF INPUT IN MATLAB

% Define the two sequences with four values each

x = [1, 2, 3, 4]; % Sequence 1
h = [0.5, 0.2, 0.1, 0.3]; % Sequence 2

% Calculate the circular convolution using cconv

y = cconv(x, h, 4);

% Plot the circular convolution result

stem(0:3, y);
xlabel('Index');
ylabel('Amplitude');
title('Circular Convolution of Two Sequences');
grid on;

//EXPLANATION
Here's an explanation of the code for calculating and plotting the circular convolution of two sequences with four val

1. **Input Sequences**:
- `x = [1, 2, 3, 4];` and `h = [0.5, 0.2, 0.1, 0.3];` define two sequences with four values each. These are the sequence

2. **Circular Convolution Calculation**:

- `y = cconv(x, h, 4);` calculates the circular convolution of sequences `x` and `h` with a result length of 4. The `cc
ircular shift property of the Discrete Fourier Transform (DFT).

3. **Plotting**:
- `stem(0:3, y);` plots the circular convolution result `y` against the index (0 to 3). The `stem` function is used to c
values.

4. **Labels and Title**:

- `xlabel('Index'); ylabel('Amplitude');` set the labels for the x-axis and y-axis, respectively, indicating that the x-axis
plitude of the convolution result.
- `title('Circular Convolution of Two Sequences');` sets the title of the plot to "Circular Convolution of Two Sequence

5. **Grid**:
- `grid on;` adds a grid to the plot for better readability, making it easier to see the values of the convolution result

####7.PLOT THE DISCRETE FOURIER TRANSFORM FOR A FOUR POINT SEQUENCE ON A MATLAB CODE

% Define the four-point sequence

x = [1, 2, 3, 4];

% Calculate the Discrete Fourier Transform (DFT)

X = fft(x);

% Plot the magnitude of the DFT

stem(0:3, abs(X));
xlabel('Frequency (k)');
ylabel('Magnitude');
title('Magnitude of DFT of a Four-Point Sequence');
grid on;

//EXPLANATION
Here's an explanation of the code for calculating and plotting the Discrete Fourier Transform (DFT) of a four-point se

1. **Input Sequence**:
- `x = [1, 2, 3, 4];` defines a four-point sequence for which we want to calculate the DFT.

2. **DFT Calculation**:
- `X = fft(x);` calculates the DFT of the input sequence `x` using the Fast Fourier Transform (FFT) algorithm. The res

3. **Magnitude Plotting**:
- `stem(0:3, abs(X));` plots the magnitude of the DFT coefficients. The `abs` function is used to calculate the magn
- The x-axis represents the frequency index `k`, which ranges from 0 to 3 for a four-point DFT.
- The y-axis represents the magnitude of the DFT coefficients.

4. **Labels and Title**:

- `xlabel('Frequency (k)'); ylabel('Magnitude');` set the labels for the x-axis and y-axis, respectively, indicating that th
represents the magnitude of the DFT coefficients.
- `title('Magnitude of DFT of a Four-Point Sequence');` sets the title of the plot to describe the content.

5. **Grid**:
- `grid on;` adds a grid to the plot for better readability, making it easier to see the values of the DFT coefficients.