sunnbear 0.2.2__tar.gz → 0.2.3__tar.gz

{sunnbear-0.2.2 → sunnbear-0.2.3}/.gitignore

@@ -12,9 +12,6 @@ __pycache__
 .coverage.*
 htmlcov
 
-# Jupyter Notebook checkpoints
-.ipynb_checkpoints
-
 # Virtual environment directories
 venv
 .env

{sunnbear-0.2.2 → sunnbear-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sunnbear
-Version: 0.2.2
+Version: 0.2.3
 Summary: Under construction.
 Project-URL: Source, https://github.com/bertpl/sunnbear
 Project-URL: ChangeLog, https://github.com/bertpl/sunnbear/blob/main/CHANGELOG.md
@@ -16,34 +16,44 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: backports-zstd>=1.0.0; python_version < '3.14'
-Requires-Dist: counted-float>=1.2.1
+Requires-Dist: counted-float>=1.2.1; python_version < '3.15'
+Requires-Dist: counted-float>=2.6.0; python_version >= '3.15'
 Requires-Dist: matplotlib>=3.10.7; python_version == '3.12'
 Requires-Dist: matplotlib>=3.10.7; python_version == '3.13'
-Requires-Dist: matplotlib>=3.10.7; python_version >= '3.14'
-Requires-Dist: max-div>=0.21.1
-Requires-Dist: mpl-composite>=0.1.2
+Requires-Dist: matplotlib>=3.10.7; python_version == '3.14'
+Requires-Dist: matplotlib>=3.11.2; python_version >= '3.15'
+Requires-Dist: max-div>=0.21.1; python_version < '3.15'
+Requires-Dist: max-div>=0.21.3; python_version >= '3.15'
+Requires-Dist: mpl-composite>=0.1.2; python_version < '3.15'
+Requires-Dist: mpl-composite>=0.1.4; python_version >= '3.15'
 Requires-Dist: numba>=0.60.0; python_version == '3.12'
 Requires-Dist: numba>=0.66.0; python_version == '3.13'
-Requires-Dist: numba>=0.66.0; python_version >= '3.14'
+Requires-Dist: numba>=0.66.0; python_version == '3.14'
+Requires-Dist: numba>=0.68.0; python_version >= '3.15'
 Requires-Dist: numpy>=2.0.0; python_version == '3.12'
 Requires-Dist: numpy>=2.1.0; python_version == '3.13'
-Requires-Dist: numpy>=2.3.2; python_version >= '3.14'
+Requires-Dist: numpy>=2.3.2; python_version == '3.14'
+Requires-Dist: numpy>=2.5.2; python_version >= '3.15'
 Requires-Dist: platformdirs>=4.0
-Requires-Dist: polars>=1.0.0
-Requires-Dist: pydantic>=2.12; python_version >= '3.14'
+Requires-Dist: polars>=1.0.0; python_version < '3.15'
+Requires-Dist: polars>=2.0.0; python_version >= '3.15'
+Requires-Dist: pydantic>=2.12; python_version == '3.14'
+Requires-Dist: pydantic>=2.14; python_version >= '3.15'
 Requires-Dist: pydantic>=2.7; python_version == '3.12'
 Requires-Dist: pydantic>=2.9; python_version == '3.13'
-Requires-Dist: snuffled>=0.1.6
+Requires-Dist: snuffled>=0.1.6; python_version < '3.15'
+Requires-Dist: snuffled>=0.1.9; python_version >= '3.15'
 Requires-Dist: typing-extensions>=4.4
 Description-Content-Type: text/markdown
 
 [![CI](https://img.shields.io/github/actions/workflow/status/bertpl/sunnbear/push_to_main.yml?branch=main&label=CI)](https://github.com/bertpl/sunnbear/actions/workflows/push_to_main.yml)
 [![Coverage](https://img.shields.io/badge/coverage-100.00%25-brightgreen)](https://github.com/bertpl/sunnbear/actions/workflows/push_to_main.yml)
-[![Tests](https://img.shields.io/badge/tests-1439-blue)](https://github.com/bertpl/sunnbear/actions/workflows/push_to_main.yml)
+[![Tests](https://img.shields.io/badge/tests-1451-blue)](https://github.com/bertpl/sunnbear/actions/workflows/push_to_main.yml)
 [![PyPI](https://img.shields.io/pypi/v/sunnbear.svg)](https://pypi.org/project/sunnbear/)
 [![Python](https://img.shields.io/pypi/pyversions/sunnbear.svg)](https://pypi.org/project/sunnbear/)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue)](https://github.com/bertpl/sunnbear/blob/main/LICENSE)
@@ -54,4 +64,4 @@ Description-Content-Type: text/markdown
 
 Under construction.
 
-![sunnbear splash](https://raw.githubusercontent.com/bertpl/sunnbear/v0.2.2/images/splash_with_version.webp)
+![sunnbear splash](https://raw.githubusercontent.com/bertpl/sunnbear/v0.2.3/images/splash_with_version.webp)

{sunnbear-0.2.2 → sunnbear-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sunnbear"
-version = "0.2.2"
+version = "0.2.3"
 description = "Under construction."
 # readme is dynamic: hatch-fancy-pypi-readme builds the PyPI long-description from README.md,
 # rewriting the relative splash link to a tag-pinned absolute URL (config below).
@@ -15,31 +15,45 @@ dependencies = [
     # Per-Python minimal versions: each is the earliest version shipping a wheel for that
     # CPython (and, for numpy, admitted by the numba minimal version on the same interpreter),
     # so `lowest-direct` installs (not source-builds) across the whole matrix.
+    #
+    # A pure-Python package ships 1 wheel that installs on every Python version, so the rule above does
+    # not apply to it: where its minimal version does not declare 3.15 support, a separate dependency line
+    # for 3.15 raises its minimal version to the earliest release that does.
     "numpy>=2.0.0; python_version == '3.12'",
     "numpy>=2.1.0; python_version == '3.13'",
-    "numpy>=2.3.2; python_version >= '3.14'",
+    "numpy>=2.3.2; python_version == '3.14'",
+    "numpy>=2.5.2; python_version >= '3.15'",
     "numba>=0.60.0; python_version == '3.12'",
     "numba>=0.66.0; python_version == '3.13'",
-    "numba>=0.66.0; python_version >= '3.14'",
+    "numba>=0.66.0; python_version == '3.14'",
+    "numba>=0.68.0; python_version >= '3.15'",
     "matplotlib>=3.10.7; python_version == '3.12'",
     "matplotlib>=3.10.7; python_version == '3.13'",
-    "matplotlib>=3.10.7; python_version >= '3.14'",
-    "counted-float>=1.2.1",
+    "matplotlib>=3.10.7; python_version == '3.14'",
+    "matplotlib>=3.11.2; python_version >= '3.15'",
+    "counted-float>=1.2.1; python_version < '3.15'",
+    "counted-float>=2.6.0; python_version >= '3.15'",
     # These pydantic minimal versions equal counted-float's own pydantic minimal versions; counted-float
     # depends on pydantic, so every install already satisfies them.
     "pydantic>=2.7; python_version == '3.12'",
     "pydantic>=2.9; python_version == '3.13'",
-    "pydantic>=2.12; python_version >= '3.14'",
+    "pydantic>=2.12; python_version == '3.14'",
+    "pydantic>=2.14; python_version >= '3.15'",
     "typing-extensions>=4.4",  # TypeVar defaults (PEP 696) on Python < 3.13
     "platformdirs>=4.0",  # platformdirs finds the user's cache directory for downloaded data artifacts
     # backports.zstd provides zstd for the archives of downloaded data artifacts; the standard library has it from 3.14.
     "backports.zstd>=1.0.0; python_version < '3.14'",
-    "snuffled>=0.1.6",
-    # max-div 0.21.1 adds the factory method DiversityMetric.min_separation(), which the construction of the Monte Carlo (MC) tuple set calls to create its diversity metric.
-    "max-div>=0.21.1",
-    "mpl-composite>=0.1.2",
-    # polars holds the benchmark results; its wheels use the stable CPython ABI, so 1 minimal version serves every supported Python version.
-    "polars>=1.0.0",
+    "snuffled>=0.1.6; python_version < '3.15'",
+    "snuffled>=0.1.9; python_version >= '3.15'",
+    # max-div 0.21.1 adds DiversityMetric.gpq_separation(q), the diversity metric that sunnbear maximizes when it builds the Monte Carlo (MC) tuple set.
+    "max-div>=0.21.1; python_version < '3.15'",
+    "max-div>=0.21.3; python_version >= '3.15'",
+    "mpl-composite>=0.1.2; python_version < '3.15'",
+    "mpl-composite>=0.1.4; python_version >= '3.15'",
+    # polars holds the benchmark results. Its wheels use the stable CPython ABI, so they install on every Python
+    # version, but on 3.15 the benchmark runner fails with polars 1.x.
+    "polars>=1.0.0; python_version < '3.15'",
+    "polars>=2.0.0; python_version >= '3.15'",
 ]
 classifiers = [
     "Development Status :: 2 - Pre-Alpha",
@@ -50,6 +64,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Scientific/Engineering :: Mathematics",
     "Typing :: Typed",
 ]
@@ -65,24 +80,18 @@ dev = [
     # exact tool versions are pinned by the tracked uv.lock (used by pre-commit,
     # `make lint`, and CI); these ranges just set the floor.
     "ruff>=0.15.11",
-    "scipy>=1.16.2",  # its root finders are what the solver tests compare against; never a runtime dependency
+    # The solver tests compare against scipy's root finders; scipy is never a runtime dependency. On 3.15,
+    # its minimal version is its first release with a 3.15 wheel.
+    "scipy>=1.16.2; python_version < '3.15'",
+    "scipy>=1.18.1; python_version >= '3.15'",
     "ty==0.0.56",  # pre-1.0 type checker — pin exactly; its ruleset is still evolving
 ]
-# maintainer scratch tooling — installed by a plain `uv sync` (default-groups below)
-# but NOT by CI's `uv sync --group dev` / `uv run --group dev`, keeping matrix jobs lean
-notebooks = [
-    "jupyterlab>=4.4.6",
-    "notebook>=7.4.5",
-]
-# packaging-integrity tooling for the _package_check.yml CI gate; opt-in via
-# `--group package`, kept out of the default dev/notebooks sync.
+# This group holds the packaging-integrity tooling for the _package_check.yml CI gate, which installs it with
+# `--group package`.
 package = [
     "check-wheel-contents>=0.6.2",
 ]
 
-[tool.uv]
-default-groups = ["dev", "notebooks"]
-
 [project.urls]
 Source = "https://github.com/bertpl/sunnbear"
 ChangeLog = "https://github.com/bertpl/sunnbear/blob/main/CHANGELOG.md"
@@ -189,8 +198,6 @@ invalid-method-override = "ignore"
 [tool.codespell]
 # "intoto": the in-toto attestation format (provenance.intoto.jsonl).
 ignore-words-list = "intoto"
-# Notebooks embed base64 image outputs that codespell misreads as typos.
-skip = "*.ipynb"
 
 [tool.pytest.ini_options]
 addopts = "--strict-markers"

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/benchmark/protocol/correctness.py

@@ -11,6 +11,8 @@ from collections.abc import Callable, Iterator, Sequence
 
 import numpy as np
 
+from sunnbear._core.utils.floats import FLOAT64_EPS
+
 # The largest number of function evaluations that 1 check spends before it judges the answer incorrect.
 CORRECTNESS_CHECK_MAX_FEVALS = 1000
 
@@ -85,11 +87,12 @@ def _random_x_probes(x_found: float, xtol: float, seed: int) -> Iterator[float]:
     likely, and uniform.
     """
     rng = np.random.default_rng(seed)
-    # Adding a distance below 1 ulp (unit in the last place) of `x_found` returns `x_found` unchanged. When
-    # `x_found` is 0, 1 ulp is about 5e-324, so log-uniform distances would spread over hundreds of orders of
+    # Adding a distance below 1 ulp (unit in the last place) of `x_found` returns `x_found` unchanged.
+    #
+    # When `x_found` is 0, 1 ulp is about 5e-324, so log-uniform distances would spread over hundreds of orders of
     # magnitude and almost all be negligible; the smallest log-uniform distance is therefore also held at or
-    # above `xtol · 2^-52`, the relative precision of a double.
-    log_distance_min = math.log(min(xtol, max(math.ulp(x_found), math.ldexp(xtol, -52))))
+    # above `xtol · FLOAT64_EPS`.
+    log_distance_min = math.log(min(xtol, max(math.ulp(x_found), xtol * FLOAT64_EPS)))
     log_distance_max = math.log(xtol)
     while True:
         for is_log_uniform in (True, False):

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/anderson_bjorck/state.py

@@ -20,14 +20,12 @@ class AndersonBjorckState(SolveState):
             scaling factor of every iteration that kept the bound again.
     """
 
-    newest_bound: IntervalBound = IntervalBound.UPPER
+    newest_bound: IntervalBound = field(init=False)
     newest_f: float = field(init=False)
     scaled_retained_f: float = field(init=False)
 
     def __post_init__(self) -> None:
-        """Set the starting values from the interval: `newest_f` is ``fb`` and `scaled_retained_f` is ``fa``.
-
-        These values hold only for the default `newest_bound`.
-        """
+        """Start with the upper bound as the newest bound: `newest_f` is ``fb`` and `scaled_retained_f` is ``fa``."""
+        self.newest_bound = IntervalBound.UPPER
         self.newest_f = self.interval.fb
         self.scaled_retained_f = self.interval.fa

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/brent/solver.py

@@ -1,11 +1,7 @@
 """`Brent` implements Brent's method: interpolation steps, with bisection when they converge too slowly."""
 
-import sys
-
 from sunnbear._core.solvers.core import Solver, SolveState
-
-# ``_MACHEPS`` is Brent's ``macheps``, the relative machine precision: 2^-52 for float64.
-_MACHEPS = sys.float_info.epsilon
+from sunnbear._core.utils.floats import FLOAT64_EPS
 
 
 class Brent(Solver):
@@ -30,9 +26,9 @@ class Brent(Solver):
 
     - ``b`` and ``c`` are the interval bounds, ``b`` the one with the smaller ``|f|``, which is the best estimate;
     - ``m`` is half the signed width of the interval, from ``b`` toward ``c``;
-    - ``tol = 2 * macheps * |b| + t`` is the tolerance, with ``macheps`` the relative machine precision and ``t`` an
-      absolute tolerance derived from ``xtol`` (below); the solve ends once ``|m| <= tol`` or ``f(b) = 0``, and
-      returns ``b``.
+    - ``tol = 2 * macheps * |b| + t`` is the tolerance, with ``macheps`` the relative machine precision
+      (`FLOAT64_EPS`) and ``t`` an absolute tolerance derived from ``xtol`` (below); the solve ends once
+      ``|m| <= tol`` or ``f(b) = 0``, and returns ``b``.
 
     Brent's procedure returns a ``b`` within ``6 * macheps * |x| + 2 * t`` of a root ``x``. The solver sets
     ``t = (xtol - 6 * macheps * max(|a0|, |b0|)) / 2``, with ``a0`` and ``b0`` the bounds of the initial interval,
@@ -77,7 +73,7 @@ class Brent(Solver):
         """
         interval = state.interval
         a, fa, b, fb = interval.a, interval.fa, interval.b, interval.fb
-        t = 0.5 * (state.xtol - 6.0 * _MACHEPS * max(abs(a), abs(b)))
+        t = 0.5 * (state.xtol - 6.0 * FLOAT64_EPS * max(abs(a), abs(b)))
         # The Algol label "int": c becomes a, the bound on the other side of the root from b.
         c, fc = a, fa
         d = e = b - a
@@ -86,7 +82,7 @@ class Brent(Solver):
             if abs(fc) < abs(fb):
                 a, b, c = b, c, b
                 fa, fb, fc = fb, fc, fb
-            tol = 2.0 * _MACHEPS * abs(b) + t
+            tol = 2.0 * FLOAT64_EPS * abs(b) + t
             m = 0.5 * (c - b)
             if abs(m) <= tol or fb == 0.0:
                 return b

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/illinois/state.py

@@ -17,9 +17,10 @@ class IllinoisState(SolveState):
             iteration that kept the bound again.
     """
 
-    newest_bound: IntervalBound = IntervalBound.UPPER
+    newest_bound: IntervalBound = field(init=False)
     scaled_retained_f: float = field(init=False)
 
     def __post_init__(self) -> None:
-        """Start with the lower bound as the retained bound, at its own function value."""
+        """Start with the upper bound as the newest bound: `scaled_retained_f` is ``fa``."""
+        self.newest_bound = IntervalBound.UPPER
         self.scaled_retained_f = self.interval.fa

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/itp/solver.py

@@ -7,6 +7,11 @@ from sunnbear._core.solvers.core import BracketingSolver, Interval
 from .state import ITPState
 from .variant import ITPVariant
 
+# ``kappa_1`` and ``kappa_2`` are the truncation constants that the `ITP` docstring gives. ``kappa_1`` depends on
+# the initial interval, so `ITP._solve` sets it per solve from `_KAPPA_1_TIMES_INITIAL_WIDTH`.
+_KAPPA_1_TIMES_INITIAL_WIDTH = 0.2
+_KAPPA_2 = 2
+
 
 class ITP(BracketingSolver[ITPState]):
     """`ITP` implements the ITP method, in the variant of its paper's pseudocode or in that of its paper's experiments.
@@ -70,9 +75,6 @@ class ITP(BracketingSolver[ITPState]):
     version = 1
     state_cls = ITPState
 
-    # `_KAPPA_2` is the paper's kappa_2; kappa_1 depends on the initial interval, so `_solve` sets it per solve.
-    _KAPPA_2 = 2
-
     def __init__(self, *, n_slack: int, variant: ITPVariant) -> None:
         """Configure the method.
 
@@ -99,7 +101,7 @@ class ITP(BracketingSolver[ITPState]):
         """
         width = state.interval.width
         n_bisection = math.ceil(math.log2(width / (2.0 * state.xtol)))
-        state.kappa_1 = 0.2 / width
+        state.kappa_1 = _KAPPA_1_TIMES_INITIAL_WIDTH / width
         state.max_next_width = state.xtol * 2.0 ** (n_bisection + self.n_slack)
         return super()._solve(state)
 
@@ -121,7 +123,7 @@ class ITP(BracketingSolver[ITPState]):
             sigma = -1.0
         else:
             sigma = 0.0
-        delta = state.kappa_1 * interval.width**self._KAPPA_2
+        delta = state.kappa_1 * interval.width**_KAPPA_2
         if delta <= abs(x_half_minus_x_f):
             x_t = x_f + sigma * delta
         else:

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/modab/solver.py

@@ -22,7 +22,7 @@ class ModAB(Solver):
 
     ``x3`` replaces the bound whose function value has the sign of ``y3``.
 
-    In Anderson-Björck mode, when the same bound stays fixed in 2 iterations in a row, its stored function value is
+    In Anderson-Björck mode, when the same bound is retained in 2 iterations in a row, its stored function value is
     multiplied by the factor of `AndersonBjorck`, ``m = 1 - y3 / y_moved``, where ``y_moved`` is the function value at
     the replaced bound; where ``m`` is not positive, the factor is 0.5.
 
@@ -42,7 +42,7 @@ class ModAB(Solver):
     - **Clamping:** Algorithm 1 evaluates the chord's zero and then clamps it into the interval. The C# code clamps
       first: a chord's zero that rounding puts on or outside a bound is replaced by that bound and its stored function
       value, so nothing is evaluated. In Anderson-Björck mode, such an iteration only halves the stored function value
-      at the other bound, or marks the other bound as fixed.
+      at the other bound, or marks the other bound as retained.
     - **The first threshold:** only the C# code shows the threshold's starting value at the switch.
     - **Scaled function values:** Anderson-Björck mode's scaled function values stay stored after a fallback to
       bisection, and the next bisection steps read them when they test whether the function looks close to a straight
@@ -81,7 +81,7 @@ class ModAB(Solver):
 
         - ``x_new`` and ``y_new`` are the point that replaces a bound: ``x3`` and ``y3``, or, when ``x3`` is clamped
           onto a bound, that bound with its stored function value;
-        - ``fixed_bound`` is the bound that stayed fixed in the last Anderson-Björck step, ``None`` before the first;
+        - ``retained_bound`` is the bound that was retained in the last Anderson-Björck step, ``None`` before the first;
           the C# code stores it as the integer ``side``, although the comment on ``side`` calls it the side that moved
           last;
         - ``is_bisecting`` is the mode, ``bisection`` in the C# code.
@@ -91,13 +91,13 @@ class ModAB(Solver):
         - computes ``x3``, and ends the solve if the interval is narrow enough;
         - evaluates ``x3``, unless it is clamped, and in bisection mode tests whether to switch;
         - ends the solve if ``y_new = 0``;
-        - replaces a bound by ``(x_new, y_new)``, scaling the fixed bound's function value in Anderson-Björck mode;
+        - replaces a bound by ``(x_new, y_new)``, scaling the retained bound's function value in Anderson-Björck mode;
         - falls back to bisection if the interval is wider than the threshold.
         """
         interval = state.interval
         x1, y1, x2, y2 = interval.a, interval.fa, interval.b, interval.fb
         is_bisecting = True
-        fixed_bound: IntervalBound | None = None
+        retained_bound: IntervalBound | None = None
         threshold = x2 - x1
         while True:
             # --- the new x-value x3 -------------
@@ -137,23 +137,23 @@ class ModAB(Solver):
             # The C# code compares Math.Sign(y_new) with Math.Sign(y1); the test below gives the same result because
             # y_new is not 0 here.
             if (y_new > 0.0 and y1 > 0.0) or (y_new < 0.0 and y1 < 0.0):
-                if fixed_bound is IntervalBound.UPPER:
+                if retained_bound is IntervalBound.UPPER:
                     m = 1.0 - y_new / y1
                     y2 = y2 * (0.5 if m <= 0.0 else m)
                 elif not is_bisecting:
-                    fixed_bound = IntervalBound.UPPER
+                    retained_bound = IntervalBound.UPPER
                 x1, y1 = x_new, y_new
             else:
-                if fixed_bound is IntervalBound.LOWER:
+                if retained_bound is IntervalBound.LOWER:
                     m = 1.0 - y_new / y2
                     y1 = y1 * (0.5 if m <= 0.0 else m)
                 elif not is_bisecting:
-                    fixed_bound = IntervalBound.LOWER
+                    retained_bound = IntervalBound.LOWER
                 x2, y2 = x_new, y_new
             if x2 - x1 > threshold:
                 # The Anderson-Björck steps shrink the interval too slowly: fall back to bisection.
                 is_bisecting = True
-                fixed_bound = None
+                retained_bound = None
 
     # --------------------------------------------------------------------------
     #  Helpers

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/pegasus/state.py

@@ -19,14 +19,12 @@ class PegasusState(SolveState):
             scaling factor of every iteration that kept the bound again.
     """
 
-    newest_bound: IntervalBound = IntervalBound.UPPER
+    newest_bound: IntervalBound = field(init=False)
     newest_f: float = field(init=False)
     scaled_retained_f: float = field(init=False)
 
     def __post_init__(self) -> None:
-        """Set the starting values from the interval: `newest_f` is ``fb`` and `scaled_retained_f` is ``fa``.
-
-        These values hold only for the default `newest_bound`.
-        """
+        """Start with the upper bound as the newest bound: `newest_f` is ``fb`` and `scaled_retained_f` is ``fa``."""
+        self.newest_bound = IntervalBound.UPPER
         self.newest_f = self.interval.fb
         self.scaled_retained_f = self.interval.fa

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/bracketing/toms748/solver.py

@@ -1,11 +1,7 @@
 """`TOMS748` implements Algorithm 748: interpolation steps, a double-size secant step, and bisection if needed."""
 
-import sys
-
 from sunnbear._core.solvers.core import Interval, IntervalBound, Solver, SolveState
-
-# ``_MACHEPS`` is the paper's ``macheps``, the relative machine precision: 2^-52 for float64.
-_MACHEPS = sys.float_info.epsilon
+from sunnbear._core.utils.floats import FLOAT64_EPS
 
 # ``_MU`` is the paper's ``mu``: an iteration that leaves the interval wider than ``_MU`` times its width at the start
 # of the iteration ends with a bisection.
@@ -40,8 +36,8 @@ class TOMS748(Solver):
     The paper states the 2 algorithms without a stopping criterion; its experiments, and the authors' code, add the
     stopping criterion of Brent's method:
 
-    - ``stop_width = 2 * (2 * macheps * |u| + tol)``, with ``macheps`` the relative machine precision and ``tol`` an
-      absolute tolerance that the solver derives from ``xtol``;
+    - ``stop_width = 2 * (2 * macheps * |u| + tol)``, with ``macheps`` the relative machine precision
+      (`FLOAT64_EPS`) and ``tol`` an absolute tolerance that the solver derives from ``xtol``;
     - the solve ends once the interval is at most ``stop_width`` wide, or once an evaluation returns exactly 0, and
       returns the lower bound ``a``, or the point that returned 0.
 
@@ -162,7 +158,7 @@ class TOMS748(Solver):
     @staticmethod
     def _get_tol(xtol: float, a0: float, b0: float) -> float:
         """Return the ``tol`` that keeps ``stop_width`` at most ``xtol``, or 0 where that ``tol`` would be negative."""
-        return max(0.5 * xtol - 2.0 * _MACHEPS * max(abs(a0), abs(b0)), 0.0)
+        return max(0.5 * xtol - 2.0 * FLOAT64_EPS * max(abs(a0), abs(b0)), 0.0)
 
     @staticmethod
     def _get_u(interval: Interval) -> tuple[float, float]:
@@ -176,7 +172,7 @@ class TOMS748(Solver):
     def _get_stop_width(interval: Interval, tol: float) -> float:
         """Return ``stop_width = 2 * (2 * macheps * |u| + tol)`` for ``interval``, the authors' subroutine ``TOLE``."""
         u, _ = TOMS748._get_u(interval)
-        return 2.0 * (tol + 2.0 * abs(u) * _MACHEPS)
+        return 2.0 * (tol + 2.0 * abs(u) * FLOAT64_EPS)
 
     def _evaluate_and_split_at(
         self, state: SolveState, interval: Interval, c: float, stop_width: float, tol: float

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/core/interval.py

@@ -115,13 +115,13 @@ class Interval(ABC):
         else:
             return type(self)(self.a, x, self.fa, fx, IntervalBound.UPPER)
 
-    def is_converged(self, doubled_xtol: float) -> bool:
-        """Return whether a stopping criterion holds: the width is at most ``doubled_xtol`` or a bound value is zero.
+    def is_converged(self, xtol_doubled: float) -> bool:
+        """Return whether the width is at most ``xtol_doubled`` or the function value at a bound is zero.
 
         The parameter is the doubled tolerance, so the caller computes it once
         per solve, not once per iteration.
         """
-        return self.width <= doubled_xtol or self.is_fa_zero or self.is_fb_zero
+        return self.width <= xtol_doubled or self.is_fa_zero or self.is_fb_zero
 
     def root(self) -> float:
         """Return the best root estimate without another step: a bound with a zero value if any, else the midpoint."""

{sunnbear-0.2.2 → sunnbear-0.2.3}/src/sunnbear/_core/solvers/core/solver.py

@@ -95,15 +95,15 @@ class Solver(ABC, Generic[StateT]):
             ValueError: If ``a >= b``, or ``f(a)`` and ``f(b)`` have the same sign and neither is
                 zero — a caller error, not a solve outcome.
         """
-        # --- uncounted validation -------------------
+        # --- uncounted validation ---------------
         if not a < b:
             raise ValueError(f"Interval must satisfy a < b (got a={a}, b={b}).")
         wrapped_f = WrappedFunction(f, max_fevals=max_fevals, history_enabled=history_enabled)
 
-        # --- counted: main algorithm ----------------
+        # --- counted: main algorithm ------------
         x_failed: float | None = None  # Where f failed, if it did; decides FUNCTION_ERROR versus DIVERGED below.
         with FlopCountingContext() as flop_ctx:
-            # --- prep and early exits ---------------
+            # --- prep and early exits -----------
             a_counted, b_counted, xtol_counted = CountedFloat(a), CountedFloat(b), CountedFloat(xtol)
             try:
                 fa, fb = wrapped_f(a_counted), wrapped_f(b_counted)
@@ -115,7 +115,7 @@ class Solver(ABC, Generic[StateT]):
                 elif fb == 0.0:  # Early exit when b is a root.
                     x, status = b_counted, SolveStatus.CONVERGED
                 else:
-                    # --- actual solve -----------------------
+                    # --- actual solve -----------
                     interval = Interval.from_interval_bounds(a_counted, b_counted, fa, fb)
                     state = self.state_cls(f=wrapped_f, interval=interval, xtol=xtol_counted, x_best=interval.midpoint)
                     try:
@@ -124,7 +124,7 @@ class Solver(ABC, Generic[StateT]):
                     except Exception as exc:  # noqa: BLE001 — every ending becomes a recorded status, by design
                         x, status, x_failed = _ending_of(exc, x_best=state.x_best)
 
-        # --- return results -------------------------
+        # --- return results ---------------------
         # Divergence is the framework's judgment, not solver work, so these checks are uncounted.
         x_plain = float(x)
         if x_failed is not None and not a <= x_failed <= b:

sunnbear-0.2.3/src/sunnbear/_core/utils/floats.py

@@ -0,0 +1,7 @@
+"""This module holds the float64 constants that several packages share."""
+
+import sys
+
+# `FLOAT64_EPS` is 2^-52, the distance from 1.0 to the next larger float64 value; papers on root finding call it
+# ``macheps``, the relative machine precision.
+FLOAT64_EPS = sys.float_info.epsilon