Learning Objectives:

• Review all built-in, NumPy, and math functions used across typical numerical methods problems given at the end of this page.
• Understand and apply key numerical methods including root finding, interpolation, curve fitting, numerical integration, and solving ODEs.
• Practice basic numerical algorithms using Python.

---

Before diving into the problems, quickly recap some essential functions and libraries used in numerical programming, listed at the end of this page.

🧠 Solved Numerical Methods Problem Set Using Python

Each problem below corresponds to a major concept in numerical methods.

🔹 1. Root of Functions – Bisection Method

Problem: Find the root of the equation \(f(x) = x^3 - x - 2\) in the interval [1, 2] using the Bisection Method.

def f(x):
    return x**3 - x - 2

a, b = 1, 2
eps = 1e-6

while abs(b - a) > eps:
    c = (a + b) / 2
    if f(a) * f(c) < 0:
        b = c
    else:
        a = c

print("Root:", round(c, 6))

🔹 2. Iteration Method – Fixed Point Iteration

Problem: Solve the equation \(x = \cos(x)\) using the fixed-point iteration method starting from \(x_0 = 0.5\).

import math

def g(x):
    return math.cos(x)

x0 = 0.5
eps = 1e-6

while True:
    x1 = g(x0)
    if abs(x1 - x0) < eps:
        break
    x0 = x1

print("Root:", round(x1, 6))

🔹 3. Gauss Elimination Method

Problem: Solve the system of equations: 2x + 3y = 8 5x + 4y = 13 using Gaussian Elimination.

import numpy as np

A = np.array([[2, 3], [5, 4]], dtype=float)
b = np.array([8, 13], dtype=float)

x = np.linalg.solve(A, b)
print("Solution:", x)

🔹 4. Eigenvalues and Eigenvectors

Problem: Compute the eigenvalues and eigenvectors of the matrix: \(A = \begin{bmatrix} 4 & 2 \\ 1 & 3 \end{bmatrix}\)

import numpy as np

A = np.array([[4, 2], [1, 3]])
eigvals, eigvecs = np.linalg.eig(A)

print("Eigenvalues:", eigvals)
print("Eigenvectors:")
print(eigvecs)

🔹 5. Interpolation – Lagrange

Problem: Use Lagrange interpolation to estimate the value of the function at \(x = 2.5\), given the points (1, 2), (2, 3), and (4, 1).

def lagrange(X, Y, x):
    px = 0
    for j in range(len(X)):
        num = 1
        for i in range(len(X)):
            if i != j:
                num *= (x - X[i]) / (X[j] - X[i])
        px += num * Y[j]
    return px

X = [1, 2, 4]
Y = [2, 3, 1]

print("Interpolated value at x=2.5:", round(lagrange(X, Y, 2.5), 4))

🔹 6. Extrapolation – Newton Forward

Problem: Use Newton’s forward difference formula to estimate \(f(4)\) from the table: x = [1, 2, 3], f(x) = [1, 8, 27].

def newton_forward(x, y, value):
    n = len(x)
    diff_table = [y]
    for i in range(1, n):
        col = [diff_table[-1][j + 1] - diff_table[-1][j] for j in range(n - i)]
        diff_table.append(col)
    h = x[1] - x[0]
    u = (value - x[0]) / h
    result = y[0]
    u_term = 1
    fact = 1
    for i in range(1, n):
        u_term *= (u - i + 1)
        fact *= i
        result += (u_term * diff_table[i][0]) / fact
    return result

x = [1, 2, 3]
y = [1, 8, 27]
print("Extrapolated value at x=4:", round(newton_forward(x, y, 4), 2))

🔹 7. Curve Fitting – Polynomial Fit

Problem: Fit a 2nd-degree polynomial to the data points: (0,1), (1,2), (2,1), and (3,3).

import numpy as np
import matplotlib.pyplot as plt

x = np.array([0, 1, 2, 3])
y = np.array([1, 2, 1, 3])

coeffs = np.polyfit(x, y, 2)
p = np.poly1d(coeffs)

print("Fitted Polynomial:
", p)

🔹 8. Least Squares Fit – Linear

Problem: Find the best-fit line \(y = mx + c\) for the data points: (1,2), (2,4), and (3,5) using least squares.

import numpy as np

x = np.array([1, 2, 3])
y = np.array([2, 4, 5])

A = np.vstack([x, np.ones(len(x))]).T
m, c = np.linalg.lstsq(A, y, rcond=None)[0]

print(f"Line: y = {m:.2f}x + {c:.2f}")

🔹 9. Integration – Trapezoidal Rule

Problem: Approximate the integral of \(f(x) = x^2\) from 0 to 2 using the Trapezoidal Rule with 4 intervals.

def f(x):
    return x**2

a, b, n = 0, 2, 4
h = (b - a) / n
s = f(a) + f(b)

for i in range(1, n):
    s += 2 * f(a + i * h)

result = (h / 2) * s
print("Integral (Trapezoidal):", result)

🔹 10. Integration – Simpson’s Rule

Problem: Estimate the integral of \(f(x) = x^2\) from 0 to 2 using Simpson’s 1/3 Rule with 4 intervals.

def f(x):
    return x**2

a, b, n = 0, 2, 4
h = (b - a) / n
s = f(a) + f(b)

for i in range(1, n):
    if i % 2 == 0:
        s += 2 * f(a + i * h)
    else:
        s += 4 * f(a + i * h)

result = (h / 3) * s
print("Integral (Simpson's 1/3):", result)

🔹 11. Runge-Kutta Method – First Order ODE

Problem: Solve the initial value problem \(dy/dx = x + y\), \(y(0) = 1\) at \(x = 0.1\) using the 4th-order Runge-Kutta method.

def f(x, y):
    return x + y

x, y, h = 0, 1, 0.1
k1 = h * f(x, y)
k2 = h * f(x + h / 2, y + k1 / 2)
k3 = h * f(x + h / 2, y + k2 / 2)
k4 = h * f(x + h, y + k3)

y_new = y + (k1 + 2*k2 + 2*k3 + k4) / 6
print("y(0.1):", round(y_new, 5))

🔹 12. Finite Difference Method – Derivative Approximation

Problem: Approximate the derivative of \(f(x) = x^3\) at \(x = 1\) using the forward difference method with step size \(h = 0.1\).

def f(x):
    return x**3

x, h = 1, 0.1
df = (f(x + h) - f(x)) / h
print("f'(1) ≈", df)

---

🛠️ Additional Practice: Sorting a List in Descending Order

Problem:
Write a Python program to sort a list of numbers in descending order using the following algorithms:

• Bubble Sort
• Selection Sort

Implement both methods separately and compare their logic and results.

---

Revision

🐍 Built-in Python Functions

Function	Purpose	Example
input()	Reads user input	x = int(input())
print()	Displays output	print("Result:", result)
range()	Loop iteration	for i in range(n):
round()	Rounds a number	round(val, 4)
abs()	Absolute value	abs(a - b)

🧮 NumPy Library (numpy)

Function	Purpose	Example
np.array()	Create arrays	np.array([1, 2, 3])
np.append()	Append values to array	np.append(arr, x)
np.linspace()	Generate evenly spaced values	np.linspace(0, 2, 5)
np.vstack()	Stack arrays vertically	np.vstack([x, np.ones(n)])
np.ones()	Create array of ones	np.ones(n)
np.polyfit()	Polynomial curve fitting	np.polyfit(x, y, 2)
np.poly1d()	Construct polynomial from coeffs	np.poly1d(coeffs)
np.meshgrid()	Create 2D coordinate grid	np.meshgrid(x, y)
np.linalg.solve()	Solve linear equations	np.linalg.solve(A, b)
np.linalg.eig()	Compute eigenvalues/vectors	np.linalg.eig(A)
np.linalg.lstsq()	Least squares line fit	np.linalg.lstsq(A, y, rcond=None)

📐 Math Library (math)

Function	Purpose	Example
math.cos()	Compute cosine	math.cos(x)

📈 Matplotlib (matplotlib.pyplot)

Function	Purpose	Example
plt.plot()	Plot line or data	plt.plot(x, y)