Expt.

No: - 1 Solution of algebraic and transcendental equation by Regula-Falsi and

Newton-Raphson method
Statement: - 1 (A):

(i) Develop a Python (3) program to obtain a root of the equation 𝒙𝟑 − 𝟐𝒙 − 𝟓 = 𝟎 ,between
2 and 3 by regula-falsi method.

Algorithm:

1. Define the symbolic variable x.

2. Input the function as a string and convert it into a callable function using lambdify.
3. Prompt the user for initial interval endpoints a and b, and the number of iterations N.
4. Perform the False Position Method iterations:
• Calculate the next approximation c.
• Update the interval [a, b] based on the sign of f(a) * f(c).
• Print the iteration number, the root approximation c, and the function value f(c) for each iteration.

Program:

from sympy import *

x = Symbol('x')
g = input('Enter the function: ')
f = lambdify(x, g)
a = float(input('Enter a value: '))
b = float(input('Enter b value: '))
N = int(input('Enter number of iterations: '))

for i in range(1, N + 1):

c = (a * f(b) - b * f(a)) / (f(b) - f(a))
if f(a) * f(c) < 0:
b = c
else:
a = c
print('Iteration %d \t the root %0.3f \t function value %0.3f \n' % (i, c, f(c)))

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 1

 (ii) Develop a Python (3) program to obtain a root of the equation 𝟑𝒙 =
𝒄𝒐𝒔(𝒙) − 𝟏 ,between 0 and 1 by regula-falsi method.
Program:

from sympy import *

x = Symbol('x')
g = input('Enter the function: ')
f = lambdify(x, g)
a = float(input('Enter a value: '))
b = float(input('Enter b value: '))
N = int(input('Enter number of iterations: '))

for i in range(1, N + 1):

c = (a * f(b) - b * f(a)) / (f(b) - f(a))
if f(a) * f(c) < 0:
b = c
else:
a = c
print('Iteration %d \t the root %0.3f \t function value %0.3f \n' % (i, c, f(c)))

Output:

Statement: - 1 (B):

(i) Develop a python (3) program to find a root of the equation 𝒙𝟑 − 𝟐𝒙 − 𝟓 = 𝟎

near 1, by Newton Raphson method
Algorithm:

1. Import Libraries: Import necessary functions from sympy for symbolic computations.
2. Define Variables: Define the symbolic variable x to represent the independent variable in the function.
3. Input Function: Prompt the user to enter a function g as a string.
4. Convert Function to Callable: Convert the string function g into a callable function f using lambdify.
5. Compute Derivative: Calculate the derivative dg of g with respect to x.
6. Convert Derivative to Callable: Convert the derivative dg into a callable function df using lambdify.
B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 2
 7. Initial Approximation: Prompt the user to enter an initial approximation x0 for the root.
8. Number of Iterations: Prompt the user to enter the number of iterations n.
9. Newton-Raphson Iterations:
• For each iteration:
• Compute the next approximation x1 using: 𝑥1 = 𝑥0 − 𝑓(𝑥0)/𝑓′(𝑥0)
• Update x0 to x1.
• Print the iteration number, the root approximation x1, and the function value f(x1).

Program:

from sympy import *

x= Symbol ('x')
g = input ('\t Enter the function ')
f= lambdify (x , g )
dg = diff ( g )
df= lambdify (x , dg )
x0= float ( input ('\t Enter the intial approximation ') ) ; # x0=1
n= int( input ('\t Enter the number of iterations ') ) ; #n=5;
for i in range (1 , n+1 ):
x1 =( x0 - ( f ( x0 )/df ( x0 ) ) )
print('\t Itration %d \t the root %0.3f \t function value %0.3f \n'%(i,x1,f(x1)))
x0 = x1

Output:

(ii) Develop a python (3) program to find a root of the equation 𝟑𝒙 = 𝒄𝒐𝒔(𝒙) + 𝟏
near 1, by Newton Raphson method
Program:

from sympy import *

x= Symbol ('x')
g = input ('\t Enter the function ')
f= lambdify (x , g )
dg = diff ( g )
df= lambdify (x , dg )

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 3

x0= float ( input ('\t Enter the intial approximation ') ) ; # x0=1
n= int( input ('\t Enter the number of iterations ') ) ; #n=5;
for i in range (1 , n+1 ):
x1 =( x0 - ( f ( x0 )/df ( x0 ) ) )
print('\t Itration %d \t the root %0.3f \t function value %0.3f \n'%(i,x1,f(x1)))
x0 = x1

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 4

Expt. No: - 2 Interpolation /Extrapolation using Newton’s forward and backward
difference formula
Statement: - 2 (A): Develop a python (2) program to Use Newtons forward interpolation to obtain the
interpolating polynomial and hence calculate 𝒚(𝟏𝟖𝟗𝟓) for the following:

Algorithm:

1. User inputs the number of data points (n) and then enters the values for x and y (data points).
2. The code constructs the forward difference table using the entered data points.
3. The algorithm computes the Newton's divided difference coefficients to construct the interpolating
polynomial.
4. It simplifies the polynomial using SymPy.
5. The code then asks the user to enter a value a at which they want to approximate the function's value.
6. Finally, it uses the interpolating polynomial to calculate and print the approximate value of the function at
point a
Program:

from sympy import *

import numpy as np
n = int( input ('Enter number of data points : ') )
210
x = np . zeros (( n ) )
y = np . zeros (( n , n ) )
# Reading data points
print ('Enter data for x and y: ')
for i in range ( n ):
x[i] = float ( input ( 'x['+str( i )+']= ') )
y[i][0] = float ( input ( 'y['+str( i )+']= ') )
# Generating forward difference table
for i in range (1 , n ):
for j in range (0 , n-i ):
y[j][i] = y[j+1][i-1] - y[j][i-1]
print ('\nFORWARD DIFFERENCE TABLE \n') ;
for i in range (0 , n ):
print ('%0.2f ' %( x[i]) , end='')
for j in range (0 , n-i ):
print ('\t\t%0.2f ' %( y[i][j]) , end='')
print ()
# obtaining the polynomial
t= symbols ('t')
f=[] # f is a list type data
p=( t-x[0])/( x[1]-x[0])
f . append ( p )
for i in range (1 , n-1 ):
f . append ( f[i-1]*( p-i )/( i+1 ) )
poly =y[0][0]
for i in range ( n-1 ):
poly = poly +y[0][i+1]*f[i]
simp_poly = simplify ( poly )
print ('\nTHE INTERPOLATING POLYNOMIAL IS\n') ;
pprint ( simp_poly )
# if you want to interpolate at some point the next session will help
inter = input ('Do you want to interpolate at a point (y/n)? ') # y
if inter =='y':
a= float ( input ('enter the point ') ) #2

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 5

 interpol = lambdify (t , simp_poly )
result = interpol ( a )
print ('\nThe value of the function at ' ,a ,'is\n', result )

Output:

Statement: - 2 (B): Develop a python (2) program to Use Newtons backward interpolation to obtain the
interpolating polynomial and hence calculate 𝒚(𝟖) for the following data:

Algorithm:

1. The user is prompted to input the number of data points (n).

2. The user then enters the values for x and y (data points).
3. The algorithm constructs the backward difference table using the entered data points.
4. It computes the Newton's divided difference coefficients to construct the interpolating polynomial.
5. The algorithm simplifies the polynomial using SymPy.
6. The code asks the user to enter a value a at which they want to approximate the function's value.
7. Finally, the code uses the interpolating polynomial to calculate and print the approximate value of the
function at point a.

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 6

Program:

from sympy import *

import numpy as np
import sys
print (" This will use Newton 's backword intepolation formula ")
# Reading number of unknowns
n = int( input ('Enter number of data points : ') )
# Making numpy array of n & n x n size and initializing
# to zero for storing x and y value along with differences of y
x = np . zeros (( n ) )
y = np . zeros (( n , n ) )
# Reading data points
print ('Enter data for x and y: ')
for i in range ( n ):
x[i] = float ( input ( 'x['+str( i )+']= ') )
y[i][0] = float ( input ( 'y['+str( i )+']= ') )
# Generating backward difference table
for i in range (1 , n ):
for j in range ( n-1 , i-2 ,-1 ):
y[j][i] = y[j][i-1] - y[j-1][i-1]
print ('\nBACKWARD DIFFERENCE TABLE \n') ;
for i in range (0 , n ):
print ('%0.2f ' %( x[i]) , end='')
for j in range (0 , i+1 ):
print ('\t%0.2f ' %( y[i][j]) , end='')
print ()
# obtaining the polynomial
t= symbols ('t')
f=[]
p=( t-x[n-1])/( x[1]-x[0])
f . append ( p )
for i in range (1 , n-1 ):
f . append ( f[i-1]*( p+i )/( i+1 ) )
poly =y[n-1][0]
print ( poly )
for i in range ( n-1 ):
poly = poly +y[n-1][i+1]*f[i]
simp_poly = simplify ( poly )
print ('\nTHE INTERPOLATING POLYNOMIAL IS\n') ;
pprint ( simp_poly )
# if you want to interpolate at some point the next session will help
inter = input ('Do you want to interpolate at a point (y/n)? ')
if inter =='y':
a= float ( input ('enter the point ') )
interpol = lambdify (t , simp_poly )
result = interpol ( a )
print ('\nThe value of the function at ' ,a ,'is\n', result )

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 7

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 8

Expt. No: - 3 Computation of area under the curve using Trapezoidal, Simpson’s(𝟏⁄𝟑)𝒓𝒅
and Simpson (𝟑⁄𝟖)𝒕𝒉 rule
𝟓 𝟏
Statement: - 3 (A): Develop a Python (3) program to Evaluate ∫𝟎 , by trapezoidal rule
(𝟏+𝒙𝟐 )

Algorithm:

1. The function my_func(x) is defined, representing the integrand.

2. The trapezoidal function is defined to perform the numerical integration using the Trapezoidal method. It
takes the parameters x0 (lower limit), xn (upper limit), and n (number of sub-intervals) as input.
3. The variable h is calculated, representing the step size for each sub-interval.
4. The integration sum is initialized with the values of the function at the lower and upper limits (x0 and xn).
5. The Trapezoidal method iteratively sums up the function values at intermediate points within each sub-
interval and multiplies them by 2.
6. The final integration result is calculated by multiplying the summed values by h/2.
7. The user is prompted to enter the lower limit, upper limit, and the number of sub-intervals.
8. The trapezoidal function is called with the provided input, and the integration result is printed.

Program:

def my_func ( x ) :
return 1 / ( 1 + x ** 2 )

def trapezoidal ( x0 , xn , n ) :
h = ( xn - x0 ) / n
integration = my_func ( x0 ) + my_func ( xn )
for i in range (1 , n ) :
k = x0 + i * h
integration = integration + 2 * my_func ( k )
integration = integration * h / 2
return integration

lower_limit = float ( input ( " Enter lower limit of integration : " ) )

upper_limit = float ( input ( " Enter upper limit of integration : " ) )
sub_interval = int ( input ( " Enter number of sub intervals : " ) )
result = trapezoidal ( lower_limit , upper_limit , sub_interval )
print ( " Integration result by Trapezoidal method is : " ,result )

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 9

 𝟓 𝟏 𝟏
Statement: - 3 (B): Develop a Python (3) program to Evaluate ∫𝟎 , by Simpson’s (𝟑) 𝒓𝒅 Rule
(𝟏+𝒙𝟐 )

Algorithm:

1. The function my_func(x) is defined, representing the integrand.

2. The simpson13 function is defined to perform the numerical integration using Simpson's 1/3 rule. It takes the
parameters x0 (lower limit), xn (upper limit), and n (number of sub-intervals) as input.
3. The variable h is calculated, representing the step size for each sub-interval.
4. The integration sum is initialized with the values of the function at the lower and upper limits (x0 and xn).
5. The function values at intermediate points within each sub-interval are then summed up according to the
Simpson's 1/3 rule. If the index i is even, the function value is multiplied by 2; if i is odd, the function value is
multiplied by 4.
6. The final integration result is calculated by multiplying the summed values by (h/3).
7. The user is prompted to enter the lower limit, upper limit, and the number of sub-intervals.
8. The simpson13 function is called with the provided input, and the integration result is printed.

Program:

def my_func ( x ) :
return 1 / ( 1 + x ** 2 )

def simpson13 ( x0 , xn , n ) :
h = ( xn - x0 ) / n
integration = ( my_func ( x0 ) + my_func ( xn ) )
k = x0
for i in range (1 , n ) :
if i % 2 == 0 :
integration = integration + 2 * my_func ( k )
else :
integration = integration + 4 * my_func ( k )
k += h
integration = integration * h * ( 1 / 3 )
return integration

lower_limit = float ( input ( " Enter lower limit of integration : " ) )

upper_limit = float ( input ( " Enter upper limit of integration : " ) )
sub_interval = int ( input ( " Enter number of sub intervals : " ) )
result = simpson13 ( lower_limit , upper_limit , sub_interval )
print ( " Integration result by Simpson's 1 / 3 method is : ",( result))

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 10

 𝟓 𝟏 𝟑
Statement: -3 (C): Develop a Python (3) program to Evaluate ∫𝟎 , by Simpson’s (𝟖) 𝒕𝒉 rule
(𝟏+𝒙𝟐 )

Algorithm:

1. The function my_func(x) is defined, representing the integrand. In this case, the function is 3*x**2.
2. The simpson38 function is defined to perform the numerical integration using Simpson's 3/8 rule. It takes the
parameters x0 (lower limit), xn (upper limit), and n (number of sub-intervals) as input.
3. The variable h is calculated, representing the step size for each sub-interval.
4. The integration sum is initialized with the values of the function at the lower and upper limits (x0 and xn).
5. The function values at intermediate points within each sub-interval are then summed up according to the
Simpson's 3/8 rule. If the index i is divisible by 3, the function value is multiplied by 2; otherwise, it is
multiplied by 3.
6. The final integration result is calculated by multiplying the summed values by (3h/8).
7. The user is prompted to enter the lower limit, upper limit, and the number of sub-intervals.
8. The simpson38 function is called with the provided input, and the integration result is printed.

Program:

def my_func ( x ) :
return 3*x**2

def simpson38 ( x0 , xn , n ) :
h = ( xn - x0 ) / n
integration = ( my_func ( x0 ) + my_func ( xn ) )
for i in range (1 , n ) :
k=x0+i*h
if i % 3 == 0 :
integration = integration + 2 * my_func ( k )
else :
integration = integration + 3 * my_func ( k )
integration = integration * h * ( 3 / 8 )
return integration

lower_limit = float ( input ( " Enter lower limit of integration : " ) )

upper_limit = float ( input ( " Enter upper limit of integration : " ) )
sub_interval = int ( input ( " Enter number of sub intervals : " ) )
result = simpson38 ( lower_limit , upper_limit , sub_interval )
print ( " Integration result by Simpson's 3 / 8 method is : ",( result))

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 11

Expt. No: - 4 Solution of ODE of first order and first degree by Taylor’s series and Modified
Euler’s method
𝒅𝒚
Statement: - 4 (A): Develop a Python (2) program to Solve 𝒅𝒙 − 𝟐𝒚 = 𝟑𝒆𝒙 with 𝒚(𝟎) = 𝟎 using Taylor
series method at 𝒙 = 𝟎. 𝟏(𝟎. 𝟏)𝟎. 𝟑.

Algorithm:

1. The taylor function is defined to perform the Taylor series method for numerical integration of the system of
ODEs.
2. The deriv function is defined, representing the system of first-order ODEs that need to be solved. In this case,
it is a system of four ODEs.
3. The taylor function takes the following parameters:
• deriv: A function that returns the derivatives of the system of ODEs.
• x: The initial value of the independent variable.
• y: An array containing the initial values of the dependent variables.
• xStop: The stopping value of the independent variable.
• h: The step size for the numerical integration.
4. The function uses a loop to iteratively compute the approximate values of the dependent variables (y) at
different points in the interval (x to xStop) using the Taylor series expansion.
5. The computed values of the independent variable (x) and the corresponding values of the dependent
variables (y) are stored in arrays X and Y, respectively.
6. The initial values and the first four approximated values of x and y are printed.

Program:

from numpy import array,zeros,exp

def taylor ( deriv ,x ,y , xStop , h ) :
X = []
Y = []
X . append ( x )
Y . append ( y )
while x < xStop :
D = deriv (x , y )
H = 1.0
for j in range ( 4) :
H = H*h/(j + 1)
y = y + D[j]*H
x = x + h
X . append ( x )
Y . append ( y )
return array ( X ) , array ( Y )
def deriv (x , y ) :
D = zeros (( 4 , 1 ) )
D[0] =[ 2 * y [ 0 ] + 3 * exp ( x ) ]
D[1] =[ 4 * y [ 0 ] + 9 * exp ( x ) ]
D[2] =[ 8 * y [ 0 ] + 21 * exp ( x ) ]
D[3] =[ 16 * y [ 0 ] + 45 * exp ( x ) ]
return D
x = 0.0
xStop = 0.3
y = array([0.0])
h = 0.1
B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 12
 X , Y = taylor ( deriv ,x ,y , xStop , h )
for i in range(4):
print('x='+str(X[i]))
print('y='+str(round(float(Y[i]),5)))

Output:

Statement: - 4 (B): Develop a Python (2) program to Solve 𝒚′ = −𝒌𝒚 with 𝒚(𝟎) = 𝟏𝟎𝟎 using modified
Euler’s method at 𝒙 = 𝟏𝟎𝟎, by taking 𝒉 = 𝟐𝟓 .

Algorithm:

1. The modified_euler function is defined to perform the Modified Euler method for numerical integration of
the ODE.
2. The f function is defined, representing the ODE itself. In this case, it is a simple first-order ODE with the
function f(x, y) = -0.01*y.
3. The modified_euler function takes the following parameters:
• f: The function representing the ODE.
• x0: The initial value of the independent variable.
• y0: The initial value of the dependent variable.
• h: The step size for the numerical integration.
• n: The number of steps to be performed.
4. The function uses a loop to iteratively compute the approximate values of x and y using the Modified Euler
method.
5. The computed values of x and y at the n-th step are stored in arrays x and y, respectively.
6. The final values of x and y are printed.

Program:

import numpy as np
def modified_euler (f , x0 , y0 , h , n ) :
x = np . zeros ( n + 1 )
y = np . zeros ( n + 1 )
x [ 0 ] = x0
y [ 0 ] = y0
for i in range ( n ) :
x[i+1] = x[i] + h
k1 = h * f ( x [ i ] , y [ i ] )
k2 = h * f ( x [ i + 1 ] , y [ i ] + k1 )
y [ i + 1 ] = y [ i ] + 0.5 * ( k1 + k2 )

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 13

 return x , y
def f (x , y ) :
return -0.01*y
x0 = 0.0
y0 = 100.0
h = 25
n = 4
x , y = modified_euler (f , x0 , y0 , h , n )
print('x='+str(x[4])+' y='+str(round(y[4],5)))

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 14

Expt. No: - 5 Solution of ODE of first order and first degree by Runge-Kutta 4th order
method and Milne’s predictor and corrector method
Statement: - 5 (A): Develop a Python (2) program to Apply the Runge-Kutta method to find the solution
𝒅𝒚 𝒚
of 𝒅𝒙 = 𝟏 + ( ⁄𝒙) at 𝒚(𝟐) taking = 𝟎. 𝟐 . Given that 𝒚(𝟏) = 𝟐.

Algorithm:

1. The RungeKutta function takes the following parameters:

• g: Then function represented as ‘1 + (𝑦/𝑥)’
• x0: The initial value of the independent variable.
• h: The step size for the numerical integration.
• y0: The initial value of the dependent variable.
• xn: The final value of the independent variable where the solution is to be approximated.
2. The function uses a loop to iteratively compute the approximate values of y using the 4th-order Runge-Kutta
method.
3. The computed values of y at different points are stored in a list Y and printed.
Program:

from sympy import *

import numpy as np
def RungeKutta (g , x0 ,h , y0 , xn ):
x , y= symbols ('x,y')
f= lambdify ([x , y],g )
xt=x0+h
Y=[y0]
while xt<=xn:
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 )
y1=y0+( 1/6 )*( k1+2*k2+2*k3+k4 )
Y . append ( y1 )
print ('y(%3.3f '%xt ,') is %3.3f '%y1)
x0=xt
y0=y1
xt=xt+h
return np . round (Y , 2 )
RungeKutta ('1+(y/x)',1 , 0.2 ,2 , 2 )

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 15

Statement: -5 (B): Develop a Python (2) program to Apply Milne’s predictor and corrector method to
𝒅𝒚 𝒚
solve 𝒅𝒙 = 𝒙𝟐 + ( ⁄𝟐) at 𝒚(𝟏. 𝟒). Given that 𝒚(𝟏) = 𝟐, 𝒚(𝟏. 𝟏) = 𝟐. 𝟐𝟏𝟓𝟔, 𝒚(𝟏. 𝟐) =
𝟐. 𝟒𝟔𝟒𝟗, 𝒚(𝟏. 𝟑) = 𝟐. 𝟕𝟓𝟏𝟒.Use corrector formula thrice.

Algorithm:

1. The initial values of x and y are given as x0 and y0, respectively. The values of y at three additional points are
also provided as y1, y2, and y3.
2. The step size h is defined.
3. The function f(x, y) representing the ODE is defined. In this case, the ODE is dy/dx = x^2 + (y / 2).
4. The value of y at intermediate points (y10, y11, y12, y13) is calculated using the given initial values.
5. The predicted value of y at x4 is approximated using the fourth-order Runge-Kutta method and stored in y4p.
6. The corrected value of y at x4 is then calculated using a correction step. The correction is performed
iteratively three times. In each iteration, the corrected value y4c is calculated based on the previously
corrected value or the predicted value y4p. The value of y14 is updated using the corrected value after each
iteration.
7. After each iteration, the corrected value of y at x4 is printed.

Program:

x0 = 1
y0 = 2
y1 = 2.2156
y2 = 2.4649
y3 = 2.7514
h=0.1
x1 = x0 + h
x2 = x1 + h
x3 = x2 + h
x4 = x3 + h
def f (x , y ) :
return x ** 2 + ( y / 2 )
y10 = f ( x0 , y0 )
y11 = f ( x1 , y1 )
y12 = f ( x2 , y2 )
y13 = f ( x3 , y3 )
y4p = y0 + ( 4 * h / 3 ) * ( 2 * y11 - y12 + 2 * y13 )
print ( ' predicted value of y4 is % 3.3f '% y4p )
y14 = f ( x4 , y4p )
for i in range (1 , 4 ) :
y4c = y2 + ( h / 3 ) * ( y14 + 4 * y13 + y12 )
print ( ' corrected value of y4 after iteration %d is % 3.5f '%(i ,
y4c ) )
y14 = f ( x4 , y4c )

Output:

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 16

B.L.D.E.A's V.P. Dr.P.G.Halakatti College of Engineering and Technology Page | 17