@@ -26,24 +26,24 @@ class SKOptLearner(Optimizer, BaseLearner):

     def __init__(self, function, **kwargs):

         self.function = function

-        self.pending_points = list()

+        self.pending_points = set()

         self.data = OrderedDict()

         super().__init__(**kwargs)

     def tell(self, x, y, fit=True):

-        if x in self.pending_points:

-            self.pending_points.remove(x)

         if hasattr(x, '__iter__'):

+            self.pending_points.discard(tuple(x))

             self.data[tuple(x)] = y

             super().tell(x, y, fit)

         else:

+            self.pending_points.discard(x)

             self.data[x] = y

             super().tell([x], y, fit)

     def tell_pending(self, x):

         # 'skopt.Optimizer' takes care of points we

         # have not got results for.

-        self.pending_points.append(x)

+        self.pending_points.add(tuple(x))

     def remove_unfinished(self):

         pass

@@ -25,3 +25,23 @@ def test_skopt_learner_runs():

     for _ in range(11):

         (x,), _ = learner.ask(1)

         learner.tell(x, learner.function(x))

+

+

+@pytest.mark.skipif(not with_scikit_optimize, reason="scikit-optimize is not installed")

+def test_skopt_learner_4D_runs():

+    """The SKOptLearner provides very few guarantees about its

+       behaviour, so we only test the most basic usage

+       In this case we test also for 2D domain

+    """

+

+    def g(x, noise_level=0.1):

+        return np.sin(5 * (x[0] + x[1] + x[2] + x[3])) * (

+            1 - np.tanh(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2)

+        ) + np.random.randn() * noise_level

+

+    learner = SKOptLearner(g, dimensions=[(-2.0, 2.0), (-2.0, 2.0),

+                                            (-2.0, 2.0), (-2.0, 2.0)])

+

+    for _ in range(11):

+        (x,), _ = learner.ask(1)

+        learner.tell(x, learner.function(x))