Break out bezier root finding and test it

scottshambaugh · scottshambaugh · commit 420631308a17 · 2026-02-03T08:29:51.000-07:00
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -27,7 +27,7 @@ def _bisect_root_finder(f, a, b, tol=1e-12, max_iter=64):
     return (a + b) * 0.5
 
 
-def _real_roots_in_01(coeffs):
+def _bisected_roots_in_01(coeffs):
     """
     Find real roots of polynomial in [0, 1] using sampling and bisection.
     coeffs in ascending order: c0 + c1*x + c2*x**2 + ...
@@ -87,6 +87,47 @@ def _quadratic_roots_in_01(c0, c1, c2):
     return roots[(roots >= 0) & (roots <= 1)]
 
 
+def _real_roots_in_01(coeffs):
+    """
+    Find real roots of a polynomial in the interval [0, 1].
+
+    This is optimized for finding roots only in [0, 1], which is faster than
+    computing all roots with `numpy.roots` and filtering. For polynomials of
+    degree <= 2, closed-form solutions are used. For higher degrees, sampling
+    and bisection are used.
+
+    Parameters
+    ----------
+    coeffs : array-like
+        Polynomial coefficients in ascending order:
+        ``c[0] + c[1]*x + c[2]*x**2 + ...``
+        Note this is the opposite convention from `numpy.roots`.
+
+    Returns
+    -------
+    roots : ndarray
+        Sorted array of real roots in [0, 1].
+    """
+    coeffs = np.asarray(coeffs, dtype=float)
+
+    # Trim trailing near-zeros to get actual degree
+    deg = len(coeffs) - 1
+    while deg > 0 and abs(coeffs[deg]) < 1e-12:
+        deg -= 1
+
+    if deg <= 0:
+        return np.array([])
+    elif deg == 1:
+        root = -coeffs[0] / coeffs[1]
+        return np.array([root]) if 0 <= root <= 1 else np.array([])
+    elif deg == 2:
+        roots = _quadratic_roots_in_01(coeffs[0], coeffs[1], coeffs[2])
+    else:
+        roots = _bisected_roots_in_01(coeffs[:deg + 1])
+
+    return np.sort(roots)
+
+
 @lru_cache(maxsize=16)
 def _get_coeff_matrix(n):
     """
@@ -391,21 +432,7 @@ def axis_aligned_extrema(self):
         all_roots = []
 
         for i, pi in enumerate(dCj.T):
-            # Trim trailing near-zeros to get actual degree
-            deg = len(pi) - 1
-            while deg > 0 and abs(pi[deg]) < 1e-12:
-                deg -= 1
-
-            if deg == 0:
-                continue
-            elif deg == 1:
-                root = -pi[0] / pi[1]
-                r = np.array([root]) if 0 <= root <= 1 else np.array([])
-            elif deg == 2:
-                r = _quadratic_roots_in_01(pi[0], pi[1], pi[2])
-            else:
-                r = _real_roots_in_01(pi[:deg + 1])
-
+            r = _real_roots_in_01(pi)
             if len(r) > 0:
                 all_roots.append(r)
                 all_dims.append(np.full(len(r), i))
diff --git a/lib/matplotlib/tests/test_bezier.py b/lib/matplotlib/tests/test_bezier.py
@@ -2,7 +2,57 @@
 Tests specific to the bezier module.
 """
 
-from matplotlib.bezier import inside_circle, split_bezier_intersecting_with_closedpath
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+
+from matplotlib.bezier import (
+    _real_roots_in_01, inside_circle, split_bezier_intersecting_with_closedpath
+)
+
+
+def _np_real_roots_in_01(coeffs):
+    """Reference implementation using np.roots for comparison."""
+    coeffs = np.asarray(coeffs)
+    # np.roots expects descending order (highest power first)
+    all_roots = np.roots(coeffs[::-1])
+    # Filter to real roots in [0, 1]
+    real_mask = np.abs(all_roots.imag) < 1e-10
+    real_roots = all_roots[real_mask].real
+    in_range = (real_roots >= -1e-10) & (real_roots <= 1 + 1e-10)
+    return np.sort(np.clip(real_roots[in_range], 0, 1))
+
+
+@pytest.mark.parametrize("coeffs, expected", [
+    ([-0.5, 1], [0.5]),
+    ([-2, 1], []),                    # roots: [2.0], not in [0, 1]
+    ([0.1875, -1, 1], [0.25, 0.75]),
+    ([1, -2.5, 1], [0.5]),            # roots: [0.5, 2.0], only one in [0, 1]
+    ([1, 0, 1], []),                  # roots: [+-i], not real
+    ([-0.08, 0.66, -1.5, 1], [0.2, 0.5, 0.8]),
+    ([5], []),
+    ([0, 0, 0], []),
+    ([0, -0.5, 1], [0.0, 0.5]),
+    ([0.5, -1.5, 1], [0.5, 1.0]),
+])
+def test_real_roots_in_01_known_cases(coeffs, expected):
+    """Test _real_roots_in_01 against known values and np.roots reference."""
+    result = _real_roots_in_01(coeffs)
+    np_expected = _np_real_roots_in_01(coeffs)
+    assert_allclose(result, expected, atol=1e-10)
+    assert_allclose(result, np_expected, atol=1e-10)
+
+
+@pytest.mark.parametrize("degree", range(1, 11))
+def test_real_roots_in_01_random(degree):
+    """Test random polynomials against np.roots."""
+    rng = np.random.default_rng(seed=0)
+    coeffs = rng.uniform(-10, 10, size=degree + 1)
+    result = _real_roots_in_01(coeffs)
+    expected = _np_real_roots_in_01(coeffs)
+    assert len(result) == len(expected)
+    if len(result) > 0:
+        assert_allclose(result, expected, atol=1e-8)
 
 
 def test_split_bezier_with_large_values():
