@@ -4,5 +4,6 @@ from .notebook_integration import notebook_extension, live_plot

 from . import learner

 from . import runner

-from .learner import Learner1D, AverageLearner

+from .learner import (Learner1D, Learner2D, AverageLearner,

+                      BalancingLearner, DataSaver, IntegratorLearner)

 from .runner import Runner

@@ -18,8 +18,8 @@

     "`adaptive` needs the following packages:\n",

     "\n",

     "+ Python 3.6\n",

-    "+ holowiews\n",

-    "+ bokeh"

+    "+ `holoviews`\n",

+    "+ `bokeh`"

    ]

   },

   {

@@ -29,7 +29,13 @@

    "outputs": [],

    "source": [

     "import adaptive\n",

-    "adaptive.notebook_extension()"

+    "adaptive.notebook_extension()\n",

+    "\n",

+    "# Import modules that are used in multiple cells\n",

+    "import holoviews as hv\n",

+    "import numpy as np\n",

+    "from functools import partial\n",

+    "import random"

    ]

   },

   {

@@ -54,12 +60,9 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "from functools import partial\n",

-    "from random import random\n",

+    "offset = random.uniform(-0.5, 0.5)\n",

     "\n",

-    "offset = random() - 0.5\n",

-    "\n",

-    "def f(x, offset=0, wait=True):\n",

+    "def f(x, offset=offset, wait=True):\n",

     "    from time import sleep\n",

     "    from random import random\n",

     "\n",

@@ -82,7 +85,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "learner = adaptive.learner.Learner1D(f, bounds=(-1.0, 1.0))"

+    "learner = adaptive.Learner1D(f, bounds=(-1, 1))"

    ]

   },

   {

@@ -145,11 +148,9 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "import numpy as np\n",

+    "learner2 = adaptive.Learner1D(f, bounds=learner.bounds)\n",

     "\n",

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

-    "\n",

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

+    "xs = np.linspace(*learner.bounds, len(learner.data))\n",

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

     "\n",

     "learner.plot() + learner2.plot()"

@@ -175,7 +176,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

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

+    "def ring(xy, wait=True):\n",

     "    import numpy as np\n",

     "    from time import sleep\n",

     "    from random import random\n",

@@ -185,7 +186,7 @@

     "    a = 0.2\n",

     "    return x + np.exp(-(x**2 + y**2 - 0.75**2)**2/a**4)\n",

     "\n",

-    "learner = adaptive.learner.Learner2D(func, bounds=[(-1, 1), (-1, 1)])"

+    "learner = adaptive.Learner2D(ring, bounds=[(-1, 1), (-1, 1)])"

    ]

   },

   {

@@ -205,7 +206,6 @@

    "source": [

     "%%output size=100\n",

     "%%opts Contours (alpha=0.3)\n",

-    "import holoviews as hv\n",

     "\n",

     "def plot(learner):\n",

     "    tri = learner.ip().tri\n",

@@ -227,11 +227,12 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "import numpy as np\n",

-    "learner2 = adaptive.learner.Learner2D(func, bounds=[(-1, 1), (-1, 1)])\n",

-    "lin = np.linspace(-1, 1, len(learner.points)**0.5)\n",

-    "xy = [(x, y) for x in lin for y in lin]\n",

-    "learner2.add_data(xy, map(partial(func, wait=False), xy))\n",

+    "import itertools\n",

+    "learner2 = adaptive.Learner2D(ring, bounds=learner.bounds)\n",

+    "xs = np.linspace(*learner.bounds[0], learner.n**0.5)\n",

+    "ys = np.linspace(*learner.bounds[1], learner.n**0.5)\n",

+    "xys = list(itertools.product(xs, ys))\n",

+    "learner2.add_data(xys, map(partial(ring, wait=False), xys))\n",

     "learner2.plot().relabel('Homogeneous grid') + learner.plot().relabel('With adaptive')"

    ]

   },

@@ -276,7 +277,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "learner = adaptive.learner.AverageLearner(g, None, 0.01)\n",

+    "learner = adaptive.AverageLearner(g, atol=None, rtol=0.01)\n",

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

     "adaptive.live_plot(runner)"

    ]

@@ -303,9 +304,6 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "import numpy as np\n",

-    "import holoviews as hv\n",

-    "\n",

     "def f24(x):\n",

     "    return np.floor(np.exp(x))\n",

     "\n",

@@ -343,8 +341,9 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "learner = adaptive.learner.IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)\n",

-    "runner = adaptive.Runner(learner, executor=adaptive.runner.SequentialExecutor(), goal=lambda l: l.done())"

+    "from adaptive.runner import SequentialExecutor\n",

+    "learner = adaptive.IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)\n",

+    "runner = adaptive.Runner(learner, executor=SequentialExecutor(), goal=lambda l: l.done())"

    ]

   },

   {

@@ -396,11 +395,15 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "from adaptive.learner import Learner1D, BalancingLearner\n",

+    "def f(x, offset):\n",

+    "    a = 0.01\n",

+    "    return x + a**2 / (a**2 + (x - offset)**2)\n",

+    "\n",

+    "learners = [adaptive.Learner1D(partial(f, offset=random.uniform(-1, 1)),\n",

+    "            bounds=(-1, 1)) for i in range(10)]\n",

     "\n",

-    "learners = [Learner1D(partial(f, offset=2*random()-1, wait=False), bounds=(-1.0, 1.0)) for i in range(10)]\n",

-    "learner = BalancingLearner(learners)\n",

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

+    "bal_learner = adaptive.BalancingLearner(learners)\n",

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

    ]

   },

   {

@@ -409,8 +412,8 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "import holoviews as hv\n",

-    "adaptive.live_plot(runner, plotter=lambda learner: hv.Overlay([L.plot() for L in learner.learners]))"

+    "plotter = lambda learner: hv.Overlay([L.plot() for L in learner.learners])\n",

+    "adaptive.live_plot(runner, plotter=plotter)"

    ]

   },

   {

@@ -437,10 +440,9 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "from adaptive.learner import DataSaver, Learner1D\n",

     "from operator import itemgetter\n",

     "\n",

-    "def f(x):\n",

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

     "    \"\"\"The function evaluation takes roughly the time we `sleep`.\"\"\"\n",

     "    import random\n",

     "    from time import sleep\n",

@@ -453,10 +455,10 @@

     "\n",

     "# Create the learner with the function that returns a `dict`\n",

     "# Note that this learner cannot be passed to a runner.\n",

-    "_learner = Learner1D(f, bounds=(-1.0, 1.0))\n",

+    "_learner = adaptive.Learner1D(f_dict, bounds=(-1, 1))\n",

     "\n",

     "# Wrap the learner in the `DataSavingLearner` and tell it which key it needs to learn\n",

-    "learner = DataSaver(_learner, arg_picker=itemgetter('y'))"

+    "learner = adaptive.DataSaver(_learner, arg_picker=itemgetter('y'))"

    ]

   },

   {

@@ -548,7 +550,7 @@

     "\n",

     "executor = ProcessPoolExecutor(max_workers=4)\n",

     "\n",

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

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

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

     "adaptive.live_plot(runner)"

    ]

@@ -572,7 +574,7 @@

     "# f is a closure, so we have to use cloudpickle -- this is independent of 'adaptive'\n",

     "client[:].use_cloudpickle()\n",

     "\n",

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

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

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

     "adaptive.live_plot(runner)"

    ]

@@ -613,7 +615,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "learner = adaptive.learner.Learner1D(f, bounds=(-1.0, 1.0))\n",

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

     "runner = adaptive.Runner(learner)\n",

     "adaptive.live_plot(runner)"

    ]

@@ -717,7 +719,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

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

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

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

     "                         log=True)\n",

     "adaptive.live_plot(runner)"

@@ -738,7 +740,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

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

+    "reconstructed_learner = adaptive.Learner1D(f, bounds=(-1, 1))\n",

     "adaptive.runner.replay_log(reconstructed_learner, runner.log)"

    ]

   },

@@ -789,9 +791,8 @@

     "\n",

     "ioloop = asyncio.get_event_loop()\n",

     "\n",

-    "learner = adaptive.learner.IntegratorLearner(f24, bounds=(0, 3), tol=1e-3)\n",

-    "runner = adaptive.Runner(learner, executor=adaptive.runner.SequentialExecutor(),\n",

-    "                         goal=lambda l: l.done())\n",

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

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

     "\n",

     "timer = ioloop.create_task(time(runner))"

    ]