pymodab 1.0.0__tar.gz

pymodab-1.0.0/LICENSE

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

pymodab-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+recursive-include src/pymodab *.dll *.so *.dylib

pymodab-1.0.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pymodab
+Version: 1.0.0
+Summary: Fast and robust root-finding using the Modified Anderson-Bjork method
+Author: Ganchovski, Traykov
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ModAB-Root-Finding/ModAB-Python
+Project-URL: Repository, https://github.com/ModAB-Root-Finding/ModAB-Python
+Keywords: root-finding,numerical,mathematics,optimization,bisection,secant
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+A fast and robust root-finding library using the Modified Anderson-Bjork method (Ganchovski, Traykov), written in C for Python.
+
+
+## Installation
+
+```bash
+pip install pymodab
+```
+
+## Usage
+
+```python
+import math
+from pymodab import find_root, find_default, get_evaluation_count
+
+# Find the root of cos(x) - x = 0 in [0, 1]
+root = find_root(lambda x: math.cos(x) - x, 0, 1, 100)
+print(f"Root: {root}")  # 0.7390851332151607
+
+# Using default tolerances
+root = find_default(lambda x: x**2 - 2, 1, 2)
+print(f"sqrt(2) = {root}")  # 1.4142135623730951
+
+# Get the number of function evaluations
+print(f"Evaluations: {get_evaluation_count()}")
+```
+
+## API
+
+### `find_root(f, x1, x2, atol=1e-14, rtol=1e-14, max_iter=200)`
+
+Find the root of `f(x) = 0` within the interval `[x1, x2]`.
+
+**Parameters:**
+- `f`: A continuous function of one variable
+- `x1`, `x2`: Bracket interval endpoints (must satisfy `f(x1) * f(x2) < 0`)
+- `atol`: Absolute tolerance (default: 1e-14)
+- `rtol`: Relative tolerance (default: 1e-14)
+- `max_iter`: Maximum iterations (default: 200)
+
+**Returns:** The root, or `NaN` if not found.
+
+### `find_default(f, x1, x2)`
+
+Convenience wrapper for `find_root` with default tolerances.
+
+### `get_evaluation_count()`
+
+Returns the number of function evaluations from the last root-finding call.
+
+## Algorithm
+
+Modified Anderson-Björck's method is a new robust and efficient bracketing root-finding algorithm. It combines bisection with Anderson-Björk's method to achieve both fast performance and worst-case optimality.
+
+References:
+
+Ganchovski N.; Traykov A. Modified Anderson-Björck's method for solving non-linear equations in structural mechanics. IOP Conference Series: Materials Science and Engineering 2023, 1276 (1) 012010, IOP Publishing. 
+https://iopscience.iop.org/article/10.1088/1757-899X/1276/1/012010/pdf
+
+Ganchovski, N.; Smith, O.; Rackauckas, C.; Tomov, L.; Traykov, A. Improvements of the Modified Anderson-Björck (modAB) Root-Finding Algorithm. Preprints 2026, 2026032190.
+https://www.preprints.org/manuscript/202603.2190
+
+## License
+
+MIT License

pymodab-1.0.0/README.md

@@ -0,0 +1,65 @@
+A fast and robust root-finding library using the Modified Anderson-Bjork method (Ganchovski, Traykov), written in C for Python.
+
+
+## Installation
+
+```bash
+pip install pymodab
+```
+
+## Usage
+
+```python
+import math
+from pymodab import find_root, find_default, get_evaluation_count
+
+# Find the root of cos(x) - x = 0 in [0, 1]
+root = find_root(lambda x: math.cos(x) - x, 0, 1, 100)
+print(f"Root: {root}")  # 0.7390851332151607
+
+# Using default tolerances
+root = find_default(lambda x: x**2 - 2, 1, 2)
+print(f"sqrt(2) = {root}")  # 1.4142135623730951
+
+# Get the number of function evaluations
+print(f"Evaluations: {get_evaluation_count()}")
+```
+
+## API
+
+### `find_root(f, x1, x2, atol=1e-14, rtol=1e-14, max_iter=200)`
+
+Find the root of `f(x) = 0` within the interval `[x1, x2]`.
+
+**Parameters:**
+- `f`: A continuous function of one variable
+- `x1`, `x2`: Bracket interval endpoints (must satisfy `f(x1) * f(x2) < 0`)
+- `atol`: Absolute tolerance (default: 1e-14)
+- `rtol`: Relative tolerance (default: 1e-14)
+- `max_iter`: Maximum iterations (default: 200)
+
+**Returns:** The root, or `NaN` if not found.
+
+### `find_default(f, x1, x2)`
+
+Convenience wrapper for `find_root` with default tolerances.
+
+### `get_evaluation_count()`
+
+Returns the number of function evaluations from the last root-finding call.
+
+## Algorithm
+
+Modified Anderson-Björck's method is a new robust and efficient bracketing root-finding algorithm. It combines bisection with Anderson-Björk's method to achieve both fast performance and worst-case optimality.
+
+References:
+
+Ganchovski N.; Traykov A. Modified Anderson-Björck's method for solving non-linear equations in structural mechanics. IOP Conference Series: Materials Science and Engineering 2023, 1276 (1) 012010, IOP Publishing. 
+https://iopscience.iop.org/article/10.1088/1757-899X/1276/1/012010/pdf
+
+Ganchovski, N.; Smith, O.; Rackauckas, C.; Tomov, L.; Traykov, A. Improvements of the Modified Anderson-Björck (modAB) Root-Finding Algorithm. Preprints 2026, 2026032190.
+https://www.preprints.org/manuscript/202603.2190
+
+## License
+
+MIT License

pymodab-1.0.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pymodab"
+version = "1.0.0"
+description = "Fast and robust root-finding using the Modified Anderson-Bjork method"
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "Ganchovski, Traykov"}
+]
+keywords = ["root-finding", "numerical", "mathematics", "optimization", "bisection", "secant"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: C",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/ModAB-Root-Finding/ModAB-Python"
+Repository = "https://github.com/ModAB-Root-Finding/ModAB-Python"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+pymodab = ["*.dll", "*.so", "*.dylib", "*.lib", "py.typed"]

pymodab-1.0.0/setup.cfg

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

pymodab-1.0.0/src/pymodab/__init__.py

@@ -0,0 +1,15 @@
+"""
+PyModAB - Python wrapper for the Modified Anderson-Bjork (modAB) algorithm .
+ModAB is a fast and robust root-finding method that combines bisection with the 
+Anderson-Bjork method for that provide fast convergence for well-behaved functions
+while preserving wost-case optimality.
+
+Ganchovski, N.; Smith, O.; Rackauckas, C.; Tomov, L.; Traykov, A. 
+Improvements of the Modified Anderson-Björck (modAB) Root-Finding Algorithm. 
+Preprints 2026, 2026032190. https://doi.org/10.20944/preprints202603.2190.v1
+"""
+
+from .modab import find_root, find_default, get_evaluation_count
+
+__version__ = "1.0.0"
+__all__ = ["find_root", "find_default", "get_evaluation_count"]

pymodab-1.0.0/src/pymodab/modab.py

@@ -0,0 +1,168 @@
+"""
+Python wrapper for the ModAB C library.
+"""
+
+import ctypes
+import os
+import platform
+import sys
+from ctypes import c_double, c_int, CFUNCTYPE
+from typing import Callable
+
+# Define the callback function type for the C library
+FUNC_TYPE = CFUNCTYPE(c_double, c_double)
+
+def _get_library_path() -> str:
+    """Get the path to the shared library based on the platform."""
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+
+    system = platform.system()
+    if system == "Windows":
+        lib_name = "ModAB.dll"
+    elif system == "Darwin":
+        machine = platform.machine()
+        if machine == "arm64":
+            lib_name = "libModAB_arm64.dylib"
+        else:
+            lib_name = "libModAB_x64.dylib"
+    else:  # Linux and others
+        lib_name = "libModAB.so"
+
+    lib_path = os.path.join(package_dir, lib_name)
+
+    if not os.path.exists(lib_path):
+        raise FileNotFoundError(
+            f"Could not find {lib_name} in {package_dir}. "
+            f"Please ensure the library is built for your platform."
+        )
+
+    return lib_path
+
+def _load_library():
+    """Load the ModAB shared library."""
+    lib_path = _get_library_path()
+    lib = ctypes.CDLL(lib_path)
+
+    # Configure modAB_find_root
+    lib.modAB_find_root.argtypes = [FUNC_TYPE, c_double, c_double, c_double, c_double, c_int]
+    lib.modAB_find_root.restype = c_double
+
+    # Configure modAB_default
+    lib.modAB_default.argtypes = [FUNC_TYPE, c_double, c_double]
+    lib.modAB_default.restype = c_double
+
+    # Configure get_evaluation_count
+    lib.get_evaluation_count.argtypes = []
+    lib.get_evaluation_count.restype = c_int
+
+    return lib
+
+# Load the library once at module import
+_lib = _load_library()
+
+
+def find_root(
+    f: Callable[[float], float],
+    x1: float,
+    x2: float,
+    atol: float = 1e-14,
+    rtol: float = 1e-14,
+    max_iter: int = 200
+) -> float:
+    """
+    Find the root of f(x) = 0 within the interval [x1, x2].
+
+    Uses an improved version of the Modified Anderson-Bjork method
+    (Ganchovski, Traykov) which combines bisection with the secant method
+    for robust and fast convergence.
+
+    Parameters
+    ----------
+    f : callable
+        A continuous function of one variable.
+    x1 : float
+        Left endpoint of the bracket interval.
+    x2 : float
+        Right endpoint of the bracket interval.
+    atol : float, optional
+        Absolute tolerance for convergence (default: 1e-14).
+    rtol : float, optional
+        Relative tolerance for convergence (default: 1e-14).
+    max_iter : int, optional
+        Maximum number of iterations (default: 200).
+
+    Returns
+    -------
+    float
+        The root of f(x) = 0 within [x1, x2].
+        Returns NaN if no root is found or if f(x1) and f(x2) have the same sign.
+
+    Notes
+    -----
+    The function f must be continuous on [x1, x2] and f(x1) * f(x2) < 0
+    (i.e., the function must have opposite signs at the endpoints).
+
+    Examples
+    --------
+    >>> import math
+    >>> from pymodab import find_root
+    >>> # Find the root of cos(x) - x in [0, 1]
+    >>> root = find_root(lambda x: math.cos(x) - x, 0, 1)
+    >>> print(f"{root:.10f}")
+    0.7390851332
+    """
+    c_func = FUNC_TYPE(f)
+    return _lib.modAB_find_root(c_func, x1, x2, atol, rtol, max_iter)
+
+
+def find_default(f: Callable[[float], float], x1: float, x2: float) -> float:
+    """
+    Find the root of f(x) = 0 within the interval [x1, x2] using default tolerances.
+
+    This is a convenience function that calls find_root with default parameters:
+    atol=1e-14, rtol=1e-14, max_iter=200.
+
+    Parameters
+    ----------
+    f : callable
+        A continuous function of one variable.
+    x1 : float
+        Left endpoint of the bracket interval.
+    x2 : float
+        Right endpoint of the bracket interval.
+
+    Returns
+    -------
+    float
+        The root of f(x) = 0 within [x1, x2].
+        Returns NaN if no root is found or if f(x1) and f(x2) have the same sign.
+
+    Examples
+    --------
+    >>> import math
+    >>> from pymodab import find_default
+    >>> root = find_default(lambda x: x**2 - 2, 1, 2)
+    >>> print(f"{root:.10f}")
+    1.4142135624
+    """
+    c_func = FUNC_TYPE(f)
+    return _lib.modAB_default(c_func, x1, x2)
+
+
+def get_evaluation_count() -> int:
+    """
+    Get the number of function evaluations from the last root-finding call.
+
+    Returns
+    -------
+    int
+        The number of times the function was evaluated during the last
+        call to find_root or find_default.
+
+    Examples
+    --------
+    >>> from pymodab import find_default, get_evaluation_count
+    >>> root = find_default(lambda x: x**2 - 2, 1, 2)
+    >>> print(f"Evaluations: {get_evaluation_count()}")
+    """
+    return _lib.get_evaluation_count()

pymodab-1.0.0/src/pymodab.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pymodab
+Version: 1.0.0
+Summary: Fast and robust root-finding using the Modified Anderson-Bjork method
+Author: Ganchovski, Traykov
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ModAB-Root-Finding/ModAB-Python
+Project-URL: Repository, https://github.com/ModAB-Root-Finding/ModAB-Python
+Keywords: root-finding,numerical,mathematics,optimization,bisection,secant
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+A fast and robust root-finding library using the Modified Anderson-Bjork method (Ganchovski, Traykov), written in C for Python.
+
+
+## Installation
+
+```bash
+pip install pymodab
+```
+
+## Usage
+
+```python
+import math
+from pymodab import find_root, find_default, get_evaluation_count
+
+# Find the root of cos(x) - x = 0 in [0, 1]
+root = find_root(lambda x: math.cos(x) - x, 0, 1, 100)
+print(f"Root: {root}")  # 0.7390851332151607
+
+# Using default tolerances
+root = find_default(lambda x: x**2 - 2, 1, 2)
+print(f"sqrt(2) = {root}")  # 1.4142135623730951
+
+# Get the number of function evaluations
+print(f"Evaluations: {get_evaluation_count()}")
+```
+
+## API
+
+### `find_root(f, x1, x2, atol=1e-14, rtol=1e-14, max_iter=200)`
+
+Find the root of `f(x) = 0` within the interval `[x1, x2]`.
+
+**Parameters:**
+- `f`: A continuous function of one variable
+- `x1`, `x2`: Bracket interval endpoints (must satisfy `f(x1) * f(x2) < 0`)
+- `atol`: Absolute tolerance (default: 1e-14)
+- `rtol`: Relative tolerance (default: 1e-14)
+- `max_iter`: Maximum iterations (default: 200)
+
+**Returns:** The root, or `NaN` if not found.
+
+### `find_default(f, x1, x2)`
+
+Convenience wrapper for `find_root` with default tolerances.
+
+### `get_evaluation_count()`
+
+Returns the number of function evaluations from the last root-finding call.
+
+## Algorithm
+
+Modified Anderson-Björck's method is a new robust and efficient bracketing root-finding algorithm. It combines bisection with Anderson-Björk's method to achieve both fast performance and worst-case optimality.
+
+References:
+
+Ganchovski N.; Traykov A. Modified Anderson-Björck's method for solving non-linear equations in structural mechanics. IOP Conference Series: Materials Science and Engineering 2023, 1276 (1) 012010, IOP Publishing. 
+https://iopscience.iop.org/article/10.1088/1757-899X/1276/1/012010/pdf
+
+Ganchovski, N.; Smith, O.; Rackauckas, C.; Tomov, L.; Traykov, A. Improvements of the Modified Anderson-Björck (modAB) Root-Finding Algorithm. Preprints 2026, 2026032190.
+https://www.preprints.org/manuscript/202603.2190
+
+## License
+
+MIT License

pymodab-1.0.0/src/pymodab.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/pymodab/ModAB.dll
+src/pymodab/ModAB.lib
+src/pymodab/__init__.py
+src/pymodab/libModAB.so
+src/pymodab/libModAB_arm64.dylib
+src/pymodab/libModAB_x64.dylib
+src/pymodab/modab.py
+src/pymodab/py.typed
+src/pymodab.egg-info/PKG-INFO
+src/pymodab.egg-info/SOURCES.txt
+src/pymodab.egg-info/dependency_links.txt
+src/pymodab.egg-info/top_level.txt

pymodab-1.0.0/src/pymodab.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pymodab-1.0.0/src/pymodab.egg-info/top_level.txt

@@ -0,0 +1 @@
+pymodab