numeth 0.1.0__tar.gz

numeth-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Numeth
+
+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.

numeth-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: numeth
+Version: 0.1.0
+Summary: A comprehensive set of core numerical methods used in engineering and applied mathematics
+Author-email: Abhisumat Kundu <kunduabhisumat@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Numeth
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the &quot;Software&quot;), 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 &quot;AS IS&quot;, 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.
+        
+Project-URL: Homepage, https://github.com/example/numeth
+Project-URL: Repository, https://github.com/example/numeth.git
+Project-URL: Documentation, https://numeth.readthedocs.io
+Keywords: numerical methods,scientific computing,engineering,applied mathematics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# numeth
+
+A fully functional Python package implementing core numerical methods for engineering and applied mathematics. Designed for usability and educational clarity.
+
+## Installation
+
+Install via pip:
+
+```
+pip install numeth
+```
+
+## Quick Start
+
+Here's a simple example using the Newton-Raphson method to find the square root of 2:
+
+```python
+from numeth import newton_raphson
+
+def f(x):
+    return x**2 - 2
+
+def df(x):
+    return 2 * x
+
+root, iterations, converged = newton_raphson(f, df, x0=1.0, tol=1e-6, max_iter=100)
+print(f"Root: {root}, Iterations: {iterations}, Converged: {converged}")
+# Output: Root: 1.414213562373095, Iterations: 4, Converged: True
+```
+
+## Supported Methods
+
+### Integration
+- Trapezoidal Rule (single and composite)
+- Simpson’s 1/3 Rule (single and composite)
+- Simpson’s 3/8 Rule
+- Gaussian Quadrature (2-point and 3-point)
+
+### Differentiation
+- Forward difference (first derivative)
+- Backward difference (first derivative)
+- Central difference (first derivative)
+- Central difference (second derivative)
+- Richardson extrapolation (first derivative)
+
+### Root Finding
+- Bisection Method
+- Newton-Raphson Method
+- Secant Method
+- False Position Method
+
+### Interpolation
+- Linear Interpolation
+- Lagrange Interpolation
+- Newton’s Divided Difference Interpolation
+
+### Linear Algebra
+- Gauss Elimination with partial pivoting
+- LU Decomposition (Doolittle’s method)
+- Jacobi Iterative Method
+- Gauss-Seidel Iterative Method
+
+### Optimization
+- Golden Section Search (minimization)
+- Newton’s Method for Optimization (1D)
+
+## How to Contribute or Report Issues
+
+Contributions are welcome! Please submit pull requests or open issues on the [GitHub repository](https://github.com/example/numeth).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

numeth-0.1.0/README.md

@@ -0,0 +1,73 @@
+# numeth
+
+A fully functional Python package implementing core numerical methods for engineering and applied mathematics. Designed for usability and educational clarity.
+
+## Installation
+
+Install via pip:
+
+```
+pip install numeth
+```
+
+## Quick Start
+
+Here's a simple example using the Newton-Raphson method to find the square root of 2:
+
+```python
+from numeth import newton_raphson
+
+def f(x):
+    return x**2 - 2
+
+def df(x):
+    return 2 * x
+
+root, iterations, converged = newton_raphson(f, df, x0=1.0, tol=1e-6, max_iter=100)
+print(f"Root: {root}, Iterations: {iterations}, Converged: {converged}")
+# Output: Root: 1.414213562373095, Iterations: 4, Converged: True
+```
+
+## Supported Methods
+
+### Integration
+- Trapezoidal Rule (single and composite)
+- Simpson’s 1/3 Rule (single and composite)
+- Simpson’s 3/8 Rule
+- Gaussian Quadrature (2-point and 3-point)
+
+### Differentiation
+- Forward difference (first derivative)
+- Backward difference (first derivative)
+- Central difference (first derivative)
+- Central difference (second derivative)
+- Richardson extrapolation (first derivative)
+
+### Root Finding
+- Bisection Method
+- Newton-Raphson Method
+- Secant Method
+- False Position Method
+
+### Interpolation
+- Linear Interpolation
+- Lagrange Interpolation
+- Newton’s Divided Difference Interpolation
+
+### Linear Algebra
+- Gauss Elimination with partial pivoting
+- LU Decomposition (Doolittle’s method)
+- Jacobi Iterative Method
+- Gauss-Seidel Iterative Method
+
+### Optimization
+- Golden Section Search (minimization)
+- Newton’s Method for Optimization (1D)
+
+## How to Contribute or Report Issues
+
+Contributions are welcome! Please submit pull requests or open issues on the [GitHub repository](https://github.com/example/numeth).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

numeth-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "numeth"
+version = "0.1.0"
+description = "A comprehensive set of core numerical methods used in engineering and applied mathematics"
+readme = "README.md"
+authors = [{ name = "Abhisumat Kundu", email = "kunduabhisumat@gmail.com" }]
+license = { file = "LICENSE" }
+keywords = ["numerical methods", "scientific computing", "engineering", "applied mathematics"]
+dependencies = ["numpy"]
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/example/numeth"
+"Repository" = "https://github.com/example/numeth.git"
+"Documentation" = "https://numeth.readthedocs.io"

numeth-0.1.0/setup.cfg

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

numeth-0.1.0/src/numeth/__init__.py

@@ -0,0 +1,57 @@
+from .differentiation import (
+    backward_difference,
+    central_difference,
+    central_second_difference,
+    forward_difference,
+    richardson_extrapolation,
+)
+from .integration import (
+    composite_simpsons_13,
+    composite_trapezoidal,
+    gaussian_quadrature_2,
+    gaussian_quadrature_3,
+    simpsons_13,
+    simpsons_38,
+    trapezoidal,
+)
+from .interpolation import (
+    lagrange_interpolation,
+    linear_interpolation,
+    newton_divided_difference,
+)
+from .linear_algebra import (
+    gauss_elimination,
+    gauss_seidel,
+    jacobi,
+    lu_decomposition,
+)
+from .optimization import golden_section_search, newton_optimization
+from .root_finding import bisection, false_position, newton_raphson, secant
+
+__all__ = [
+    "trapezoidal",
+    "composite_trapezoidal",
+    "simpsons_13",
+    "composite_simpsons_13",
+    "simpsons_38",
+    "gaussian_quadrature_2",
+    "gaussian_quadrature_3",
+    "forward_difference",
+    "backward_difference",
+    "central_difference",
+    "central_second_difference",
+    "richardson_extrapolation",
+    "bisection",
+    "newton_raphson",
+    "secant",
+    "false_position",
+    "linear_interpolation",
+    "lagrange_interpolation",
+    "newton_divided_difference",
+    "gauss_elimination",
+    "lu_decomposition",
+    "jacobi",
+    "gauss_seidel",
+    "golden_section_search",
+    "newton_optimization",
+]

numeth-0.1.0/src/numeth/differentiation.py

@@ -0,0 +1,123 @@
+from typing import Callable
+
+
+def forward_difference(f: Callable[[float], float], x: float, h: float) -> float:
+    """
+    Forward difference approximation of the first derivative.
+
+    Args:
+        f: Function to differentiate.
+        x: Point at which to evaluate.
+        h: Step size.
+
+    Returns:
+        Approximation of f'(x).
+
+    Raises:
+        ValueError: If h <= 0.
+
+    Example:
+        >>> forward_difference(lambda x: x**2, 1, 0.1)
+        2.100000000000002
+    """
+    if h <= 0:
+        raise ValueError("Step size h must be positive")
+    return (f(x + h) - f(x)) / h
+
+
+def backward_difference(f: Callable[[float], float], x: float, h: float) -> float:
+    """
+    Backward difference approximation of the first derivative.
+
+    Args:
+        f: Function to differentiate.
+        x: Point at which to evaluate.
+        h: Step size.
+
+    Returns:
+        Approximation of f'(x).
+
+    Raises:
+        ValueError: If h <= 0.
+
+    Example:
+        >>> backward_difference(lambda x: x**2, 1, 0.1)
+        1.9000000000000013
+    """
+    if h <= 0:
+        raise ValueError("Step size h must be positive")
+    return (f(x) - f(x - h)) / h
+
+
+def central_difference(f: Callable[[float], float], x: float, h: float) -> float:
+    """
+    Central difference approximation of the first derivative.
+
+    Args:
+        f: Function to differentiate.
+        x: Point at which to evaluate.
+        h: Step size.
+
+    Returns:
+        Approximation of f'(x).
+
+    Raises:
+        ValueError: If h <= 0.
+
+    Example:
+        >>> central_difference(lambda x: x**2, 1, 0.1)
+        2.0000000000000018
+    """
+    if h <= 0:
+        raise ValueError("Step size h must be positive")
+    return (f(x + h) - f(x - h)) / (2 * h)
+
+
+def central_second_difference(f: Callable[[float], float], x: float, h: float) -> float:
+    """
+    Central difference approximation of the second derivative.
+
+    Args:
+        f: Function to differentiate.
+        x: Point at which to evaluate.
+        h: Step size.
+
+    Returns:
+        Approximation of f''(x).
+
+    Raises:
+        ValueError: If h <= 0.
+
+    Example:
+        >>> central_second_difference(lambda x: x**2, 1, 0.1)
+        1.9999999999999991
+    """
+    if h <= 0:
+        raise ValueError("Step size h must be positive")
+    return (f(x + h) - 2 * f(x) + f(x - h)) / (h**2)
+
+
+def richardson_extrapolation(f: Callable[[float], float], x: float, h: float) -> float:
+    """
+    Richardson extrapolation for first derivative using central differences.
+
+    Args:
+        f: Function to differentiate.
+        x: Point at which to evaluate.
+        h: Initial step size.
+
+    Returns:
+        Improved approximation of f'(x).
+
+    Raises:
+        ValueError: If h <= 0.
+
+    Example:
+        >>> richardson_extrapolation(lambda x: x**2, 1, 0.1)
+        2.0000000000000004
+    """
+    if h <= 0:
+        raise ValueError("Step size h must be positive")
+    d1 = central_difference(f, x, h)
+    d2 = central_difference(f, x, h / 2)
+    return (4 * d2 - d1) / 3

numeth-0.1.0/src/numeth/integration.py

@@ -0,0 +1,211 @@
+import math
+from typing import Callable, Optional
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+def _has_numpy() -> bool:
+    return np is not None
+
+
+def trapezoidal(f: Callable[[float], float], a: float, b: float) -> float:
+    """
+    Single trapezoidal rule for numerical integration.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b.
+
+    Example:
+        >>> trapezoidal(lambda x: x**2, 0, 1)
+        0.5
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    h = b - a
+    return (h / 2) * (f(a) + f(b))
+
+
+def composite_trapezoidal(
+    f: Callable[[float], float], a: float, b: float, n: int
+) -> float:
+    """
+    Composite trapezoidal rule for numerical integration.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+        n: Number of intervals.
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b or n < 1.
+
+    Example:
+        >>> composite_trapezoidal(lambda x: x**2, 0, 1, 2)
+        0.375
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    if n < 1:
+        raise ValueError("Number of intervals n must be at least 1")
+    h = (b - a) / n
+    integral = f(a) + f(b)
+    for i in range(1, n):
+        integral += 2 * f(a + i * h)
+    return (h / 2) * integral
+
+
+def simpsons_13(f: Callable[[float], float], a: float, b: float) -> float:
+    """
+    Single Simpson's 1/3 rule for numerical integration.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b.
+
+    Example:
+        >>> simpsons_13(lambda x: x**2, 0, 1)
+        0.3333333333333333
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    h = (b - a) / 2
+    return (h / 3) * (f(a) + 4 * f(a + h) + f(b))
+
+
+def composite_simpsons_13(
+    f: Callable[[float], float], a: float, b: float, n: int
+) -> float:
+    """
+    Composite Simpson's 1/3 rule for numerical integration. Requires even n.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+        n: Number of intervals (must be even).
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b, n < 2, or n is odd.
+
+    Example:
+        >>> composite_simpsons_13(lambda x: x**2, 0, 1, 2)
+        0.3333333333333333
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    if n < 2 or n % 2 != 0:
+        raise ValueError("Number of intervals n must be even and at least 2")
+    h = (b - a) / n
+    integral = f(a) + f(b)
+    for i in range(1, n, 2):
+        integral += 4 * f(a + i * h)
+    for i in range(2, n, 2):
+        integral += 2 * f(a + i * h)
+    return (h / 3) * integral
+
+
+def simpsons_38(f: Callable[[float], float], a: float, b: float) -> float:
+    """
+    Simpson's 3/8 rule for numerical integration.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b.
+
+    Example:
+        >>> simpsons_38(lambda x: x**2, 0, 1)
+        0.3333333333333333
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    h = (b - a) / 3
+    return (3 * h / 8) * (f(a) + 3 * f(a + h) + 3 * f(a + 2 * h) + f(b))
+
+
+def gaussian_quadrature_2(f: Callable[[float], float], a: float, b: float) -> float:
+    """
+    2-point Gaussian quadrature for numerical integration.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b.
+
+    Example:
+        >>> gaussian_quadrature_2(lambda x: x**2, 0, 1)
+        0.33333333333333337
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    # Transform to [-1,1]
+    t = lambda x: ((b - a) * x + (b + a)) / 2
+    w = (b - a) / 2
+    x1, x2 = -math.sqrt(1 / 3), math.sqrt(1 / 3)
+    return w * (f(t(x1)) + f(t(x2)))
+
+
+def gaussian_quadrature_3(f: Callable[[float], float], a: float, b: float) -> float:
+    """
+    3-point Gaussian quadrature for numerical integration.
+
+    Args:
+        f: Function to integrate.
+        a: Lower bound.
+        b: Upper bound.
+
+    Returns:
+        Approximation of the integral.
+
+    Raises:
+        ValueError: If a >= b.
+
+    Example:
+        >>> gaussian_quadrature_3(lambda x: x**2, 0, 1)
+        0.3333333333333333
+    """
+    if a >= b:
+        raise ValueError("Lower bound a must be less than upper bound b")
+    # Transform to [-1,1]
+    t = lambda x: ((b - a) * x + (b + a)) / 2
+    w = (b - a) / 2
+    x1, x2, x3 = -math.sqrt(3 / 5), 0, math.sqrt(3 / 5)
+    w1, w2, w3 = 5 / 9, 8 / 9, 5 / 9
+    return w * (w1 * f(t(x1)) + w2 * f(t(x2)) + w3 * f(t(x3)))