refactor: consolidate 1D cleanup tests

Author: basnijholt

adaptive/tests/test_learnernd.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 import scipy.spatial
 
 from adaptive.learner import LearnerND
@@ -50,16 +51,21 @@ def test_vector_return_with_a_flat_layer():
         simple(learner, loss_goal=0.1)
 
 
-def test_learnerND_1d_basic():
+@pytest.mark.parametrize(
+    ("run_kwargs", "expected_npoints"),
+    [
+        ({"npoints_goal": 10}, 10),
+        ({"loss_goal": 0.1}, None),
+    ],
+    ids=["npoints-goal", "loss-goal"],
+)
+def test_learnerND_1d(run_kwargs, expected_npoints):
     """Test LearnerND works with 1D bounds."""
     learner = LearnerND(lambda x: x[0] ** 2, bounds=[(-1, 1)])
-    simple(learner, npoints_goal=10)
-    assert learner.npoints == 10
-    assert learner.loss() < float("inf")
-
+    simple(learner, **run_kwargs)
 
-def test_learnerND_1d_with_loss_goal():
-    """Test LearnerND 1D converges with a loss goal."""
-    learner = LearnerND(lambda x: x[0] ** 2, bounds=[(-1, 1)])
-    simple(learner, loss_goal=0.1)
-    assert learner.loss() <= 0.1
+    if expected_npoints is not None:
+        assert learner.npoints == expected_npoints
+    assert learner.loss() < float("inf")
+    if "loss_goal" in run_kwargs:
+        assert learner.loss() <= run_kwargs["loss_goal"]

adaptive/tests/test_triangulation.py

@@ -76,14 +76,6 @@ def test_triangulation_raises_exception_for_1d_list():
     with pytest.raises(TypeError):
         Triangulation(pts)
 
-
-def test_triangulation_supports_1d_points():
-    pts = [(0,), (1,)]
-    t = Triangulation(pts)
-    assert t.simplices == {(0, 1)}
-    assert t.hull == {0, 1}
-
-
 @with_dimension_incl_1d
 def test_triangulation_of_standard_simplex(dim):
     t = Triangulation(_make_standard_simplex(dim))
@@ -336,61 +328,44 @@ def test_initialisation_accepts_more_than_one_simplex(dim):
 # ---- 1D-specific triangulation tests ----
 
 
-def test_1d_triangulation_basic():
-    """Test basic 1D triangulation with two points."""
-    t = Triangulation([(0.0,), (1.0,)])
-    assert t.simplices == {(0, 1)}
-    assert t.hull == {0, 1}
-    assert t.volume((0, 1)) == 1.0
-    _check_triangulation_is_valid(t)
-
-
-def test_1d_triangulation_multiple_points():
-    """Test 1D triangulation with multiple initial points."""
-    pts = [(0.0,), (0.5,), (1.0,)]
-    t = Triangulation(pts)
-    # Points 0=(0.0,), 1=(0.5,), 2=(1.0,) → sorted: 0, 1, 2
-    assert len(t.simplices) == 2
-    assert t.hull == {0, 2}  # endpoints
-    _check_triangulation_is_valid(t)
-    assert np.isclose(sum(t.volumes()), 1.0)
-
-
-def test_1d_triangulation_unsorted_points():
-    """Test that 1D triangulation handles unsorted initial points."""
-    pts = [(1.0,), (0.0,), (0.5,)]
-    t = Triangulation(pts)
-    assert len(t.simplices) == 2
+@pytest.mark.parametrize(
+    ("points", "expected_simplices", "expected_hull", "expected_total_volume"),
+    [
+        ([(0.0,), (1.0,)], {(0, 1)}, {0, 1}, 1.0),
+        ([(0.0,), (0.5,), (1.0,)], {(0, 1), (1, 2)}, {0, 2}, 1.0),
+        ([(1.0,), (0.0,), (0.5,)], {(0, 2), (1, 2)}, {0, 1}, 1.0),
+    ],
+    ids=["two-points", "sorted", "unsorted"],
+)
+def test_1d_triangulation_initialisation(
+    points, expected_simplices, expected_hull, expected_total_volume
+):
+    t = Triangulation(points)
+
+    assert t.simplices == expected_simplices
+    assert t.hull == expected_hull
     _check_triangulation_is_valid(t)
-    assert np.isclose(sum(t.volumes()), 1.0)
-
-
-def test_1d_add_point_inside():
-    """Test adding a point inside a 1D interval."""
-    t = Triangulation([(0.0,), (1.0,)])
-    _add_point_with_check(t, (0.5,))
-    assert len(t.simplices) == 2
-    assert t.hull == {0, 1}  # original endpoints are still hull
-    _check_triangulation_is_valid(t)
-    assert np.isclose(sum(t.volumes()), 1.0)
-
-
-def test_1d_add_point_outside_right():
-    """Test adding a point to the right of a 1D triangulation."""
+    assert np.isclose(sum(t.volumes()), expected_total_volume)
+
+
+@pytest.mark.parametrize(
+    ("point", "expected_simplices", "expected_hull", "expected_total_volume"),
+    [
+        ((0.5,), {(0, 2), (1, 2)}, {0, 1}, 1.0),
+        ((2.0,), {(0, 1), (1, 2)}, {0, 2}, 2.0),
+        ((-1.0,), {(0, 1), (0, 2)}, {1, 2}, 2.0),
+    ],
+    ids=["inside", "outside-right", "outside-left"],
+)
+def test_1d_add_point(point, expected_simplices, expected_hull, expected_total_volume):
     t = Triangulation([(0.0,), (1.0,)])
-    _add_point_with_check(t, (2.0,))
-    assert t.simplices == {(0, 1), (1, 2)}
-    assert t.hull == {0, 2}
-    _check_triangulation_is_valid(t)
 
+    _add_point_with_check(t, point)
 
-def test_1d_add_point_outside_left():
-    """Test adding a point to the left of a 1D triangulation."""
-    t = Triangulation([(0.0,), (1.0,)])
-    _add_point_with_check(t, (-1.0,))
-    assert t.simplices == {(0, 1), (0, 2)}
-    assert t.hull == {1, 2}
+    assert t.simplices == expected_simplices
+    assert t.hull == expected_hull
     _check_triangulation_is_valid(t)
+    assert np.isclose(sum(t.volumes()), expected_total_volume)
 
 
 def test_1d_locate_point():
@@ -407,18 +382,23 @@ def test_1d_locate_point():
     assert simplex == ()
 
 
-def test_1d_duplicate_coordinates_skipped():
+@pytest.mark.parametrize(
+    ("points", "expected_simplices"),
+    [
+        ([(0.0,), (1.0,), (1.0,)], {(0, 1)}),
+        ([(0.0,), (0.0,), (0.5,), (1.0,), (1.0,)], None),
+    ],
+    ids=["single-duplicate", "multiple-duplicates"],
+)
+def test_1d_duplicate_coordinates_skipped(points, expected_simplices):
     """Test that duplicate 1D coordinates don't create degenerate simplices."""
-    t = Triangulation([(0.0,), (1.0,), (1.0,)])
-    # The duplicate (1.0,) should be skipped, leaving only one simplex
-    assert t.simplices == {(0, 1)}
+    t = Triangulation(points)
+
+    if expected_simplices is not None:
+        assert t.simplices == expected_simplices
     assert all(v > 0 for v in t.volumes())
     _check_triangulation_is_valid(t)
-
-    # Multiple duplicates
-    t2 = Triangulation([(0.0,), (0.0,), (0.5,), (1.0,), (1.0,)])
-    assert all(v > 0 for v in t2.volumes())
-    _check_triangulation_is_valid(t2)
+    assert np.isclose(sum(t.volumes()), 1.0)
 
 
 def test_1d_opposing_vertices():

adaptive/tests/unit/test_learnernd.py

@@ -5,7 +5,13 @@
 from scipy.spatial import ConvexHull
 
 from adaptive.learner.base_learner import uses_nth_neighbors
-from adaptive.learner.learnerND import LearnerND, curvature_loss_function
+from adaptive.learner.learnerND import (
+    LearnerND,
+    curvature_loss_function,
+    default_loss,
+    std_loss,
+    uniform_loss,
+)
 
 
 def ring_of_fire(xy):
@@ -47,76 +53,87 @@ def loss(*args):
 # ---- 1D-specific LearnerND tests ----
 
 
+ONE_D_BOUNDS = [(-1, 1)]
+ONE_D_POINTS = (-1.0, -0.5, 0.0, 0.5, 1.0)
+
+
 def f_1d(x):
     """Simple 1D test function."""
     return x[0] ** 2
 
 
+def make_1d_learner(function=f_1d, **kwargs):
+    return LearnerND(function, bounds=ONE_D_BOUNDS, **kwargs)
+
+
+def tell_1d_points(learner, function=None, points=ONE_D_POINTS):
+    function = learner.function if function is None else function
+    for x in points:
+        learner.tell((x,), function((x,)))
+
+
+def initialize_1d_learner(**kwargs):
+    learner = make_1d_learner(**kwargs)
+    points, _ = learner.ask(2)
+    for point in points:
+        learner.tell(point, learner.function(point))
+    return learner
+
+
 def test_learnerND_1d_construction():
     """Test that LearnerND can be constructed with 1D bounds."""
-    learner = LearnerND(f_1d, bounds=[(-1, 1)])
+    learner = make_1d_learner()
     assert learner.ndim == 1
     assert learner._bounds_points == [(-1,), (1,)]
     assert learner._bbox == ((-1.0, 1.0),)
 
 
-def test_learnerND_1d_tell_ask():
+@pytest.mark.parametrize(
+    ("loss_fn", "expected_nth_neighbors"),
+    [
+        (None, 0),
+        (curvature_loss_function(), 1),
+    ],
+    ids=["default", "curvature"],
+)
+def test_learnerND_1d_tell_ask(loss_fn, expected_nth_neighbors):
     """Test basic tell/ask cycle for 1D LearnerND."""
-    learner = LearnerND(f_1d, bounds=[(-1, 1)])
-    # Ask for bound points first
-    points, losses = learner.ask(2)
-    assert len(points) == 2
-    # Tell the boundary values
-    for p in points:
-        learner.tell(p, f_1d(p))
-    # Now we should have a triangulation
+    kwargs = {} if loss_fn is None else {"loss_per_simplex": loss_fn}
+    learner = initialize_1d_learner(**kwargs)
+
     assert learner.tri is not None
-    # Ask for more points
+    assert learner.nth_neighbors == expected_nth_neighbors
+
     points2, losses2 = learner.ask(3)
+
     assert len(points2) == 3
+    assert all(loss > 0 for loss in losses2)
 
 
-def test_learnerND_1d_loss_functions():
+@pytest.mark.parametrize(
+    "loss_fn",
+    [
+        pytest.param(loss_fn, id=loss_fn.__name__)
+        for loss_fn in (default_loss, uniform_loss, std_loss)
+    ],
+)
+def test_learnerND_1d_loss_functions(loss_fn):
     """Test that all standard loss functions work for 1D."""
-    from adaptive.learner.learnerND import (
-        default_loss,
-        std_loss,
-        uniform_loss,
-    )
-
-    for loss_fn in [default_loss, uniform_loss, std_loss]:
-        learner = LearnerND(f_1d, bounds=[(-1, 1)], loss_per_simplex=loss_fn)
-        points, _ = learner.ask(2)
-        for p in points:
-            learner.tell(p, f_1d(p))
-        points2, losses2 = learner.ask(3)
-        assert len(points2) == 3
-        assert all(l > 0 for l in losses2)
-
-
-def test_learnerND_1d_curvature_loss():
-    """Test that curvature loss function works for 1D."""
-    loss = curvature_loss_function()
-    learner = LearnerND(f_1d, bounds=[(-1, 1)], loss_per_simplex=loss)
-    assert learner.nth_neighbors == 1
-    points, _ = learner.ask(2)
-    for p in points:
-        learner.tell(p, f_1d(p))
-    points2, _ = learner.ask(3)
+    learner = initialize_1d_learner(loss_per_simplex=loss_fn)
+    points2, losses2 = learner.ask(3)
+
     assert len(points2) == 3
+    assert all(loss > 0 for loss in losses2)
 
 
 def test_learnerND_1d_interpolation():
     """Test that 1D interpolation works correctly."""
-    learner = LearnerND(f_1d, bounds=[(-1, 1)])
-    # Tell some points
-    for x in [-1.0, -0.5, 0.0, 0.5, 1.0]:
-        learner.tell((x,), x**2)
+    learner = make_1d_learner()
+    tell_1d_points(learner)
     ip = learner._ip()
-    # Check interpolation at known points
+
     assert np.isclose(ip(0.0), 0.0)
     assert np.isclose(ip(1.0), 1.0)
-    # Check interpolation at midpoint (linear interpolation)
     assert np.isclose(ip(0.25), 0.125)  # linear between 0 and 0.5
 
 
@@ -126,9 +143,8 @@ def test_learnerND_1d_vector_output_interpolation():
     def f_vec(x):
         return np.array([x[0] ** 2, np.sin(x[0])])
 
-    learner = LearnerND(f_vec, bounds=[(-1, 1)])
-    for x in [-1.0, -0.5, 0.0, 0.5, 1.0]:
-        learner.tell((x,), f_vec((x,)))
+    learner = make_1d_learner(function=f_vec)
+    tell_1d_points(learner, function=f_vec)
     ip = learner._ip()
     result = ip(0.0)
     assert result.shape == (2,)
@@ -141,8 +157,7 @@ def test_learnerND_1d_plot():
     import holoviews as hv
 
     hv.extension("bokeh")
-    learner = LearnerND(f_1d, bounds=[(-1, 1)])
-    for x in [-1.0, -0.5, 0.0, 0.5, 1.0]:
-        learner.tell((x,), x**2)
+    learner = make_1d_learner()
+    tell_1d_points(learner)
     plot = learner.plot()
     assert plot is not None