numerical-method-lab 0.1.0__tar.gz

numerical_method_lab-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abhishek thakur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

numerical_method_lab-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: numerical-method-lab
+Version: 0.1.0
+Summary: A collection of numerical methods for root finding, integration, and linear algebra
+License: MIT License
+        
+        Copyright (c) 2026 Abhishek thakur
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# Numerical_Method_Lab
+A from-scratch numerical analysis laboratory implementing classical numerical methods for root finding, numerical integration, and linear algebra, with automated tests, visualization, and experimental notebooks to study accuracy, convergence, and numerical stability.

numerical_method_lab-0.1.0/README.md

@@ -0,0 +1,2 @@
+# Numerical_Method_Lab
+A from-scratch numerical analysis laboratory implementing classical numerical methods for root finding, numerical integration, and linear algebra, with automated tests, visualization, and experimental notebooks to study accuracy, convergence, and numerical stability.

numerical_method_lab-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "numerical-method-lab"
+version = "0.1.0"
+description = "A collection of numerical methods for root finding, integration, and linear algebra"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {file = "LICENSE"}          # <-- This line adds your MIT license
+dependencies = [
+    "numpy",
+    "matplotlib",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

numerical_method_lab-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

numerical_method_lab-0.1.0/src/numerical_method_lab/__inti__.py

@@ -0,0 +1 @@
+# src/__init__.py

numerical_method_lab-0.1.0/src/numerical_method_lab/integration.py

@@ -0,0 +1,59 @@
+import numpy as np
+def trapezoidal(f,a,b,n=10000):
+    """
+    This function implements the trapezoidal rule for numerical integration.
+    :param f: The function to integrate
+    :param a: The lower limit of integration
+    :param b: The upper limit of integration
+    :param n: The number of trapezoids (default is 10000)
+    :return: The approximate value of the integral
+    """
+    x = np.linspace(a, b, n+1)  # x values for the trapezoids
+    dx = x[1]-x[0]  # width of each trapezoid
+    total = np.sum(f(x[:-1])*dx) + np.sum(f(x[1:])*dx)  # sum of areas of trapezoids
+    return total/2  # return the average of the two sums
+
+def rectanglel(f,a,b,n=10000):
+    """
+    This function implements the left rectangle rule for numerical integration.
+    :param f: The function to integrate
+    :param a: The lower limit of integration
+    :param b: The upper limit of integration
+    :param n: The number of rectangles (default is 10000)
+    :return: The approximate value of the integral
+    """
+    x = np.linspace(a, b, n+1)  # x values for the rectangles
+    dx = x[1]-x[0]  # width of each rectangle
+    total = np.sum(f(x[:-1])*dx)  # sum of areas of rectangles
+    return total  # return the total area
+
+def rectangler(f,a,b,n=10000):
+    """
+    This function implements the right rectangle rule for numerical integration.
+    :param f: The function to integrate
+    :param a: The lower limit of integration
+    :param b: The upper limit of integration
+    :param n: The number of rectangles (default is 10000)
+    :return: The approximate value of the integral
+    """
+    x = np.linspace(a, b, n+1)  # x values for the rectangles
+    dx = x[1]-x[0]  # width of each rectangle
+    total = np.sum(f(x[1:])*dx)  # sum of areas of rectangles
+    return total  # return the total area
+
+def simpson(f,a,b,n=10000):
+    """
+    This function implements Simpson's rule for numerical integration.
+    :param f: The function to integrate
+    :param a: The lower limit of integration
+    :param b: The upper limit of integration
+    :param n: The number of intervals (default is 10000, must be even)
+    :return: The approximate value of the integral
+    """
+    if n % 2 == 1:
+        n += 1  # make n even if it is odd
+    x = np.linspace(a, b, n+1)  # x values for the intervals
+    dx = x[1]-x[0] # width of each interval
+    total = f(x[0]) + f(x[-1]) + 4*np.sum(f(x[1:-1:2])) + 2*np.sum(f(x[2:-1:2]))  # Simpson's rule formula
+    return total * dx / 3  # return the approximate integral value
+

numerical_method_lab-0.1.0/src/numerical_method_lab/linear_algebra.py

@@ -0,0 +1,100 @@
+import numpy as np
+
+
+def back_substitution(A, b):
+    """
+    Solve an upper-triangular system Ax = b
+    using back substitution.
+    """
+
+    n = len(b)
+
+    # Create an array to store the solution
+    x = np.zeros(n)
+
+    # Start from the last equation
+    for i in range(n - 1, -1, -1):
+
+        # Start with the right-hand side
+        total = b[i]
+
+        # Subtract the terms we already know
+        for j in range(i + 1, n):
+            total -= A[i, j] * x[j]
+
+        # Check for zero diagonal element
+        if abs(A[i, i]) < 1e-12:
+            raise ValueError("Zero pivot encountered during back substitution.")
+
+        # Solve for x[i]
+        x[i] = total / A[i, i]
+
+    return x
+
+
+def gaussian_elimination(A, b):
+    """
+    Solve Ax = b using Gaussian elimination
+    with partial pivoting and back substitution.
+    """
+
+    # Convert inputs to NumPy arrays
+    A = np.array(A, dtype=float)
+    b = np.array(b, dtype=float)
+
+    # Make sure A is a square matrix
+    if A.ndim != 2 or A.shape[0] != A.shape[1]:
+        raise ValueError("A must be a square matrix.")
+
+    # Make sure b has the correct size
+    if len(b) != A.shape[0]:
+        raise ValueError("The dimensions of A and b do not match.")
+
+    n = len(b)
+
+    # -----------------------------------------
+    # Gaussian Elimination
+    # -----------------------------------------
+
+    for i in range(n):
+
+        # -------------------------------------
+        # PARTIAL PIVOTING
+        # -------------------------------------
+
+        # Look at the current column from row i downward
+        pivot_row = i + np.argmax(np.abs(A[i:, i]))
+
+        # Check whether the largest value is effectively zero
+        if abs(A[pivot_row, i]) < 1e-12:
+            raise ValueError("Matrix is singular or nearly singular.")
+
+        # Swap the current row with the pivot row
+        if pivot_row != i:
+            A[[i, pivot_row]] = A[[pivot_row, i]]
+            b[[i, pivot_row]] = b[[pivot_row, i]]
+
+        # -------------------------------------
+        # ELIMINATION
+        # -------------------------------------
+
+        # Eliminate values below the pivot
+        for j in range(i + 1, n):
+
+            # Calculate elimination factor
+            factor = A[j, i] / A[i, i]
+
+            # Eliminate the value
+            for k in range(i, n):
+                A[j, k] -= factor * A[i, k]
+
+            # Apply the same operation to b
+            b[j] -= factor * b[i]
+
+    # -----------------------------------------
+    # BACK SUBSTITUTION
+    # -----------------------------------------
+
+    solution = back_substitution(A, b)
+
+    return solution

numerical_method_lab-0.1.0/src/numerical_method_lab/root_finding.py

@@ -0,0 +1,170 @@
+
+
+
+def bisection_method(f, a, b, tol=1e-5, max_iter=100):
+    """
+    Bisection method for finding roots of a function.
+
+    Parameters:
+    f : function
+        The function for which we are trying to find a root.
+    a : float
+        The start of the interval.
+    b : float
+        The end of the interval.
+    tol : float
+        The tolerance for stopping the algorithm.
+    max_iter : int
+        The maximum number of iterations.
+
+    Returns:
+    float
+        The approximate root of the function.
+    """
+    fa = f(a)
+    fb = f(b)
+
+    if fa * fb >= 0:
+        raise ValueError(
+            "The function must have different signs at the endpoints."
+        )
+
+    for i in range(max_iter):
+
+        c = (a + b) / 2
+        fc = f(c)
+
+        if abs(fc) < tol or (b - a) / 2 < tol:
+            return c
+
+        if fa * fc < 0:
+            b = c
+            fb = fc
+        else:
+            a = c
+            fa = fc
+
+    return (a + b) / 2
+
+def derivative(f, x, h=1e-5):
+
+    """
+
+    Numerical derivative of a function using central difference.
+
+    Parameters:
+
+    f : function
+
+        The function for which we are calculating the derivative.
+
+    x : float
+
+        The point at which to evaluate the derivative.
+
+    h : float
+
+        The step size for the finite difference.
+
+    Returns:
+
+    float
+
+        The approximate derivative of the function at point x.
+
+    """
+
+    return (f(x + h) - f(x - h)) / (2 * h)
+
+
+def Newton_raphson_method(f, x0, df=derivative, tol=1e-5, max_iter=100):
+
+    """
+
+    Newton-Raphson Method
+
+    =====================
+
+    What it is:
+
+        The Newton-Raphson method is an iterative numerical technique used to find
+
+        roots of a real-valued function f(x) = 0.
+
+        If x_n is the current estimate, then the next estimate is:
+
+            x_{n+1} = x_n - f(x_n) / f'(x_n)
+
+        where f'(x) is the derivative of f(x).
+
+    How it works:
+
+        - Start with an initial guess x0.
+
+        - Compute the tangent line to the curve at x0.
+
+        - Find where that tangent line crosses the x-axis.
+
+        - Repeat until the change is very small or the function value is close to zero.
+
+    Why use it:
+
+        - Very fast when the initial guess is close to the actual root.
+
+        - It usually converges quadratically near simple roots.
+
+        - Works well for smooth functions with known derivatives.
+
+    Using NumPy:
+
+        NumPy helps with array operations, mathematical calculations, and plotting
+
+        when needed. This example uses only standard NumPy math functions.
+
+    Parameters:
+
+    f : function
+
+        The function for which we are trying to find a root.
+
+    x0 : float
+
+        The initial guess for the root.
+
+    df : function, optional
+
+        The derivative of the function f. If not provided, it will be calculated numerically.
+
+    tol : float, optional
+
+        The tolerance for stopping the algorithm.
+
+    max_iter : int, optional
+
+        The maximum number of iterations.
+
+    """
+
+    x_n = x0
+
+    for i in range(max_iter):
+
+        f_xn = f(x_n)
+
+        df_xn = df(f, x_n)
+
+        if abs(df_xn) < 1e-12:
+
+            raise ValueError("Derivative is too small; no convergence.")
+
+        x_n1 = x_n - f_xn / df_xn
+
+        if abs(x_n1 - x_n) < tol:
+            return x_n1
+
+        if abs(f(x_n1)) < tol:
+            return x_n1
+
+        x_n = x_n1
+
+    raise ValueError("Maximum iterations reached without convergence.")

numerical_method_lab-0.1.0/src/numerical_method_lab.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: numerical-method-lab
+Version: 0.1.0
+Summary: A collection of numerical methods for root finding, integration, and linear algebra
+License: MIT License
+        
+        Copyright (c) 2026 Abhishek thakur
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# Numerical_Method_Lab
+A from-scratch numerical analysis laboratory implementing classical numerical methods for root finding, numerical integration, and linear algebra, with automated tests, visualization, and experimental notebooks to study accuracy, convergence, and numerical stability.

numerical_method_lab-0.1.0/src/numerical_method_lab.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/numerical_method_lab/__inti__.py
+src/numerical_method_lab/integration.py
+src/numerical_method_lab/linear_algebra.py
+src/numerical_method_lab/root_finding.py
+src/numerical_method_lab/visualization.py
+src/numerical_method_lab.egg-info/PKG-INFO
+src/numerical_method_lab.egg-info/SOURCES.txt
+src/numerical_method_lab.egg-info/dependency_links.txt
+src/numerical_method_lab.egg-info/requires.txt
+src/numerical_method_lab.egg-info/top_level.txt
+tests/test_integration.py
+tests/test_linear_algebra.py
+tests/test_root_finding.py

numerical_method_lab-0.1.0/src/numerical_method_lab.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

numerical_method_lab-0.1.0/src/numerical_method_lab.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+matplotlib

numerical_method_lab-0.1.0/src/numerical_method_lab.egg-info/top_level.txt

@@ -0,0 +1 @@
+numerical_method_lab

numerical_method_lab-0.1.0/tests/test_integration.py

@@ -0,0 +1,177 @@
+import math
+import numpy as np
+import pytest
+from src.numerical_method_lab.integration import trapzoidal, rectanglel, rectangler, simpson
+
+
+# ----------------------------------------------------------------------
+# Helper: exact integrals of test functions
+# ----------------------------------------------------------------------
+def f_linear(x):
+    return 2 * x + 3          # integral from a to b: x^2 + 3x
+
+def f_quadratic(x):
+    return x**2 - 4*x + 5     # integral: x^3/3 - 2x^2 + 5x
+
+def f_exp(x):
+    return np.exp(x)          # integral: e^x
+
+def f_sin(x):
+    return np.sin(x)          # integral: -cos(x)
+
+# Exact values for specific intervals
+def exact_integral(f_name, a, b):
+    if f_name == 'linear':
+        return (b**2 - a**2) + 3*(b - a)
+    elif f_name == 'quadratic':
+        return (b**3 - a**3)/3 - 2*(b**2 - a**2) + 5*(b - a)
+    elif f_name == 'exp':
+        return np.exp(b) - np.exp(a)
+    elif f_name == 'sin':
+        return -np.cos(b) + np.cos(a)
+    else:
+        raise ValueError("Unknown function name")
+
+
+# ----------------------------------------------------------------------
+# Tests for trapezoidal rule
+# ----------------------------------------------------------------------
+def test_trapezoidal_linear_exact():
+    """Trapezoidal rule should be exact for linear functions."""
+    a, b = 0.0, 3.0
+    result = trapzoidal(f_linear, a, b, n=10)   # any n works
+    expected = exact_integral('linear', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-10)
+
+def test_trapezoidal_quadratic_accuracy():
+    """Trapezoidal rule should approximate quadratic with small error for large n."""
+    a, b = 0.0, 2.0
+    result = trapzoidal(f_quadratic, a, b, n=10000)
+    expected = exact_integral('quadratic', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-8)
+
+def test_trapezoidal_exp_accuracy():
+    """Trapezoidal rule for e^x with n=10000 should be very close."""
+    a, b = 0.0, 1.0
+    result = trapzoidal(f_exp, a, b, n=10000)
+    expected = exact_integral('exp', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-8)
+
+def test_trapezoidal_convergence():
+    """Error should decrease as n increases."""
+    a, b = 0.0, 1.0
+    expected = exact_integral('sin', a, b)
+    err1 = abs(trapzoidal(f_sin, a, b, n=100) - expected)
+    err2 = abs(trapzoidal(f_sin, a, b, n=1000) - expected)
+    assert err2 < err1   # larger n should give smaller error
+
+
+# ----------------------------------------------------------------------
+# Tests for left rectangle rule
+# ----------------------------------------------------------------------
+def test_rectanglel_linear_overestimates_or_underestimates():
+    """For increasing function, left rectangle underestimates; for decreasing, overestimates."""
+    a, b = 0.0, 1.0
+    # f_linear = 2x+3 is increasing, so left rectangles underestimate
+    result = rectanglel(f_linear, a, b, n=1000)
+    expected = exact_integral('linear', a, b)
+    assert result < expected
+
+def test_rectanglel_accuracy():
+    """With large n, left rectangle should approximate integral."""
+    a, b = 0.0, 2.0
+    result = rectanglel(f_quadratic, a, b, n=10000)
+    expected = exact_integral('quadratic', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-4)
+
+def test_rectanglel_convergence():
+    """Error decreases with increasing n."""
+    a, b = 0.0, 1.0
+    expected = exact_integral('exp', a, b)
+    err1 = abs(rectanglel(f_exp, a, b, n=100) - expected)
+    err2 = abs(rectanglel(f_exp, a, b, n=1000) - expected)
+    assert err2 < err1
+
+
+# ----------------------------------------------------------------------
+# Tests for right rectangle rule
+# ----------------------------------------------------------------------
+def test_rectangler_linear_overestimates_or_underestimates():
+    """For increasing function, right rectangle overestimates."""
+    a, b = 0.0, 1.0
+    result = rectangler(f_linear, a, b, n=1000)
+    expected = exact_integral('linear', a, b)
+    assert result > expected
+
+def test_rectangler_accuracy():
+    """With large n, right rectangle should approximate integral."""
+    a, b = 0.0, 2.0
+    result = rectangler(f_quadratic, a, b, n=10000)
+    expected = exact_integral('quadratic', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-4)
+
+def test_rectangler_convergence():
+    """Error decreases with increasing n."""
+    a, b = 0.0, 1.0
+    expected = exact_integral('exp', a, b)
+    err1 = abs(rectangler(f_exp, a, b, n=100) - expected)
+    err2 = abs(rectangler(f_exp, a, b, n=1000) - expected)
+    assert err2 < err1
+
+
+# ----------------------------------------------------------------------
+# Tests for Simpson's rule
+# ----------------------------------------------------------------------
+def test_simpson_quadratic_exact():
+    """Simpson's rule should be exact for quadratic functions (degree <= 3)."""
+    a, b = 0.0, 3.0
+    result = simpson(f_quadratic, a, b, n=2)   # minimal even n
+    expected = exact_integral('quadratic', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-10)
+
+def test_simpson_cubic_exact():
+    """Simpson's rule is also exact for cubic polynomials."""
+    f_cubic = lambda x: x**3 - 2*x + 1
+    a, b = 0.0, 2.0
+    # Exact integral: x^4/4 - x^2 + x evaluated from 0 to 2
+    expected = (2**4)/4 - 2**2 + 2
+    result = simpson(f_cubic, a, b, n=2)
+    assert math.isclose(result, expected, rel_tol=1e-10)
+
+def test_simpson_exp_accuracy():
+    """Simpson's rule for e^x with modest n is very accurate."""
+    a, b = 0.0, 1.0
+    result = simpson(f_exp, a, b, n=100)
+    expected = exact_integral('exp', a, b)
+    assert math.isclose(result, expected, rel_tol=1e-10)
+
+def test_simpson_odd_n_adjusts_to_even():
+    """If n is odd, the function should internally make it even and still work."""
+    a, b = 0.0, 1.0
+    result_odd = simpson(f_sin, a, b, n=101)   # odd n
+    result_even = simpson(f_sin, a, b, n=102)  # even n
+    expected = exact_integral('sin', a, b)
+    assert math.isclose(result_odd, expected, rel_tol=1e-8)
+    assert math.isclose(result_even, expected, rel_tol=1e-8)
+
+def test_simpson_convergence():
+    """Error decreases with n."""
+    a, b = 0.0, 2.0
+    expected = exact_integral('sin', a, b)
+    err1 = abs(simpson(f_sin, a, b, n=20) - expected)
+    err2 = abs(simpson(f_sin, a, b, n=40) - expected)
+    assert err2 < err1
+
+
+# ----------------------------------------------------------------------
+# Test that all methods handle n=1 without crashing
+# ----------------------------------------------------------------------
+def test_n1_no_crash():
+    """Each method should at least return a finite number for n=1."""
+    a, b = 0.0, 1.0
+    f = lambda x: x**2
+    assert np.isfinite(trapzoidal(f, a, b, n=1))
+    assert np.isfinite(rectanglel(f, a, b, n=1))
+    assert np.isfinite(rectangler(f, a, b, n=1))
+    # Simpson will adjust n to 2 internally, so should be finite
+    assert np.isfinite(simpson(f, a, b, n=1))

numerical_method_lab-0.1.0/tests/test_linear_algebra.py

@@ -0,0 +1,113 @@
+import numpy as np
+import pytest
+from src.numerical_method_lab.linear_algebra import back_substitution, gaussian_elimination
+
+
+# ----------------------------------------------------------------------
+# Tests for back_substitution
+# ----------------------------------------------------------------------
+def test_back_substitution_2x2():
+    A = np.array([[2.0, 1.0],
+                  [0.0, 3.0]])
+    b = np.array([5.0, 6.0])   # 2x + y = 5, 3y = 6 → y=2, x=1.5
+    x = back_substitution(A, b)
+    expected = np.array([1.5, 2.0])
+    assert np.allclose(x, expected, rtol=1e-12)
+
+def test_back_substitution_3x3():
+    A = np.array([[1.0, 2.0, 3.0],
+                  [0.0, 4.0, 5.0],
+                  [0.0, 0.0, 6.0]])
+    b = np.array([14.0, 23.0, 18.0])
+    # 6z = 18 → z=3; 4y + 5*3 = 23 → y=2; x + 2*2 + 3*3 = 14 → x=1
+    x = back_substitution(A, b)
+    expected = np.array([1.0, 2.0, 3.0])
+    assert np.allclose(x, expected, rtol=1e-12)
+
+def test_back_substitution_zero_pivot_raises():
+    A = np.array([[1.0, 2.0],
+                  [0.0, 0.0]])   # zero on diagonal
+    b = np.array([1.0, 1.0])
+    with pytest.raises(ValueError):
+        back_substitution(A, b)
+
+
+# ----------------------------------------------------------------------
+# Tests for gaussian_elimination
+# ----------------------------------------------------------------------
+def test_gaussian_elimination_2x2():
+    A = np.array([[2.0, 1.0],
+                  [1.0, 3.0]])
+    b = np.array([5.0, 6.0])
+    x = gaussian_elimination(A, b)
+    expected = np.linalg.solve(A, b)
+    assert np.allclose(x, expected, rtol=1e-12)
+
+def test_gaussian_elimination_3x3():
+    A = np.array([[3.0, 1.0, -1.0],
+                  [2.0, -2.0, 4.0],
+                  [-1.0, 0.5, -1.0]])
+    b = np.array([1.0, -2.0, 0.0])
+    x = gaussian_elimination(A, b)
+    expected = np.linalg.solve(A, b)
+    assert np.allclose(x, expected, rtol=1e-10)
+
+def test_gaussian_elimination_4x4():
+    A = np.array([[4.0, 1.0, 2.0, 0.5],
+                  [3.0, 4.0, 0.0, 1.0],
+                  [1.0, 0.0, 5.0, 2.0],
+                  [0.0, 2.0, 1.0, 3.0]])
+    b = np.array([8.5, 10.0, 13.0, 9.0])
+    x = gaussian_elimination(A, b)
+    expected = np.linalg.solve(A, b)
+    assert np.allclose(x, expected, rtol=1e-10)
+
+def test_gaussian_elimination_requires_pivoting():
+    # Matrix where naive Gaussian elimination (without pivoting) would fail
+    A = np.array([[0.0, 1.0],
+                  [1.0, 0.0]])
+    b = np.array([2.0, 1.0])   # solution: x=1, y=2
+    x = gaussian_elimination(A, b)
+    expected = np.array([1.0, 2.0])
+    assert np.allclose(x, expected, rtol=1e-12)
+
+def test_gaussian_elimination_ill_conditioned_pivoting():
+    # A small pivot without pivoting would cause large errors, but with pivoting it's fine
+    A = np.array([[1e-12, 1.0],
+                  [1.0, 1.0]])
+    b = np.array([1.0, 2.0])
+    x = gaussian_elimination(A, b)
+    expected = np.linalg.solve(A, b)
+    assert np.allclose(x, expected, rtol=1e-8)
+
+def test_gaussian_elimination_singular_raises():
+    A = np.array([[1.0, 2.0],
+                  [2.0, 4.0]])   # linearly dependent rows
+    b = np.array([1.0, 2.0])
+    with pytest.raises(ValueError):
+        gaussian_elimination(A, b)
+
+def test_gaussian_elimination_mismatched_dimensions_raises():
+    A = np.array([[1.0, 2.0],
+                  [3.0, 4.0]])
+    b = np.array([1.0])   # too short
+    with pytest.raises(ValueError):
+        gaussian_elimination(A, b)
+
+def test_gaussian_elimination_non_square_raises():
+    A = np.array([[1.0, 2.0, 3.0],
+                  [4.0, 5.0, 6.0]])   # 2x3
+    b = np.array([1.0, 2.0])
+    with pytest.raises(ValueError):
+        gaussian_elimination(A, b)
+
+def test_gaussian_elimination_does_not_modify_original_input():
+    A = np.array([[2.0, 1.0],
+                  [1.0, 3.0]])
+    b = np.array([5.0, 6.0])
+    A_copy = A.copy()
+    b_copy = b.copy()
+    gaussian_elimination(A, b)
+    # The function converts to arrays and modifies them internally, but should not affect originals
+    assert np.array_equal(A, A_copy)
+    assert np.array_equal(b, b_copy)

numerical_method_lab-0.1.0/tests/test_root_finding.py

@@ -0,0 +1,108 @@
+import math
+import pytest
+from src.numerical_method_lab.root_finding import (
+    bisection_method,
+    Newton_raphson_method,
+    derivative
+)
+
+
+# ----------------------------------------------------------------------
+# Tests for the bisection method
+# ----------------------------------------------------------------------
+def test_bisection_finds_sqrt2():
+    """Bisection should find sqrt(2) in [1, 2]."""
+    f = lambda x: x**2 - 2
+    root = bisection_method(f, 1, 2, tol=1e-8)
+    assert math.isclose(root, math.sqrt(2), rel_tol=1e-8)
+
+
+def test_bisection_finds_root_of_linear():
+    """Bisection should find the root of 2x - 6 = 0."""
+    f = lambda x: 2 * x - 6
+    root = bisection_method(f, 0, 5)
+    assert math.isclose(root, 3.0, rel_tol=1e-5)
+
+
+def test_bisection_handles_tight_tolerance():
+    """Bisection should get very close to the true root with small tol."""
+    f = lambda x: x**3 - x - 2
+    root = bisection_method(f, 1, 2, tol=1e-12, max_iter=200)
+    # true root is approximately 1.5213797068045676
+    assert math.isclose(root, 1.5213797068, rel_tol=1e-9)
+
+
+def test_bisection_invalid_interval_raises():
+    """If f(a) and f(b) have the same sign, a ValueError must be raised."""
+    f = lambda x: x**2 + 1  # always positive
+    with pytest.raises(ValueError):
+        bisection_method(f, -1, 1)
+
+
+def test_bisection_returns_number_even_if_max_iter_reached():
+    """If max_iter is too small, the method should still return a number."""
+    f = lambda x: x**2 - 2
+    root = bisection_method(f, 1, 2, tol=1e-12, max_iter=2)
+    assert isinstance(root, float)
+    assert 1.0 <= root <= 2.0
+
+
+# ----------------------------------------------------------------------
+# Tests for the numerical derivative function
+# ----------------------------------------------------------------------
+def test_derivative_of_linear():
+    """The derivative of f(x) = 3x + 2 should be 3."""
+    f = lambda x: 3 * x + 2
+    d = derivative(f, 5.0)
+    assert math.isclose(d, 3.0, rel_tol=1e-5)
+
+
+def test_derivative_of_quadratic():
+    """The derivative of f(x) = x^2 at x=2 should be 4."""
+    f = lambda x: x**2
+    d = derivative(f, 2.0)
+    assert math.isclose(d, 4.0, rel_tol=1e-4)
+
+
+# ----------------------------------------------------------------------
+# Tests for Newton Raphson method
+# ----------------------------------------------------------------------
+def test_newton_finds_sqrt2():
+    """Newton Raphson should find sqrt(2) starting from 1.5."""
+    f = lambda x: x**2 - 2
+    root = Newton_raphson_method(f, 1.5, tol=1e-8)
+    assert math.isclose(root, math.sqrt(2), rel_tol=1e-8)
+
+
+def test_newton_with_analytic_derivative():
+    """
+    Newton Raphson should work when an analytic derivative is supplied.
+    The derivative function passed must accept two arguments (f, x) even if
+    the first is unused.
+    """
+    f = lambda x: x**3 - x - 2
+    df = lambda f, x: 3 * x**2 - 1  # ignore f
+    root = Newton_raphson_method(f, 1.5, df=df, tol=1e-8)
+    assert math.isclose(root, 1.5213797068, rel_tol=1e-6)
+
+
+def test_newton_uses_numerical_derivative_by_default():
+    """Without a custom derivative, Newton Raphson should still converge."""
+    f = lambda x: x**2 - 2
+    root = Newton_raphson_method(f, 1.4, tol=1e-8)
+    assert math.isclose(root, math.sqrt(2), rel_tol=1e-6)
+
+
+def test_newton_raises_when_derivative_zero():
+    """If the derivative is (nearly) zero, a ValueError should be raised."""
+    f = lambda x: x**2 - 2
+    # Starting at x=0, derivative = 0, so the method should fail early.
+    with pytest.raises(ValueError):
+        Newton_raphson_method(f, 0.0, max_iter=10)
+
+
+def test_newton_raises_on_non_convergence():
+    """If the method does not converge within max_iter, it should raise."""
+    f = lambda x: x**3 - 2 * x + 2  # chosen to cause oscillation from 0
+    with pytest.raises(ValueError):
+        Newton_raphson_method(f, 0.0, max_iter=5)