give 'tell' the functionality to handle both single values and iterables

Author: basnijholt

adaptive/learner/average_learner.py

@@ -45,10 +45,10 @@ def ask(self, n, add_data=True):
         points = list(range(self.n_requested, self.n_requested + n))
         loss_improvements = [self.loss_improvement(n) / n] * n
         if add_data:
-            self.add_data(points, itertools.repeat(None))
+            self.tell(points, itertools.repeat(None))
         return points, loss_improvements
 
-    def tell(self, n, value):
+    def _tell(self, n, value):
         value_is_new = not (n in self.data and value == self.data[n])
         if not value_is_new:
             value_old = self.data[n]

adaptive/learner/balancing_learner.py

@@ -74,7 +74,7 @@ def ask(self, n, add_data=True):
         else:
             return self._choose_and_tells(n)
 
-    def tell(self, x, y):
+    def _tell(self, x, y):
         index, x = x
         self._points.pop(index, None)
         self._loss.pop(index, None)

adaptive/learner/base_learner.py

@@ -23,7 +23,7 @@ class BaseLearner(metaclass=abc.ABCMeta):
     and returns a holoviews plot.
     """
 
-    def add_data(self, xvalues, yvalues):
+    def tell(self, xvalues, yvalues):
         """Add data to the learner.
 
         Parameters
@@ -37,12 +37,12 @@ def add_data(self, xvalues, yvalues):
         """
         if all(isinstance(i, collections.Iterable) for i in [xvalues, yvalues]):
             for x, y in zip(xvalues, yvalues):
-                self.tell(x, y)
+                self._tell(x, y)
         else:
-            self.tell(xvalues, yvalues)
+            self._tell(xvalues, yvalues)
 
     @abc.abstractmethod
-    def tell(self, x, y):
+    def _tell(self, x, y):
         """Add a single datapoint to the learner."""
         pass
 

adaptive/learner/data_saver.py

@@ -37,7 +37,7 @@ def __init__(self, learner, arg_picker):
         self.__getstate__ = self.learner.__getstate__
         self.__setstate__ = self.learner.__setstate__
 
-    def tell(self, x, result):
+    def _tell(self, x, result):
         y = self.arg_picker(result) if result is not None else None
         self.extra_data[x] = result
         self.learner.tell(x, y)

adaptive/learner/integrator_learner.py

@@ -359,7 +359,7 @@ def __init__(self, function, bounds, tol):
     def approximating_intervals(self):
         return self.first_ival.done_leaves
 
-    def tell(self, point, value):
+    def _tell(self, point, value):
         if point not in self.x_mapping:
             raise ValueError("Point {} doesn't belong to any interval"
                              .format(point))

adaptive/learner/learner1D.py

@@ -214,7 +214,7 @@ def update_scale(self, x, y):
                 self._bbox[1][1] = max(self._bbox[1][1], y)
                 self._scale[1] = self._bbox[1][1] - self._bbox[1][0]
 
-    def tell(self, x, y):
+    def _tell(self, x, y):
         real = y is not None
 
         if real:
@@ -305,7 +305,7 @@ def xs(x, n):
                                      for quality, x, n in quals))
 
         if add_data:
-            self.add_data(points, itertools.repeat(None))
+            self.tell(points, itertools.repeat(None))
 
         return points, loss_improvements
 

adaptive/learner/learner2D.py

@@ -287,7 +287,7 @@ def ip_combined(self):
                                                                  values)
         return self._ip_combined
 
-    def tell(self, point, value):
+    def _tell(self, point, value):
         point = tuple(point)
 
         if value is None:
@@ -336,15 +336,15 @@ def ask(self, n, add_data=True):
         points = list(self._stack.keys())
         loss_improvements = list(self._stack.values())
         n_left = n - len(points)
-        self.add_data(points[:n], itertools.repeat(None))
+        self.tell(points[:n], itertools.repeat(None))
 
         while n_left > 0:
             # The while loop is needed because `stack_till` could be larger
             # than the number of triangles between the points. Therefore
             # it could fill up till a length smaller than `stack_till`.
             new_points, new_loss_improvements = self._fill_stack(
                 stack_till=max(n_left, self.stack_size))
-            self.add_data(new_points[:n_left], itertools.repeat(None))
+            self.tell(new_points[:n_left], itertools.repeat(None))
             n_left -= len(new_points)
 
             points += new_points

adaptive/tests/test_cquad.py

@@ -25,7 +25,7 @@ def run_integrator_learner(f, a, b, tol, n):
     learner = IntegratorLearner(f, bounds=(a, b), tol=tol)
     for _ in range(n):
         points, _ = learner.ask(1)
-        learner.add_data(points, map(learner.function, points))
+        learner.tell(points, map(learner.function, points))
     return learner
 
 

adaptive/tests/test_learner.py

@@ -310,8 +310,8 @@ def test_learner_performance_is_invariant_under_scaling(learner_type, f, learner
     for n in range(npoints):
         cxs, _ = control.ask(1)
         xs, _ = learner.ask(1)
-        control.add_data(cxs, [control.function(x) for x in cxs])
-        learner.add_data(xs, [learner.function(x) for x in xs])
+        control.tell(cxs, [control.function(x) for x in cxs])
+        learner.tell(xs, [learner.function(x) for x in xs])
 
         # Check whether the points returned are the same
         xs_unscaled = np.array(xs) / xscale

benchmarks/benchmarks/benchmarks.py

@@ -24,7 +24,7 @@ def setup(self):
     def time_run(self):
         for _ in range(1000):
             points, _ = self.learner.ask(1)
-            self.learner.add_data(points, map(f_1d, points))
+            self.learner.tell(points, map(f_1d, points))
 
 
 class TimeLearner2D:
@@ -36,7 +36,7 @@ def setup(self):
     def time_run(self):
         for _ in range(50**2):
             points, _ = self.learner.ask(1)
-            self.learner.add_data(points, map(f_2d, points))
+            self.learner.tell(points, map(f_2d, points))
 
     def time_ask(self):
         for _ in range(50**2):