COMPUTATIONAL MATHEMATICS LAB

1. Python code for solving a system of linear equation using Gauss Elimination
Method
defgauss(A):
m =len(A)
assertall([len(row) == m +1for row inA[1:]]), "Matrix rows have non-uniform
length"
n = m +1
for kinrange(m):
pivots = [abs(A[i][k]) foriinrange(k, m)]
i_max=pivots.index(max(pivots)) + k
# Check for singular matrix
assertA[i_max][k] !=0, "Matrix is singular!"
# Swap rows
A[k], A[i_max] =A[i_max], A[k]

foriinrange(k +1, m):

f =A[i][k] /A[k][k]
for j inrange(k +1, n):
A[i][j] -=A[k][j] * f

# Fill lower triangular matrix with zeros:

A[i][k] =0
# Solve equation Ax=b for an upper triangular matrix A
x = []
foriinrange(m -1, -1, -1):
x.insert(0, A[i][m] /A[i][i])
for kinrange(i-1, -1, -1):
A[k][m] -=A[k][i] *x[0]
return x

1.Generate a MATLAB code for solving a system of linear equation using Gauss
Elimination method.
% Matlab Program to solve (nxn) system equation
% by using Gaussian Elimination method
clear ; clc ; close all
n = input('Please Enter the size of the equation system n = ') ;
C = input('Please Enter the elements of the Matrix C ' ) ;
b = input('Please Enter the elements of the Matrix b ' ) ;
dett = det(C)
if dett == 0
print('This system unsolvable because det(C) = 0 ')
else
b = b'
A=[C b]
for j = 1:(n-1)
for i= (j+1) : n
mult = A(i,j)/A(j,j) ;
for k= j:n+1
A(i,k) = A(i,k) - mult*A(j,k) ;
A
end
end
end
for p = n:-1:1
for r = p+1:n
x(p) = A(p,r)/A(p,r-1)
end
end
end

Problem:
x1 + 2x2 - x3 = 3
2x1 + x2 - 2x3 = 3
-3x1 + x2 + x3 = -6
C = [ 1 2 -1 ; 2 1 -2 ; -3 1 1 ]
b= [ 3 3 -6 ]

Output:
Please Enter the size of the equation system n = 3
Please Enter the elements of the Matrix C [ 1 2 -1 ; 2 1 -2 ; -3 1 1 ]
Please Enter the elements of the Matrix b [ 3 3 -6 ]

dett =

6.0000
b=
3
3
-6
A=
1 2 -1 3
2 1 -2 3
-3 1 1 -6
A=
 1 2 -1 3
0 1 -2 3
-3 1 1 -6

A=
1 2 -1 3
0 -3 -2 3
-3 1 1 -6
A=
1 2 -1 3
0 -3 0 3
-3 1 1 -6
A=
1 2 -1 3
0 -3 0 -3
-3 1 1 -6
A=
1 2 -1 3
0 -3 0 -3
0 1 1 -6
A=
1 2 -1 3
0 -3 0 -3
0 7 1 -6
A=
1 2 -1 3
0 -3 0 -3
0 7 -2 -6
A=
1 2 -1 3
0 -3 0 -3
0 7 -2 3
A=
1 2 -1 3
0 -3 0 -3
0 0 -2 3
A=
1 2 -1 3
0 -3 0 -3
0 0 -2 3
A=
1 2 -1 3
0 -3 0 -3
0 0 -2 -4

2.Python code for LU Decomposition (Factorization)

importpprint

defmult_matrix(M, N):
"""Multiply square matrices of same dimension M and N"""

# Converts N into a list of tuples of columns

tuple_N=zip(*N)

# Nested list comprehension to calculate matrix multiplication

return[[sum(el_m*el_nforel_m,el_ninzip(row_m,col_n))forcol_nintuple_N]forrow_
min M]

defpivot_matrix(M):
"""Returns the pivoting matrix for M, used in Doolittle's method."""
m =len(M)

# Create an identity matrix, with floating point values

id_mat=[[float(i==j)foriinxrange(m)]for j inxrange(m)]

# Rearrange the identity matrix such that the largest element of

# each column of M is placed on the diagonal of of M
for j inxrange(m):
row =max(xrange(j, m), key=lambda i:abs(M[i][j]))
ifj != row:
# Swap the rows
id_mat[j],id_mat[row]=id_mat[row],id_mat[j]

returnid_mat

deflu_decomposition(A):
"""Performs an LU Decomposition of A (which must be square)
into PA = LU. The function returns P, L and U."""
n =len(A)

# Create zero matrices for L and U

L =[[0.0]* n foriinxrange(n)]
U =[[0.0]* n foriinxrange(n)]

# Create the pivot matrix P and the multipled matrix PA

P =pivot_matrix(A)
PA =mult_matrix(P, A)

# Perform the LU Decomposition

for j inxrange(n):
# All diagonal entries of L are set to unity
L[j][j]=1.0

# LaTeX: u_{ij} = a_{ij} - \sum_{k=1}^{i-1} u_{kj} l_{ik}

foriinxrange(j+1):
s1 =sum(U[k][j]* L[i][k]for kinxrange(i))
U[i][j]= PA[i][j]- s1

# LaTeX: l_{ij} = \frac{1}{u_{jj}} (a_{ij} - \sum_{k=1}^{j-1} u_{kj} l_{ik} )

foriinxrange(j, n):
s2 =sum(U[k][j]* L[i][k]for kinxrange(j))
L[i][j]=(PA[i][j]- s2)/ U[j][j]

return(P, L, U)

A =[[7,3,-1,2],[3,8,1,-4],[-1,1,4,-1],[2,-4,-1,6]]
P, L, U =lu_decomposition(A)

print"A:"
pprint.pprint(A)

print"P:"
pprint.pprint(P)

print"L:"
pprint.pprint(L)

print"U:"
pprint.pprint(U)
The output from the pure Python implementation is given below:
A:
[[7, 3, -1, 2], [3, 8, 1, -4], [-1, 1, 4, -1], [2, -4, -1, 6]]
P:
[[1.0, 0.0, 0.0, 0.0],
[0.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0]]
L:
[[1.0, 0.0, 0.0, 0.0],
[0.42857142857142855, 1.0, 0.0, 0.0],
[-0.14285714285714285, 0.2127659574468085, 1.0, 0.0],
[0.2857142857142857, -0.7234042553191489, 0.0898203592814371,
1.0]]
U:
[[7.0, 3.0, -1.0, 2.0],
 [0.0, 6.714285714285714, 1.4285714285714286, -
4.857142857142857],
[0.0, 0.0, 3.5531914893617023, 0.31914893617021267],
[0.0, 0.0, 0.0, 1.88622754491018]]
None

2. Generate a MATLAB code for LU Decomposition method.

clc; clear all;close all;
A = [1 3 4 8
2123
4358
9 2 7 4];
B = [1
1
1
1];
matrixSize=length(A);
Lower=zeros(size(A));
Upper=zeros(size(A));

Lower(:,1)= A(:,1); %Set the first column of L to the frist column of A

Upper(1,:)=A(1,:)/Lower(1,1); % Create the first row of upper, divide by L(1,1)

Upper(1,1)=1; % Start the identity matrix

for k=2:matrixSize
for j=2:matrixSize
for i=j:matrixSize
Lower(i,j)=A(i,j) - dot(Lower(i,1:j-1),Upper(1:j-1,j));
end
Upper(k,j)=(A(k,j)-dot(Lower(k,1:k-1),Upper(1:k-1,j)))/Lower(k,k);
end
end
Upper
Lower
%L*Y=B
Y = zeros(matrixSize, 1);
% BASE CASE, SOLVE THE FIRST ONE
Y(1) = B(1);
for row = 2 : matrixSize %2 - number or rows
Y(row) = B(row);
for col = 1 : row - 1 %1 - row number
Y(row) = Y(row) - Lower(row, col) * Y(col);
end
Y(row) = Y(row) / Lower(row, row)
end
Y
%U*X=Y
X = zeros(matrixSize, 1);

X(matrixSize) = Y(matrixSize) / Upper(matrixSize,matrixSize);

for row = matrixSize - 1 : -1 : 1 %second to last row - 1

temp = 0;
for col = matrixSize : -1 : 1 %number of rows to row
temp = temp + Upper(row,col) * X(col);
end
X(row) = (Y(row) - temp) / Upper(row,row);
end
Output:
Upper =

1.0000 3.0000 4.0000 8.0000

0 1.0000 1.2000 2.6000

0 0 1.0000 3.0000

0 0 0 1.0000

Lower =

1.0000 0 0 0

2.0000 -5.0000 0 0

4.0000 -9.0000 -0.2000 0

9.0000 -25.0000 1.0000 -6.0000

Y=

1.0000

0.2000

Y=

1.0000

0.2000

6.0000

Y=
 1.0000

0.2000

6.0000

1.5000

Y=

1.0000

0.2000

6.0000

1.5000

3.Python code for Iterative methods to solve equations using Jacobi Iteration.

from pprint import pprint

from numpy import array, zeros, diag, diagflat, dot

def jacobi(A,b,N=25,x=None):

"""Solves the equation Ax=b via the Jacobi iterative method."""

# Create an initial guess if needed

if x is None:

x = zeros(len(A[0]))

# Create a vector of the diagonal elements of A

# and subtract them from A

D = diag(A)

R = A - diagflat(D)

# Iterate for N times

for i in range(N):
 x = (b - dot(R,x)) / D

return x

A = array([[2.0,1.0],[5.0,7.0]])

b = array([11.0,13.0])

guess = array([1.0,1.0])

sol = jacobi(A,b,N=25,x=guess)

print "A:"

pprint(A)

print "b:"

pprint(b)

print "x:"

pprint(sol)

Output:

A:

array([[ 2., 1.],

[ 5., 7.]])

b:

array([ 11., 13.])

x:

array([ 7.11110202, -3.22220342])

3. Generate a MATLAB code for Iterative methods to solve equations using Jacobi
Iteration
Program:
clc;clear all;close all
syms x y z
jacobian([x*y*z, y^2, x + z], [x, y, z])

Output:
[ y*z, x*z, x*y]
[ 0, 2*y, 0]
[ 1, 0, 1]
%first column output is differentiate with respect to x
%second column output is differentiate with respect to y
%third column output is differentiate with respect to z

Example: Differentiate with respect to x

jacobian([x*y*z, y^2, x + z], [x])
ans =
y*z
0
1
4.Python code for Curve fitting
i. Straight line fit ii. Polynomial Curve fit
1.
import numpy as np

# curve-fit() function imported from scipy

from scipy.optimize import curve_fit

from matplotlib import pyplot as plt

# numpy.linspace with the given arguments

# produce an array of 40 numbers between 0

# and 10, both inclusive

x = np.linspace(0, 10, num = 40)

# y is another array which stores 3.45 times

# the sine of (values in x) * 1.334.

# The random.normal() draws random sample

# from normal (Gaussian) distribution to make

# them scatter across the base line

y = 3.45 * np.sin(1.334 * x) + np.random.normal(size = 40)

# Test function with coefficients as parameters

def test(x, a, b):

return a * np.sin(b * x)

# curve_fit() function takes the test-function

# x-data and y-data as argument and returns

# the coefficients a and b in param and

# the estimated covariance of param in param_cov

param, param_cov = curve_fit(test, x, y)

print("Sine funcion coefficients:")

print(param)

print("Covariance of coefficients:")

print(param_cov)

# ans stores the new y-data according to

# the coefficients given by curve-fit() function

ans = (param[0]*(np.sin(param[1]*x)))

'''Below 4 lines can be un-commented for plotting results

using matplotlib as shown in the first example. '''

# plt.plot(x, y, 'o', color ='red', label ="data")

# plt.plot(x, ans, '--', color ='blue', label ="optimized data")

# plt.legend()
# plt.show()

Output:

Sine function coefficients:

[ 3.66474998 1.32876756]
Covariance of coefficients:
[[ 5.43766857e-02 -3.69114170e-05]
[ -3.69114170e-05 1.02824503e-04]]

4.Generate a MATLAB code for Curve fitting

Program 1:
% cdate is a column vector containing the years 1790 to 1990 in 10-year
increments.
% pop is a column vector with the U.S. population figures that correspond to
the years in cdate .
plot( cdate, pop, 'o' )
[population2, gof] = fit( cdate, pop, 'poly2' );
figure
plot( population2, cdate, pop );
% Move the legend to the top left corner.
legend( 'Location', 'NorthWest' );

Output:
Figure: Plotting Data

Figure: Polynomial Curve Fitted Data

Program 2:
population3 = fit( cdate, pop, 'poly3', 'Normalize', 'on' );
plot( cdate, pop, 'o' );

plot( population3, 'predobs' )

Fig: Normalization of data

5. Generate a MATLAB program for Fourier Transform

Program:
x=[1 2 3 4];
fft(x)
Output:
10.0000 + 0.0000i -2.0000 + 2.0000i -2.0000 + 0.0000i -2.0000 - 2.0000i

6. Python code for Euler’s method differential equations

# Euler method python program

# function to be solved
deff(x,y):
returnx+y

# or
# f = lambda x: x+y
# Euler method
defeuler(x0,y0,xn,n):

# Calculating step size

h =(xn-x0)/n

print('\n-----------SOLUTION-----------')
print('------------------------------')
print('x0\ty0\tslope\tyn')
print('------------------------------')
foriinrange(n):
slope =f(x0, y0)
yn= y0 + h * slope
print('%.4f\t%.4f\t%0.4f\t%.4f'%(x0,y0,slope,yn))
print('------------------------------')
y0 =yn
x0 = x0+h

print('\nAt x=%.4f, y=%.4f'%(xn,yn))

# Inputs
print('Enter initial conditions:')
x0 =float(input('x0 = '))
y0 =float(input('y0 = '))

print('Enter calculation point: ')

xn=float(input('xn = '))

print('Enter number of steps:')

step =int(input('Number of steps = '))

# Euler method call

euler(x0,y0,xn,step)

Output
Enter initial conditions:
x0 = 0
y0 = 1
Enter calculation point:
xn = 1
Enter number of steps:
Number of steps = 10

-----------SOLUTION-----------
------------------------------
x0 y0 slope yn
------------------------------
0.0000 1.0000 1.0000 1.1000
------------------------------
0.1000 1.1000 1.2000 1.2200
------------------------------
0.2000 1.2200 1.4200 1.3620
------------------------------
0.3000 1.3620 1.6620 1.5282
------------------------------
0.4000 1.5282 1.9282 1.7210
------------------------------
0.5000 1.7210 2.2210 1.9431
------------------------------
0.6000 1.9431 2.5431 2.1974
------------------------------
0.7000 2.1974 2.8974 2.4872
------------------------------
0.8000 2.4872 3.2872 2.8159
------------------------------
0.9000 2.8159 3.7159 3.1875
------------------------------

At x=1.0000, y=3.1875

6. Generate a MATLAB program for Eulers Method differential Equations

Program:
% euler(n) returns the nth Euler number
% euler(n,x) returns the nth Euler polynomial.
syms n x
diff(euler(n,x^2), x)

Output:
2*n*x*euler(n - 1, x^2)

7. Python code for Runge – Kutta method differential equations

# RK-4 method python program

# function to be solved
deff(x,y):
returnx+y

# or
# f = lambda x: x+y

# RK-4 method
defrk4(x0,y0,xn,n):

# Calculating step size

h =(xn-x0)/n

print('\n--------SOLUTION--------')
print('-------------------------')
print('x0\ty0\tyn')
print('-------------------------')
foriinrange(n):
k1 = h *(f(x0, y0))
k2 = h *(f((x0+h/2),(y0+k1/2)))
k3 = h *(f((x0+h/2),(y0+k2/2)))
k4 = h *(f((x0+h),(y0+k3)))
k =(k1+2*k2+2*k3+k4)/6
yn= y0 + k
print('%.4f\t%.4f\t%.4f'%(x0,y0,yn))
print('-------------------------')
y0 =yn
x0 = x0+h

print('\nAt x=%.4f, y=%.4f'%(xn,yn))

# Inputs
print('Enter initial conditions:')
x0 =float(input('x0 = '))
y0 =float(input('y0 = '))

print('Enter calculation point: ')

xn=float(input('xn = '))

print('Enter number of steps:')

step =int(input('Number of steps = '))
# RK4 method call
rk4(x0,y0,xn,step)

Output

Enter initial conditions:

x0 = 0
y0 = 1
Enter calculation point:
xn = 1
Enter number of steps:
Number of steps = 2

--------SOLUTION--------
-------------------------
x0 y0 yn
-------------------------
0.0000 1.0000 1.7969
-------------------------
0.5000 1.7969 3.4347
-------------------------

At x=1.0000, y=3.4347

7. Generate a MATLAB program for Runge-Kutte Method differential Equations

Program:
function [x, y] = FunctionBeta_Executor(F)
% Note that F function expression is defined via Function Handle: F = @(x,
y)(x+y)
% change the function as you desire
h=0.15; % step size (smaller step
size gives more accurate solutions)
x = 0:h:3; % x space
y = zeros(1,length(x)); % Memory allocation
y(1) = 5; % initial condition
for i=1:(length(x)-1)
% i=1:(length(x)-1) % calculation loop
k1 = F(x(i),y(i));
k2 = F(x(i)+0.5*h,y(i)+0.5*h*k1);
k3 = F((x(i)+0.5*h),(y(i)+0.5*h*k2));
k4 = F((x(i)+h),(y(i)+k3*h));
y(i+1) = y(i) + (1/6)*(k1+2*k2+2*k3+k4)*h; % main equation
end
figure, plot(x, y) % To see the solution results
end
Input:
FunctionBeta_Executor (@(x, y)(x+y))
Input function f(x)= (x, y)(x+y)

Output:
8 Python code for Matrices and Eigen values i. Eigen values and Eigen vectors ii. Jacobi
method
from numpy.linalg import eig

import numpy as np

a=np.array([[10,20,30,40],[1,2,3,5],[7,8,9,10],[15,25,35,45]])

values , vectors = eig(a)

print(values)

print(vectors)

Output 1:

Eigen Values

[ 6.96947758e+01 -3.22806629e+00 -4.66709488e-01 -3.59740472e-14]

Output 2:

Eigen Vectors

[[-6.28224280e-01 -7.67762260e-01 -5.75701703e-01 -4.08248290e-01]

[-7.35387665e-02 -1.62230993e-02 7.06561093e-01 8.16496581e-01]
[-2.05200662e-01 6.09975078e-01 2.05319101e-01 -4.08248290e-01]
[-7.46872808e-01 -1.95469507e-01 -3.56627310e-01 -2.73218204e-14]]

ii.import numpy as np

v = np.zeros ( [ n, n ] )
d = np.zeros ( n )

for j in range ( 0, n ):
for i in range ( 0, n ):
v[i,j] = 0.0
v[j,j] = 1.0

for i in range ( 0, n ):
d[i] = a[i,i]

bw = np.zeros ( n )
zw = np.zeros ( n )
w = np.zeros ( n )

for i in range ( 0, n ):
bw[i] = d[i]

it_num = 0
rot_num = 0

while ( it_num<it_max ):

it_num = it_num + 1
#
# The convergence threshold is based on the size of the elements in
# the strict upper triangle of the matrix.
#
thresh = 0.0
for j in range ( 0, n ):
for i in range ( 0, j ):
thresh = thresh + a[i,j] ** 2

thresh = np.sqrt ( thresh ) / float ( 4 * n )

if ( thresh == 0.0 ):
break

for p in range ( 0, n ):
 for q in range ( p + 1, n ):

gapq = 10.0 * abs ( a[p,q] )

termp = gapq + abs ( d[p] )
termq = gapq + abs ( d[q] )
#
# Annihilate tiny offdiagonal elements.
#
if ( 4<it_num and termp == abs ( d[p] ) and termq == abs ( d[q] ) ):

a[p,q] = 0.0
#
# Otherwise, apply a rotation.
#
elif( thresh<= abs ( a[p,q] ) ):

h = d[q] - d[p]
term = abs ( h ) + gapq

if ( term == abs ( h ) ):
t = a[p,q] / h
else:
theta = 0.5 * h / a[p,q]
t = 1.0 / ( abs ( theta ) + np.sqrt ( 1.0 + theta * theta ) )
if ( theta< 0.0 ):
t = - t

c = 1.0 / np.sqrt ( 1.0 + t * t )

s = t * c
tau = s / ( 1.0 + c )
h = t * a[p,q]
#
# Accumulate corrections to diagonal elements.
#
zw[p] = zw[p] - h
zw[q] = zw[q] + h
d[p] = d[p] - h
d[q] = d[q] + h

a[p,q] = 0.0
#
# Rotate, using information from the upper triangle of A only.
#
for j in range ( 0, p ):
g = a[j,p]
h = a[j,q]
a[j,p] = g - s * ( h + g * tau )
a[j,q] = h + s * ( g - h * tau )

for j in range ( p + 1, q ):
g = a[p,j]
h = a[j,q]
a[p,j] = g - s * ( h + g * tau )
a[j,q] = h + s * ( g - h * tau )

for j in range ( q + 1, n ):
g = a[p,j]
 h = a[q,j]
a[p,j] = g - s * ( h + g * tau )
a[q,j] = h + s * ( g - h * tau )
#
# Accumulate information in the eigenvector matrix.
#
for j in range ( 0, n ):
g = v[j,p]
h = v[j,q]
v[j,p] = g - s * ( h + g * tau )
v[j,q] = h + s * ( g - h * tau )

rot_num = rot_num + 1

for i in range ( 0, n ):
bw[i] = bw[i] + zw[i]
d[i] = bw[i]
zw[i] = 0.0
#
# Restore upper triangle of input matrix.
#
for j in range ( 0, n ):
for i in range ( 0, j ):
a[i,j] = a[j,i]
#
# Ascending sort the eigenvalues and eigenvectors.
#
for k in range ( 0, n - 1 ):

m = k
for l in range ( k + 1, n ):
if ( d[l] < d[m] ):
m = l

if ( k != m ):

t = d[m]
d[m] = d[k]
d[k] = t

for i in range ( 0, n ):
w[i] = v[i,m]
v[i,m] = v[i,k]
v[i,k] = w[i]

return v, d, it_num, rot_num

def jacobi_eigenvalue_test01 ( ):

#****************************************************************************
*80
#
## JACOBI_EIGENVALUE_TEST01 uses a 4x4 test matrix.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 25 September 2015
#
# Author:
#
# John Burkardt
#
import numpy as np
import platform

n = 4

a = np.array ( [ \
[ 4.0, -30.0, 60.0, -35.0, ], \
[ -30.0, 300.0, -675.0, 420.0, ], \
[ 60.0, -675.0, 1620.0, -1050.0, ], \
[ -35.0, 420.0, -1050.0, 700.0 ] ] )

print ( '' )
print ( 'JACOBI_EIGENVALUE_TEST01' )
print ( ' Python version: %s' % ( platform.python_version ( ) ) )
print ( ' JACOBI_EIGENVALUE computes the eigenvalues D' )
print ( ' and eigenvectors V of a symmetric matrix A so that A * V = D *
V.' )

r8mat_print ( n, n, a, ' Input matrix A:' )

it_max = 100

v, d, it_num, rot_num = jacobi_eigenvalue( n, a, it_max )

print ( '' )
print ( ' Number of iterations = %d' % ( it_num ) )
print ( ' Number of rotations = %d' % ( rot_num ) )

r8vec_print ( n, d, ' Eigenvalues D:' )

r8mat_print ( n, n, v, ' Eigenvector matrix V:' )

#
# Compute eigentest.
#
error_frobenius = r8mat_is_eigen_right ( n, n, a, v, d )
print ( '' )
print ( 'Frobenius norm error in eigensystem A*V-D*V = %g' % (
error_frobenius ) )
#
# Terminate.
#
print ( '' )
print ( 'JACOBI_EIGENVALUE_TEST01' )
print ( ' Normal end of execution.' )
return

def jacobi_eigenvalue_test02 ( ):
Output:
JACOBI_EIGENVALUE_TEST
Python version: 3.6.5
Test the JACOBI_EIGENVALUE library.

JACOBI_EIGENVALUE_TEST01
Python version: 3.6.5
JACOBI_EIGENVALUE computes the eigenvalues D
and eigenvectors V of a symmetric matrix A so that A * V = D * V.

Input matrix A:

Col: 0 1 2 3
Row
0 : 4 -30 60 -35
1 : -30 300 -675 420
2 : 60 -675 1620 -1050
3 : -35 420 -1050 700

Number of iterations = 11
Number of rotations = 21

Eigenvalues D:

0: 0.166643
1: 1.47805
2: 37.1015
3: 2585.25

Eigenvector matrix V:

Col: 0 1 2 3
Row
0 : 0.792608 0.582076 0.179186 0.0291933
1 : 0.451923 -0.370502 -0.741918 -0.328712
2 : 0.322416 -0.509579 0.100228 0.791411
3 : 0.252161 -0.514048 0.638283 -0.514553

Frobenius norm error in eigensystem A*V-D*V = 1.20349e-12

JACOBI_EIGENVALUE_TEST01
Normal end of execution.

8. Generate a MATLAB program for Eigen values and Eigen Vectors

Program 1:
a=[1 2 3;4 5 6;7 8 9]
b=eig(a)
[V,D,W]=eig(a
Output:
a=
1 2 3
4 5 6
7 8 9
b=
16.1168
-1.1168
-0.0000
b=Eigen Values of matrix a

V=
-0.2320 -0.7858 0.4082
-0.5253 -0.0868 -0.8165
-0.8187 0.6123 0.408
D=
16.1168 0 0
0 -1.1168 0
0 0 -0.0000
W=
-0.4645 -0.8829 0.4082
-0.5708 -0.2395 -0.8165
-0.6770 0.4039 0.4082

D is a diagonal matrix containing the eigen values.

V is a matrix whose columns are the corresponding right eigenvectors.
W, a matrix whose columns are the corresponding left eigenvectors
Program 2:
syms x y z
jacobian([x*y*z, y^2, x + z], [x, y, z])
Output:
[ y*z, x*z, x*y]
[ 0, 2*y, 0]
[ 1, 0, 1]
9. Generate a MATLAB program for Partial Differential Equations
m = 0;
x = linspace(0,1,20);
t = linspace(0,2,5);

sol = pdepe(m,@pdex1pde,@pdex1ic,@pdex1bc,x,t);
% pdepe is command for Partial DE
% Extract the first solution component as u.
u = sol(:,:,1);

% A surface plot is often a good way to study a solution.

surf(x,t,u)
title('Numerical solution computed with 20 mesh points.')
xlabel('Distance x')
ylabel('Time t')

% A solution profile can also be illuminating.

figure
plot(x,u(end,:))
title('Solution at t = 2')
xlabel('Distance x')
ylabel('u(x,2)')

Output: