Merge branch 'bugfix/termination'

Closes #54.

See Merge Request !60.

Author: jbweston

adaptive/learner/learner1D.py

@@ -107,6 +107,9 @@ def __init__(self, function, bounds, loss_per_interval=None):
         self._scale = [bounds[1] - bounds[0], 0]
         self._oldscale = deepcopy(self._scale)
 
+        # The precision in 'x' below which we set losses to 0.
+        self._dx_eps = max(np.abs(bounds)) * np.finfo(float).eps
+
         self.bounds = list(bounds)
 
         self._vdim = None
@@ -132,12 +135,19 @@ def loss(self, real=True):
 
     def update_losses(self, x, data, neighbors, losses):
         x_lower, x_upper = neighbors[x]
+
+        def _update(interval):
+            a, b = interval
+            if abs(a - b) > self._dx_eps:
+                losses[interval] = self.loss_per_interval(interval,
+                                                          self._scale, data)
+            else:
+                losses[interval] = 0
+
         if x_lower is not None:
-            losses[x_lower, x] = self.loss_per_interval((x_lower, x),
-                                                        self._scale, data)
+            _update((x_lower, x))
         if x_upper is not None:
-            losses[x, x_upper] = self.loss_per_interval((x, x_upper),
-                                                        self._scale, data)
+            _update((x, x_upper))
         try:
             del losses[x_lower, x_upper]
         except KeyError:

adaptive/tests/test_learner.py

@@ -345,6 +345,34 @@ def test_learner1d_first_iteration():
     assert set(points) == set(to_see)
 
 
+def _run_on_discontinuity(x_0, bounds):
+
+    def f(x):
+        return -1 if x < x_0 else +1
+
+    learner = Learner1D(f, bounds)
+    while learner.loss() > 0.1:
+        (x,), _ = learner.choose_points(1)
+        learner.add_point(x, learner.function(x))
+
+    return learner
+
+
+def test_termination_on_discontinuities():
+
+    learner = _run_on_discontinuity(0, (-1, 1))
+    smallest_interval = min(abs(a - b) for a, b in learner.losses.keys())
+    assert smallest_interval >= np.finfo(float).eps
+
+    learner = _run_on_discontinuity(1, (-2, 2))
+    smallest_interval = min(abs(a - b) for a, b in learner.losses.keys())
+    assert smallest_interval >= np.finfo(float).eps
+
+    learner = _run_on_discontinuity(0.5E3, (-1E3, 1E3))
+    smallest_interval = min(abs(a - b) for a, b in learner.losses.keys())
+    assert smallest_interval >= 0.5E3 * np.finfo(float).eps
+
+
 @pytest.mark.xfail
 @run_with(Learner1D, Learner2D)
 def test_convergence_for_arbitrary_ordering(learner_type, f, learner_kwargs):