numerical-method-lab 0.1.0__py3-none-any.whl

numerical_method_lab/__inti__.py

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

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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+numerical_method_lab/__inti__.py,sha256=GAtuudnJ7YjHG-XK35xFEuWgo7mJTw_qFo86c_gXRmE,17
+numerical_method_lab/integration.py,sha256=pVW-Cr5N6fFGHx9sA0c4tj3tanySF539OrkgAvboJe8,2503
+numerical_method_lab/linear_algebra.py,sha256=IYxHRWffLmlkxEtGkq2MDvrs2WKhdOSydXVJUmZFan0,2627
+numerical_method_lab/root_finding.py,sha256=YhhFJVeo0j_K5_yY2nzRB1jB3vXDcnM_v7MaHhm72tU,3442
+numerical_method_lab/visualization.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numerical_method_lab-0.1.0.dist-info/licenses/LICENSE,sha256=BTBqf01TJ7ZLWhuaWgiYEKXNmxigkWwpkXAdcXM98b8,1072
+numerical_method_lab-0.1.0.dist-info/METADATA,sha256=27S9H6VVCuPhCh-1Pfdj_os2MbNC8ZQbOxC263HX4eI,1853
+numerical_method_lab-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+numerical_method_lab-0.1.0.dist-info/top_level.txt,sha256=XdQ4cWNraOuwHcIT_tGpELd2pwYnAg9OuEI0qAjYPBQ,21
+numerical_method_lab-0.1.0.dist-info/RECORD,,

numerical_method_lab-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

numerical_method_lab-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

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