32.

Interpolation in MATLAB:
Interpolation is the process of estimating values between two known
values. In MATLAB, you can use the interp1 function for various
interpolation methods. Here's a brief example using linear interpolation:

% Example data

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

y = [10, 15, 5, 20];

% Points for interpolation

xi = 2.5;

% Perform linear interpolation

yi = interp1(x, y, xi, 'linear');

% Display result

disp(['Interpolated value at x = ', num2str(xi), ' is ', num2str(yi)]);

33. Simpson's 3/8 Rule in MATLAB:

Simpson's 3/8 rule for numerical integration can be implemented in
MATLAB as follows:

% Function to integrate

fun = @(x) 2*x^3 - 4*x + 1;

% Integration limits

x1 = 2;

x2 = 4;

% Step value
h = 0.5;

% Simpson's 3/8 rule

integral_result = (h/8) * (fun(x1) + 3*fun(x1 + h) + 3*fun(x1 + 2*h) + fun(x2));

% Display result

disp(['Integral using Simpson''s 3/8 rule: ', num2str(integral_result)]);

34. Newton-Raphson Method in MATLAB:

Newton-Raphson's method is used for finding the roots of a function.
Here's an example using MATLAB:

% Define the function and its derivative

f = @(x) x^4 - 2*x^3 + x^2 - 3*x + 3;

df = @(x) 4*x^3 - 6*x^2 + 2*x - 3;

% Initial guess

x0 = 1;

% Perform Newton-Raphson iteration

tolerance = 1e-6;

max_iterations = 100;

for i = 1:max_iterations

x1 = x0 - f(x0)/df(x0);

% Check for convergence

if abs(x1 - x0) < tolerance

break;

end

x0 = x1;

end

% Display result

disp(['Root found using Newton-Raphson method: ', num2str(x1)]);

35. Using fzero in MATLAB:

The fzero function can be used to find the roots of a given function. Here's
an example:

% Define the function

fun = @(x) x^4 - 3*x^2 + 7*x^2 - 9*x + 3;

% Initial guess

x0 = 1;

% Use fzero to find the root

root = fzero(fun, x0);

% Display result

disp(['Root found using fzero: ', num2str(root)]);

### 15. Steps to Solve Nonlinear Equations in MATLAB:

To solve nonlinear equations in MATLAB, you can use the `fsolve` function. Here are the general
steps:

1. Define the function or system of functions representing the nonlinear equations.

2. Provide an initial guess for the solution.

3. Use `fsolve` to find the root of the equations.

Example:

```matlab

% Define the function

fun = @(x) x^2 - 4;

% Provide an initial guess

x0 = 1;

% Solve the nonlinear equation

solution = fsolve(fun, x0);

% Display result

disp(['Solution to the equation: ', num2str(solution)]);

```

### 16. ODE23 and interp1:

- **ODE23 (Ordinary Differential Equation Solver):** ODE23 is a MATLAB solver for initial value
problems of ordinary differential equations (ODEs). It uses a variable-step, variable-order Runge-
Kutta method to approximate the solution. Usage involves defining the ODE and calling `ode23` with
appropriate parameters.
- **interp1:** `interp1` is a MATLAB function used for 1-D interpolation. It interpolates the values of
a function at specified points using various interpolation methods such as linear, spline, and pchip.

### 17. Matrix Factorization Methods:

Matrix factorization methods are used to decompose a matrix into the product of two or more
matrices. Some common methods include:

- **LU Decomposition:** Decomposes a matrix into the product of a lower triangular matrix (L) and
an upper triangular matrix (U).

- **QR Decomposition:** Decomposes a matrix into the product of an orthogonal matrix (Q) and an
upper triangular matrix (R).

- **Singular Value Decomposition (SVD):** Decomposes a matrix into the product of three matrices -
U, Σ (diagonal matrix of singular values), and V'.

### 18. Trapezoidal Rule for Integration:

To evaluate ∫ 𝑥𝑥^2𝑑𝑥 from 0 to 4 using the Trapezoidal rule in MATLAB:

```matlab

% Define the function

fun = @(x) x^2;

% Integration limits

a = 0;

b = 4;
% Step length

h = 1;

% Trapezoidal rule

integral_result = h/2 * (fun(a) + 2*sum(fun(a+h:h:h*(b/h-1))) + fun(b));

% Display result

disp(['Integral using Trapezoidal rule: ', num2str(integral_result)]);

```

### 19. Solving First Order Equations using ODE23:

To solve a first-order ordinary differential equation (ODE) using `ode23`:

```matlab

% Define the ODE

ode = @(t, y) -2*y;

% Time span

tspan = [0, 5];

% Initial condition

y0 = 1;

% Solve the ODE using ode23

[t, y] = ode23(ode, tspan, y0);

% Plot the solution

plot(t, y);

xlabel('Time');

ylabel('Solution y(t)');

```

### 20. 2-D Interpolation:

2-D interpolation is the process of estimating values between grid points in a two-dimensional space.
In MATLAB, you can use the `interp2` function. Here's a simple example:

```matlab

% Example data

x = 1:3;

y = 1:3;

[X, Y] = meshgrid(x, y);

Z = X.^2 + Y.^2;

% Interpolation points

xi = 1.5;

yi = 2.5;

% Perform 2-D interpolation

zi = interp2(x, y, Z, xi, yi, 'linear');

% Display result

disp(['Interpolated value at (', num2str(xi), ',', num2str(yi), ') is ', num2str(zi)]);

```

21.To solve a system of linear equations using the Gauss elimination method,
you can follow these steps:

1. Create an augmented matrix by combining the coefficient matrix and the right-hand side vector.

2. Perform row operations to transform the augmented matrix into an upper triangular form.

3. Back-substitute to find the values of the variables.

Here's the MATLAB code for solving the given system of linear equations:

```matlab

function x = gaussElimination(A, b)

% Augment the matrix

AugmentedMatrix = [A, b];

% Size of the matrix

[m, n] = size(AugmentedMatrix);

% Forward elimination

for k = 1:min(m-1, n)

% Partial pivoting

[~, maxRow] = max(abs(AugmentedMatrix(k:m, k)));

maxRow = maxRow + k - 1;

AugmentedMatrix([k, maxRow], :) = AugmentedMatrix([maxRow, k], :);

% Elimination

for i = k+1:m

factor = AugmentedMatrix(i, k) / AugmentedMatrix(k, k);

AugmentedMatrix(i, :) = AugmentedMatrix(i, :) - factor * AugmentedMatrix(k, :);

end

end

% Back substitution

x = zeros(n, 1);

for i = m:-1:1

x(i) = (AugmentedMatrix(i, end) - AugmentedMatrix(i, i+1:end-1) * x(i+1:end)) /

AugmentedMatrix(i, i);

end

end

% Given coefficients matrix and right-hand side vector

A = [2 1 1; -1 1 -1; 1 2 3];

b = [2; 3; -10];

% Solve the system using Gauss elimination

solution = gaussElimination(A, b);

% Display the result

disp('Solution to the system of linear equations:');

disp(solution);

```

### 22. Solving Coupled Nonlinear ODEs in MATLAB:

```matlab

% Define the system of ODEs

ode = @(t, u) [u(1) + u(2) - u(1)*(u(1)^2 + u(2)^2); -u(1) + u(2) - u(2)*(u(1)^2 + u(2)^2)];

% Initial conditions

initial_conditions = [2; 2];

% Time span

tspan = [0, 20];

% Solve the ODEs

[t, sol] = ode45(ode, tspan, initial_conditions);

% Plot x vs t

figure;

plot(t, sol(:, 1), 'LineWidth', 2);

xlabel('Time (t)');

ylabel('x(t)');

title('Plot of x vs t');

% Hold on for overlay plot

hold on;

% Plot y vs t

figure;

plot(t, sol(:, 2), 'LineWidth', 2);

xlabel('Time (t)');

ylabel('y(t)');

title('Plot of y vs t');
```

### 23. Numerical Differentiation:

Numerical differentiation involves approximating the derivative of a function using finite differences.
Here's a simple example:

```matlab

% Define a function

f = @(x) x^2;

% Choose a point for differentiation

x0 = 2;

% Calculate numerical derivative using finite differences

h = 0.01;

numerical_derivative = (f(x0 + h) - f(x0 - h)) / (2 * h);

disp(['Numerical derivative at x = ', num2str(x0), ': ', num2str(numerical_derivative)]);

```

### 24. Finding Eigenvalues and Eigenvectors:

```matlab

% Define the coefficient matrix

A = [-3 2 -1; 6 -6 7; 3 -4 4];

% Find eigenvalues and eigenvectors

[eigen_vectors, eigen_values] = eig(A);

% Display results

disp('Eigenvalues:');

disp(diag(eigen_values)');

disp('Eigenvectors:');

disp(eigen_vectors);

```

### 25. Simpson's 1/3 Rule for Integration:

```matlab

% Define the function

fun = @(x) 1./x;

% Integration limits

x1 = 1;

x2 = 2;

% Step size

h = 0.25;

% Simpson's 1/3 rule

integral_result = h/3 * (fun(x1) + 4*fun(x1 + h) + fun(x1 + 2*h));

% Display result

disp(['Integral using Simpson''s 1/3 rule: ', num2str(integral_result)]);

```

### 26. Explanation of Terms:

- **ODE3:** ODE3 is a MATLAB solver for solving stiff systems of ordinary differential equations
(ODEs). It is part of the ODE suite along with ODE45 and ODE23.

- **fzero:** `fzero` is a MATLAB function for finding a root of a single-variable function. It uses
iterative methods like the bisection method.

- **fprintf:** `fprintf` is a MATLAB function used for formatted printing to the command window or
a file. It allows you to control the format of the output.

### 27. MATLAB Program for Linear and Spline Interpolation of Sine Function:

```matlab

% Coarsely sampled sine function

x = 0:pi/4:2*pi;

y = sin(x);

% Fine grid for interpolation

x_interp = 0:pi/16:2*pi;

% Linear interpolation

y_linear = interp1(x, y, x_interp, 'linear');

% Spline interpolation

y_spline = interp1(x, y, x_interp, 'spline');

% Plot the results

figure;

plot(x, y, 'o-', 'DisplayName', 'Coarse Sampled Sine Function');

hold on;

plot(x_interp, y_linear, 'x-', 'DisplayName', 'Linear Interpolation');

plot(x_interp, y_spline, 's-', 'DisplayName', 'Spline Interpolation');

xlabel('x');

ylabel('f(x)');

legend('show');

title('Linear and Spline Interpolation of Sine Function');

```

### 28. Trapezoidal Rule for Integration:

```matlab

% Function to integrate

fun = @(x) 2*x^3 - 4*x + 1;

% Integration limits

x1 = 2;

x2 = 4;

% Step value

h = 0.5;

% Trapezoidal rule

integral_result = h/2 * (fun(x1) + fun(x2));

% Display result

disp(['Integral using Trapezoidal rule: ', num2str(integral_result)]);

```

### 29. Lagrange's Interpolation in MATLAB:

```matlab

% Experimental data

x_data = [-1.0, 0.0, 0.5, 1.0, 2.5, 3.0];

y_data = [3.0, -2.0, -0.375, 3.0, 16.125, 19.0];

% Point to interpolate

x_interp_point = 1.8;

% Lagrange's interpolation formula

interp_result = lagrange_interpolation(x_data, y_data, x_interp_point);

% Display result

disp(['Interpolated value at x = ', num2str(x_interp_point), ': ', num2str(interp_result)]);

% Lagrange's interpolation function

function result = lagrange_interpolation(x_data, y_data, x_interp_point)

n = length(x_data);

result = 0;

for i = 1:n
term = y_data(i);

for j = 1:n

if j ~= i

term = term * (x_interp_point - x_data(j)) / (x_data(i) - x_data(j));

end

end

result = result + term;

end

end

```

### 30. Solving Linear System Equations using `solve` and `linsolve`:

```matlab

% Coefficient matrix

A = [2, 3, -1; 1, 2, -1; -2, -1, 1];

% Right-hand side vector

B = [1; 4; -3];

% Using solve

solution_solve = solve(A*B);

% Using linsolve

solution_linsolve = linsolve(A, B);

% Display results

disp('Solution using solve:');

disp(solution_solve);

disp('Solution using linsolve:');

disp(solution_linsolve);

```

### 31. Trapezoidal 3/8 Rule for Interpolation:

```matlab

% Given data points

x = [1.4, 1.6, 1.8, 2, 2.2];

y = [4.0552, 4.953, 6.0436, 7.3891, 9.025];

% Step size

h = x(2) - x(1);

% Trapezoidal 3/8 rule

integral_result = (3/8) * h * (y(1) + 3*(y(2) + y(3)) + y(4) + 3*y(5));

% Display result

disp(['Integral using Trapezoidal 3/8 rule: ', num2str(integral_result)]);

```