@@ -14,7 +14,6 @@

    "outputs": [],

    "source": [

     "import adaptive\n",

-    "import numpy as np\n",

     "adaptive.notebook_extension()\n",

     "\n",

     "def func(x, wait=True):\n",

@@ -26,7 +25,7 @@

     "    x = np.asarray(x)\n",

     "    a = 0.001\n",

     "    if wait:\n",

-    "        sleep(np.random.randint(1, 3))\n",

+    "        sleep(np.random.randint(0, 2) / 10)\n",

     "    return x + a**2/(a**2 + (x)**2)"

    ]

   },

@@ -39,22 +38,33 @@

     "## Local Process Pool (default)"

    ]

   },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {

+    "scrolled": false

+   },

+   "outputs": [],

+   "source": [

+    "learner = adaptive.learner.Learner1D(func, bounds=(-1.01, 1.0))\n",

+    "runner = adaptive.Runner(learner, goal=lambda l: l.loss(real=True) < 0.01)\n",

+    "adaptive.live_plot(runner)"

+   ]

+  },

   {

    "cell_type": "code",

    "execution_count": null,

    "metadata": {},

    "outputs": [],

    "source": [

-    "import concurrent.futures as concurrent\n",

-    "# Initialize the learner\n",

-    "learner = adaptive.learner.Learner1D(func, bounds=(-1, 1))\n",

-    "\n",

-    "# Next two lines not needed, but just as example that it still works\n",

-    "learner.add_point(-1, func(-1))\n",

-    "learner.add_point(1, func(1))\n",

+    "# Same function evaluated on homogeneous grid with same amount of points\n",

+    "from functools import partial\n",

+    "import numpy as np\n",

     "\n",

-    "runner = adaptive.Runner(learner, concurrent.ProcessPoolExecutor(48), goal=lambda l: l.loss(real=True) < 0.01)\n",

-    "adaptive.live_plot(runner)"

+    "learner2 = adaptive.learner.Learner1D(func, bounds=(-1.01, 1.0))\n",

+    "xs = np.linspace(-1.01, 1.0, len(learner.data))\n",

+    "learner2.add_data(xs, map(partial(func, wait=False), xs))\n",

+    "learner2.plot()"

    ]

   },

   {

@@ -83,6 +93,32 @@

     "runner = adaptive.Runner(learner, client, goal=lambda l: l.loss() < 0.1)\n",

     "adaptive.live_plot(runner)"

    ]

+  },

+  {

+   "cell_type": "markdown",

+   "metadata": {},

+   "source": [

+    "## 0D Learner"

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {

+    "scrolled": false

+   },

+   "outputs": [],

+   "source": [

+    "def func(x):\n",

+    "    import random\n",

+    "    import numpy as np\n",

+    "    from time import sleep\n",

+    "    sleep(np.random.randint(0, 2))\n",

+    "    return random.gauss(0.05, 1)\n",

+    "\n",

+    "learner = adaptive.learner.AverageLearner(func, None, 0.1)\n",

+    "runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 1)"

+   ]

   }

  ],

  "metadata": {

@@ -49,9 +49,10 @@ class BaseLearner(metaclass=abc.ABCMeta):

         """Add a single datapoint to the learner."""

         self.data[x] = y

+    @abc.abstractmethod

     def remove_unfinished(self):

         """Remove uncomputed data from the learner."""

-        self.data = {k: v for k, v in self.data.items() if v is not None}

+        pass

     @abc.abstractmethod

     def loss(self, real=True):

@@ -59,8 +60,8 @@ class BaseLearner(metaclass=abc.ABCMeta):

         Parameters

         ----------

-        expected : bool, default: False

-            If True, return the "expected" loss, i.e. the

+        real : bool, default: True

+            If False, return the "expected" loss, i.e. the

             loss including the as-yet unevaluated points

             (possibly by interpolation).

         """

@@ -95,6 +96,72 @@ class BaseLearner(metaclass=abc.ABCMeta):

             The number of points to choose.

         """

+class AverageLearner(BaseLearner):

+    def __init__(self, function, atol=None, rtol=None):

+        """A naive implementation of adaptive computing of averages.

+

+        The learned function must depend on an integer input variable that

+        represents the source of randomness.

+

+        Parameters:

+        -----------

+        atol : float

+            Desired absolute tolerance

+        rtol : float

+            Desired relative tolerance

+        """

+        super().__init__(function)

+

+        if atol is None and rtol is None:

+            raise Exception('At least one of `atol` and `rtol` should be set.')

+        if atol is None:

+            atol = np.inf

+        if rtol is None:

+            rtol = np.inf

+

+        self.function = function

+        self.atol = atol

+        self.rtol = rtol

+        self.n = 0

+        self.n_requested = 0

+        self.sum_f = 0

+        self.sum_f_sq = 0

+

+    def _choose_points(self, n=10):

+        return list(range(self.n_requested, self.n_requested + n))

+

+    def add_point(self, n, value):

+        super().add_point(n, value)

+        if value is None:

+            self.n_requested += 1

+            return

+        else:

+            self.n += 1

+            self.sum_f += value

+            self.sum_f_sq += value**2

+

+    @property

+    def mean(self):

+        return self.sum_f / self.n

+

+    @property

+    def std(self):

+        n = self.n

+        if n < 2:

+            return np.inf

+        return sqrt((self.sum_f_sq - n * self.mean**2) / (n - 1))

+

+    def loss(self, real=True):

+        n = self.n

+        if n < 2:

+            return np.inf

+        standard_error = self.std / sqrt(n if real else self.n_requested)

+        return max(standard_error / self.atol,

+                   standard_error / abs(self.mean) / self.rtol)

+

+    def remove_unfinished(self):

+        """Remove uncomputed data from the learner."""

+        pass

 class Learner1D(BaseLearner):

     """Learns and predicts a function 'f:ℝ → ℝ'.

@@ -247,7 +314,7 @@ class Learner1D(BaseLearner):

         return xs

     def remove_unfinished(self):

-        super().remove_unfinished()

+        self.data = {k: v for k, v in self.data.items() if v is not None}

         # self.losses = self.real_losses

         # self.neighbors = self.real_neighbors