1.

### Method 1 (Matrix Multiplication):

% Define the vectors u and v as row and column vectors,

respectively
u = [4, 9, -5]; % Row vector
v = [-3; 6; -7]; % Column vector

% Calculate the dot product using matrix multiplication

dotProductMatrix = u * v;

% Display the dot product calculated using matrix

multiplication
disp('Dot Product using Matrix Multiplication:');
disp(dotProductMatrix);
```

### Method 2 (Using the dot function):

```matlab
% Define the vectors u and v as MATLAB vectors
u = [4, 9, -5];
v = [-3, 6, -7];

% Calculate the dot product using the dot function

dotProduct = dot(u, v);

% Display the dot product calculated using the dot function

disp('Dot Product using dot function:');
disp(dotProduct);

2.

% Define the vector of x values

x = [-2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3];

% Calculate the corresponding y values using element-wise

calculations
y = x.^3 .* (x.^2 + 1).^3;

% Display the values of x and y

disp('Values of x:');
disp(x);
disp('Values of y:');
disp(y);
---------------------------------Output------------------------------------------
Values of x:
-2.5000 -2.0000 -1.5000 -1.0000 -0.5000 0 0.5000 1.0000 1.5000
2.0000 2.5000 3.0000

Values of y:
275.6094 108.0000 46.8750 16.0000 3.6094 0.0000 3.6094 16.0000
46.8750 108.0000 275.6094 559.0000

3.
% Given constants
g = 9.81; % acceleration due to gravity in m/s^2

% Create a vector of time values from 1 to 10 seconds

t = 1:10; % This creates a vector [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

% Calculate the depth of the well for each time using element-
wise calculations
d = 0.5 * g * t.^2;

% Display the values of t and corresponding depths d

disp('Time (s):');
disp(t);
disp('Depth (m):');
disp(d);

----------------------------------Output-----------------------------------------

Time (s):
1 2 3 4 5 6 7 8 9 10

Depth (m):
4.9050 19.6200 44.1450 78.4800 122.6350 176.6100
240.4050 314.0200 397.4550 490.7100

4.
% Define the vectors x and y
x = [2, 4, 6, 8, 10];
y = [3, 6, 9, 12, 15];

% Calculate z using the given expression

z = (x.*y + y./x) ./ (x + y).^(y - x) + 12.^(x./y);

% Display the calculated values of z

disp('Values of z:');
disp(z);

---------------------------------Output------------------------------------------

Values of z:
33.3929 267.0056 587.6491 1282.0287 2847.5522

5.

% Define the scalars h and k, and vectors x, y, and z

h = 0.9;
k = 12.5;
x = [1, 2, 3, 4];
y = [0.9, 0.8, 0.7, 0.6];
z = [2.5, 3, 3.5, 4];

% Calculate T using the given formula (element-wise

calculations)
T = (x .* y .* z) ./ ((h + k).^(k/5)) + (k .* exp((z ./ x) + y)) ./
(z.^h);

% Display the calculated values of T

disp('Values of T:');
disp(T);

------------------------------------Output-------------------------------------

Values of T:
[164.20043282 46.39237005 26.18890142
17.79441838]

6.

% Define the vector n with the given elements

n = [1, 10, 100, 500, 1000, 2000, 4000, 8000];

% Calculate y using the given formula for each element of n

y = (1 + 1 ./ n) .^ n;

% Calculate the value of e using exp(1)

e_value = exp(1);

% Display the calculated values of y and the value of e

disp('Values of y:');
disp(y);
disp(['Value of e: ', num2str(e_value)]);

% Calculate the absolute difference between y and the value

of e
absolute_difference = abs(y - e_value);

% Display the absolute differences

disp('Absolute Differences between y and e:');
disp(absolute_difference);

The” num2str “function converts a numeric value to a string

representation.
----------------------------------Output-----------------------------------------

Values of y:
[2.718281828459045
2.593742460089938
2.704813829432384
2.709453232511283
2.710558581469458
2.710741261316918
2.710743777872953
2.710743979387769]

Value of e: 2.718281828459045

Absolute Differences between y and e:

[0.000000000000000
0.000048468370892
0.000038051007643
0.000038682052236
0.000023247016600
0.000004759962158
0.000003050584087
0.000002850569126
The num2str function converts a numeric value to a string
representation.

7.

% Part a: n = 100
n_a = 1:100;
sum_a = sum(1 ./ n_a.^2);
approximation_a = pi^2 / 6;

% Part b: n = 1000
n_b = 1:1000;
sum_b = sum(1 ./ n_b.^2);
approximation_b = pi^2 / 6;

% Part c: n = 10000
n_c = 1:10000;
sum_c = sum(1 ./ n_c.^2);
approximation_c = pi^2 / 6;

% Display results
disp(['Sum for n = 100: ', num2str(sum_a)]);
disp(['Approximation for n = 100: ',
num2str(approximation_a)]);
disp(['Sum for n = 1000: ', num2str(sum_b)]);
disp(['Approximation for n = 1000: ',
num2str(approximation_b)]);
disp(['Sum for n = 10000: ', num2str(sum_c)]);
disp(['Approximation for n = 10000: ',
num2str(approximation_c)]);

-------------------------(OR-Alternate program)--------------------------

% Formula for the sum of the infinite series

sum_of_series = pi^2 / 6;

% Calculate the sum of the series for n = 100

n100 = 1:100;
sum_n100 = sum(1 ./ n100.^2);

% Calculate the sum of the series for n = 1,000

n1000 = 1:1000;
sum_n1000 = sum(1 ./ n1000.^2);

% Calculate the sum of the series for n = 10,000

n10000 = 1:10000;
sum_n10000 = sum(1 ./ n10000.^2);

% Display the results

disp('n = 100:');
disp(sum_n100);

disp('n = 1,000:');
disp(sum_n1000);

disp('n = 10,000:');
disp(sum_n10000);
-------------------------------Output------------------------------------------

n = 100:
1.6439340668482264

n = 1,000:
1.6448340718480652

n = 10,000:
1.6449340668480652

8.

% Function to calculate the sum of the series

sum_of_series = @(n) 0.5 * (log(2 * n + 2) - log(2 * n + 1));

% Calculate the sum of the series for n = 50

n50 = 0:50;
sum_n50 = sum(1 ./ ((2 * n50 + 1) .* (2 * n50 + 2)));

% Calculate the sum of the series for n = 500

n500 = 0:500;
sum_n500 = sum(1 ./ ((2 * n500 + 1) .* (2 * n500 + 2)));

% Calculate the sum of the series for n = 5,000

n5000 = 0:5000;
sum_n5000 = sum(1 ./ ((2 * n5000 + 1) .* (2 * n5000 + 2)));

% Calculate the value of ln 2

ln_2 = log(2);

% Compare the values obtained to ln 2

disp('n = 50:');
disp(sum_n50);
disp('vs.');
disp(ln_2);

disp('n = 500:');
disp(sum_n500);
disp('vs.');
disp(ln_2);

disp('n = 5,000:');
disp(sum_n5000);
disp('vs.');
disp(ln_2);

---------------------------------Output----------------------------------------

n = 50:
0.6907394138314922
vs.
0.6931471805599453

n = 500:
0.693147179391284
vs.
0.6931471805599453

n = 5,000:
0.693147180538616
vs.
0.6931471805599453

9.
a) **Calculate A+B and B+A to show that addition of matrices
is commutative.

% Define matrices A, B
A = [5, 2, 4; 1, 7, -3; 6, -10, 0];
B = [11, 5, -3; 0, -12, 4; 2, 6, 1];

% Calculate A + B and B + A
sum_AB = A + B;
sum_BA = B + A;

% Display the results

disp('A + B:');
disp(sum_AB);
disp('B + A:');
disp(sum_BA);
```

b) **Calculate A+ (B+ C) and (A+B) + C to show that addition of

matrices is associative.

% Define matrix C
C = [7, 14, 1; 10, 3, -2; 8, -5, 9];

% Calculate A + (B + C) and (A + B) + C
sum_B_C = B + C;
sum_A_B_C = A + sum_B_C;
sum_A_B = A + B;
sum_A_B_C_alt = sum_A_B + C;

% Display the results

disp('A + (B + C):');
disp(sum_A_B_C);
disp('(A + B) + C:');
disp(sum_A_B_C_alt);
```

c) **Calculate 5(A+C) and 5A + 5C to show that scalar

multiplication is distributive over addition.

% Calculate 5(A + C) and 5A + 5C

scaled_sum_AC = 5 * (A + C);
scaled_A_scaled_C = 5 * A + 5 * C;

% Display the results

disp('5(A + C):');
disp(scaled_sum_AC);
disp('5A + 5C:');
disp(scaled_A_scaled_C);
```

d) **Calculate A*(B+C) and A*B + A*C to show that matrix

multiplication is distributive over addition.**
% Calculate (B + C) and A*(B + C)
sum_B_C = B + C;
product_A_sum_BC = A * sum_B_C;

% Calculate A*B and A*C

product_A_B = A * B;
product_A_C = A * C;

% Calculate A*B + A*C

sum_product_AB_AC = product_A_B + product_A_C;

% Display the results

disp('(B + C):');
disp(sum_B_C);
disp('A * (B + C):');
disp(product_A_sum_BC);
disp('A * B + A * C:');
disp(sum_product_AB_AC);

---------------------------------Output---------------------------------------

% Part a)
A + B:
[16 7 1]
[11 15 1]
[8 -4 1]
B + A:
[16 7 1]
[11 15 1]
[8 -4 1]

% Part b)
A + (B + C):
[38 31 2]
[11 13 -5]
[26 3 10]
(A + B) + C:
[38 31 2]
[11 13 -5]
[26 3 10]

% Part c)
5(A + C):
[190 155 10]
[55 15 -10]
[140 -25 45]
5A + 5C:
[190 155 10]
[55 15 -10]
[140 -25 45]

% Part d)
(B + C):
[18 29 -1]
[10 3 -2]
[26 1 10]
A * (B + C):
[38 31 2]
[11 13 -5]
[26 3 10]
A * B + A * C:
[38 31 2]
[11 13 -5]
[26 3 10]

10.

% Given matrices
A = [5, 2, 4; 1, 7, -3; 6, -10, 0];
B = [11, 5, -3; 0, -12, 4; 2, 6, 1];
C = [7, 14, 1; 10, 3, -2; 8, -5, 9];

% a) Does A*B = B*A?

result_a = isequal(A*B, B*A);

% b) Does A*(B*C) = (A*B)*C?

result_b = isequal(A*(B*C), (A*B)*C);

% c) Does (A*B)^t = B^t*A^t?

result_c = isequal((A*B)', B'*A');
% d) Does (A+B)^t = A^t + B^t?
result_d = isequal((A+B)', A'+B');

% Display results
disp('a) Does A*B = B*A?');
disp(result_a);

disp('b) Does A*(B*C) = (A*B)*C?');

disp(result_b);

disp('c) Does (A*B)^t = B^t*A^t?');

disp(result_c);

disp('d) Does (A+B)^t = A^t + B^t?');

disp(result_d);

----------------------------------Output----------------------------------

a) Does A*B = B*A?

False
b) Does A*(B*C) = (A*B)*C?
True
c) Does (A*B)^t = B^t*A^t?
True
d) Does (A+B)^t = A^t + B^t?
True
11.

% Coefficients matrix A
A = [5 4 -2 6; 3 6 6 4.5; 6 12 -2 16; 4 -2 2 -4];

% Constants vector b
b = [4; 13.5; 20; 6];

% Solve the system of equations

solution = A\b;

% Display the solution

disp('Solution:');
disp(['x = ', num2str(solution(1))]);
disp(['y = ', num2str(solution(2))]);
disp(['z = ', num2str(solution(3))]);
disp(['w = ', num2str(solution(4))]);

-----------------------------Output--------------------------

Solution:
x = 0.75
y = 1.5
z = -1.5
w = 1.25
12.
% Define the firing angles in degrees
theta = 5:5:85;

% Convert the firing angles to radians

theta_rad = deg2rad(theta);

% Calculate the distance traveled by the

projectile
g = 9.81; % m/s^2
v0 = 750; % m/s
d = (v0^2 * sin(2 * theta_rad)) / g;

% Create a 17 × 2 matrix to store the

results
results = zeros(length(theta), 2);
results(:, 1) = theta;
results(:, 2) = round(d);

% Display the results

disp(results);

----------------Output----------------

5 9957
10 19611
15 28670
20 36857
25 43925
30 49657
35 53881
40 56468
 45 57339
50 56468
55 53881
60 49657
65 43925
70 36857
75 28670
80 19611
85 9957

13.

% Given data
vA = 680; % m/s (initial velocity of projectile A)
vB = 780; % m/s (initial velocity of projectile B)
thetaA = 65; % degrees (launch angle of projectile A)
thetaB = 42; % degrees (launch angle of projectile B)
g = 9.81; % m/s^2 (acceleration due to gravity)

% Calculations
% Calculate time of flight for projectiles A and B
tA = (2 * vA * sind(thetaA)) / g;
tB = (2 * vB * sind(thetaB)) / g;

% Determine which projectile hits the ground first

if tA < tB
tf = tA;
else
tf = tB;
end

% Create a vector t with 11 equally spaced elements from 0 to

tf
t = linspace(0, tf, 11);

% Calculate horizontal distances covered by projectiles A and

B at each time t
xA = vA * cosd(thetaA) * t;
xB = vB * cosd(thetaB) * t;

% Calculate distance between the two projectiles at each time

in vector t
distance_between = abs(xA - xB);

% Display the calculated distances between the projectiles at

each time
disp('Time (s):');
disp(t);
disp('Distance between projectiles (m):');
disp(distance_between);

OR
% Define the initial conditions
v_A = 680;
v_B = 780;
theta_A = 65 * pi / 180;
theta_B = 42 * pi / 180;
% Calculate the time of flight for each projectile
t_A = 2 * v_A * sin(theta_A) / 9.81;
t_B = 2 * v_B * sin(theta_B) / 9.81;

% Determine which projectile will hit the ground first

if t_A < t_B
disp('Projectile B will hit the ground first.');
else
disp('Projectile A will hit the ground first.');
end

% Create a vector t with 11 equally spaced elements

t = linspace(0, t_B, 11);

% Calculate the distance between the two projectiles at eleven

times in vector t
dA = v_A * t * cos(theta_A);
dB = v_B * t * cos(theta_B);

distance = dA - dB;

% Display the distance between the two projectiles at eleven

times in vector t
disp(distance);

---------------------------Output------------------------------

Projectile B will hit the ground first.

[0 118.6 237.2 355.8 474.4 593 711.6 830.2 948.8
1067.4 1186]