More efficient 'tell_many'

import adaptive

def f(x, offset=0):
    a = 0.01
    return x + a**2 / (a**2 + (x - offset)**2)

learner = adaptive.Learner1D(f, bounds=(-1, 1))
adaptive.runner.simple(learner, goal=lambda l: l.npoints > 200)

Timing new implementation

%%timeit
learner2 = adaptive.Learner1D(f, bounds=(-1, 1))
learner2.tell_many(*zip(*learner.data.items()))

1.17 ms ± 24.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Timing old implementation

%%timeit
learner2 = adaptive.Learner1D(f, bounds=(-1, 1))
for x, y in learner.data.items():
    learner2.tell(x, y)

6.82 ms ± 447 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

This makes it ~6 times faster for functions that return scalars and is >10 times faster for vectors.

adaptive/learner/learner1D.py

@@ -132,7 +132,11 @@ class Learner1D(BaseLearner):
         if self._vdim is None:
             if self.data:
                 y = next(iter(self.data.values()))
-                self._vdim = len(np.squeeze(y))
+                try:
+                    self._vdim = len(np.squeeze(y))
+                except TypeError:
+                    # Means we are taking the length of a float
+                    self._vdim = 1
             else:
                 return 1
         return self._vdim
@@ -289,7 +293,7 @@ class Learner1D(BaseLearner):
         self.update_losses(x, real=False)
 
     def tell_many(self, xs, ys):
-        if len(xs) < max(2, 0.5 * len(self.data)):
+        if len(xs) > 0.5 * len(self.data) and len(xs) > 2:
             # Only run this more efficient method if there are
             # at least 2 points and the amount of points added are
             # at least half of the number of points already in 'data'.