@@ -14,6 +14,7 @@ from adaptive.learner import (

     Learner2D,

     LearnerND,

     make_datasaver,

+    SequenceLearner,

 )

 from adaptive.notebook_integration import (

     active_plotting_tasks,

@@ -36,6 +37,7 @@ __all__ = [

     "Learner2D",

     "LearnerND",

     "make_datasaver",

+    "SequenceLearner",

     "active_plotting_tasks",

     "live_plot",

     "notebook_extension",

@@ -10,6 +10,7 @@ from adaptive.learner.integrator_learner import IntegratorLearner

 from adaptive.learner.learner1D import Learner1D

 from adaptive.learner.learner2D import Learner2D

 from adaptive.learner.learnerND import LearnerND

+from adaptive.learner.sequence_learner import SequenceLearner

 __all__ = [

     "AverageLearner",

@@ -21,6 +22,7 @@ __all__ = [

     "Learner1D",

     "Learner2D",

     "LearnerND",

+    "SequenceLearner",

 ]

 with suppress(ImportError):

new file mode 100644

@@ -0,0 +1,82 @@

+from copy import copy

+import sys

+

+from adaptive.learner.base_learner import BaseLearner

+

+inf = sys.float_info.max

+

+

+def ensure_hashable(x):

+    try:

+        hash(x)

+        return x

+    except TypeError:

+        return tuple(x)

+

+

+class SequenceLearner(BaseLearner):

+    def __init__(self, function, sequence):

+        self.function = function

+        self._to_do_seq = {ensure_hashable(x) for x in sequence}

+        self._npoints = len(sequence)

+        self.sequence = copy(sequence)

+        self.data = {}

+        self.pending_points = set()

+

+    def ask(self, n, tell_pending=True):

+        points = []

+        loss_improvements = []

+        i = 0

+        for point in self._to_do_seq:

+            if i > n:

+                break

+            points.append(point)

+            loss_improvements.append(inf / self._npoints)

+            i += 1

+

+        if tell_pending:

+            for p in points:

+                self.tell_pending(p)

+

+        return points, loss_improvements

+

+    def _get_data(self):

+        return self.data

+

+    def _set_data(self, data):

+        if data:

+            self.tell_many(*zip(*data.items()))

+

+    def loss(self, real=True):

+        if not (self._to_do_seq or self.pending_points):

+            return 0

+        else:

+            npoints = self.npoints + (0 if real else len(self.pending_points))

+            return inf / npoints

+

+    def remove_unfinished(self):

+        for p in self.pending_points:

+            self._to_do_seq.add(p)

+        self.pending_points = set()

+

+    def tell(self, point, value):

+        self.data[point] = value

+        self.pending_points.discard(point)

+        self._to_do_seq.discard(point)

+

+    def tell_pending(self, point):

+        self.pending_points.add(point)

+        self._to_do_seq.discard(point)

+

+    def done(self):

+        return not self._to_do_seq and not self.pending_points

+

+    def result(self):

+        """Get back the data in the same order as ``sequence``."""

+        if not self.done():

+            raise Exception("Learner is not yet complete.")

+        return [self.data[ensure_hashable(x)] for x in self.sequence]

+

+    @property

+    def npoints(self):

+        return len(self.data)

@@ -24,6 +24,7 @@ from adaptive.learner import (

     Learner1D,

     Learner2D,

     LearnerND,

+    SequenceLearner,

 )

 from adaptive.runner import simple

@@ -116,6 +117,7 @@ def quadratic(x, m: uniform(0, 10), b: uniform(0, 1)):

 @learn_with(Learner1D, bounds=(-1, 1))

+@learn_with(SequenceLearner, sequence=np.linspace(-1, 1, 201))

 def linear_with_peak(x, d: uniform(-1, 1)):

     a = 0.01

     return x + a ** 2 / (a ** 2 + (x - d) ** 2)

@@ -123,6 +125,7 @@ def linear_with_peak(x, d: uniform(-1, 1)):

 @learn_with(LearnerND, bounds=((-1, 1), (-1, 1)))

 @learn_with(Learner2D, bounds=((-1, 1), (-1, 1)))

+@learn_with(SequenceLearner, sequence=np.random.rand(1000, 2))

 def ring_of_fire(xy, d: uniform(0.2, 1)):

     a = 0.2

     x, y = xy

@@ -130,12 +133,14 @@ def ring_of_fire(xy, d: uniform(0.2, 1)):

 @learn_with(LearnerND, bounds=((-1, 1), (-1, 1), (-1, 1)))

+@learn_with(SequenceLearner, sequence=np.random.rand(1000, 3))

 def sphere_of_fire(xyz, d: uniform(0.2, 1)):

     a = 0.2

     x, y, z = xyz

     return x + math.exp(-(x ** 2 + y ** 2 + z ** 2 - d ** 2) ** 2 / a ** 4) + z ** 2

+@learn_with(SequenceLearner, sequence=range(1000))

 @learn_with(AverageLearner, rtol=1)

 def gaussian(n):

     return random.gauss(0, 1)

@@ -247,7 +252,7 @@ def test_learner_accepts_lists(learner_type, bounds):

     simple(learner, goal=lambda l: l.npoints > 10)

-@run_with(Learner1D, Learner2D, LearnerND)

+@run_with(Learner1D, Learner2D, LearnerND, SequenceLearner)

 def test_adding_existing_data_is_idempotent(learner_type, f, learner_kwargs):

     """Adding already existing data is an idempotent operation.

@@ -283,7 +288,7 @@ def test_adding_existing_data_is_idempotent(learner_type, f, learner_kwargs):

 # XXX: This *should* pass (https://github.com/python-adaptive/adaptive/issues/55)

 #      but we xfail it now, as Learner2D will be deprecated anyway

-@run_with(Learner1D, xfail(Learner2D), LearnerND, AverageLearner)

+@run_with(Learner1D, xfail(Learner2D), LearnerND, AverageLearner, SequenceLearner)

 def test_adding_non_chosen_data(learner_type, f, learner_kwargs):

     """Adding data for a point that was not returned by 'ask'."""

     # XXX: learner, control and bounds are not defined

@@ -429,7 +434,12 @@ def test_learner_performance_is_invariant_under_scaling(

 @run_with(

-    Learner1D, Learner2D, LearnerND, AverageLearner, with_all_loss_functions=False

+    Learner1D,

+    Learner2D,

+    LearnerND,

+    AverageLearner,

+    SequenceLearner,

+    with_all_loss_functions=False,

 )

 def test_balancing_learner(learner_type, f, learner_kwargs):

     """Test if the BalancingLearner works with the different types of learners."""

@@ -474,6 +484,7 @@ def test_balancing_learner(learner_type, f, learner_kwargs):

     AverageLearner,

     maybe_skip(SKOptLearner),

     IntegratorLearner,

+    SequenceLearner,

     with_all_loss_functions=False,

 )

 def test_saving(learner_type, f, learner_kwargs):

@@ -504,6 +515,7 @@ def test_saving(learner_type, f, learner_kwargs):

     AverageLearner,

     maybe_skip(SKOptLearner),

     IntegratorLearner,

+    SequenceLearner,

     with_all_loss_functions=False,

 )

 def test_saving_of_balancing_learner(learner_type, f, learner_kwargs):

@@ -541,6 +553,7 @@ def test_saving_of_balancing_learner(learner_type, f, learner_kwargs):

     AverageLearner,

     maybe_skip(SKOptLearner),

     IntegratorLearner,

+    SequenceLearner,

     with_all_loss_functions=False,

 )

 def test_saving_with_datasaver(learner_type, f, learner_kwargs):