change "execute" into "jupyter-execute"

Author: basnijholt

docs/source/rest_of_readme.rst

@@ -36,7 +36,7 @@ Examples
 Here are some examples of how Adaptive samples vs. homogeneous sampling. Click
 on the *Play* :fa:`play` button or move the sliders.
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     import itertools
@@ -52,7 +52,7 @@ on the *Play* :fa:`play` button or move the sliders.
 `adaptive.Learner1D`
 ~~~~~~~~~~~~~~~~~~~~
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     %%opts Layout [toolbar=None]
@@ -87,7 +87,7 @@ on the *Play* :fa:`play` button or move the sliders.
 `adaptive.Learner2D`
 ~~~~~~~~~~~~~~~~~~~~
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     def ring(xy):
@@ -116,7 +116,7 @@ on the *Play* :fa:`play` button or move the sliders.
 `adaptive.AverageLearner`
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     def g(n):

docs/source/tutorial/tutorial.AverageLearner.rst

@@ -8,11 +8,10 @@ Tutorial `~adaptive.AverageLearner`
 
 .. seealso::
     The complete source code of this tutorial can be found in
-    :jupyter-download:notebook:`AverageLearner`
+    :jupyter-download:notebook:`tutorial.AverageLearner`
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
-    :new-notebook: AverageLearner
 
     import adaptive
     adaptive.notebook_extension()
@@ -25,7 +24,7 @@ the learner must formally take a single parameter, which should be used
 like a “seed” for the (pseudo-) random variable (although in the current
 implementation the seed parameter can be ignored by the function).
 
-.. execute::
+.. jupyter-execute::
 
     def g(n):
         import random
@@ -38,20 +37,20 @@ implementation the seed parameter can be ignored by the function).
         random.setstate(state)
         return val
 
-.. execute::
+.. jupyter-execute::
 
     learner = adaptive.AverageLearner(g, atol=None, rtol=0.01)
     runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 2)
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     await runner.task  # This is not needed in a notebook environment!
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_info()
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_plot(update_interval=0.1)

docs/source/tutorial/tutorial.BalancingLearner.rst

@@ -8,11 +8,10 @@ Tutorial `~adaptive.BalancingLearner`
 
 .. seealso::
     The complete source code of this tutorial can be found in
-    :jupyter-download:notebook:`BalancingLearner`
+    :jupyter-download:notebook:`tutorial.BalancingLearner`
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
-    :new-notebook: BalancingLearner
 
     import adaptive
     adaptive.notebook_extension()
@@ -30,7 +29,7 @@ improvement.
 The balancing learner can for example be used to implement a poor-man’s
 2D learner by using the `~adaptive.Learner1D`.
 
-.. execute::
+.. jupyter-execute::
 
     def h(x, offset=0):
         a = 0.01
@@ -42,16 +41,16 @@ The balancing learner can for example be used to implement a poor-man’s
     bal_learner = adaptive.BalancingLearner(learners)
     runner = adaptive.Runner(bal_learner, goal=lambda l: l.loss() < 0.01)
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     await runner.task  # This is not needed in a notebook environment!
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_info()
 
-.. execute::
+.. jupyter-execute::
 
     plotter = lambda learner: hv.Overlay([L.plot() for L in learner.learners])
     runner.live_plot(plotter=plotter, update_interval=0.1)
@@ -61,7 +60,7 @@ product of parameters. For that particular case we’ve added a
 ``classmethod`` called ``~adaptive.BalancingLearner.from_product``.
 See how it works below
 
-.. execute::
+.. jupyter-execute::
 
     from scipy.special import eval_jacobi
 

docs/source/tutorial/tutorial.DataSaver.rst

@@ -8,11 +8,10 @@ Tutorial `~adaptive.DataSaver`
 
 .. seealso::
     The complete source code of this tutorial can be found in
-    :jupyter-download:notebook:`DataSaver`
+    :jupyter-download:notebook:`tutorial.DataSaver`
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
-    :new-notebook: DataSaver
 
     import adaptive
     adaptive.notebook_extension()
@@ -23,7 +22,7 @@ metadata, you can wrap your learner in an `adaptive.DataSaver`.
 In the following example the function to be learned returns its result
 and the execution time in a dictionary:
 
-.. execute::
+.. jupyter-execute::
 
     from operator import itemgetter
 
@@ -48,27 +47,27 @@ and the execution time in a dictionary:
 ``learner.learner`` is the original learner, so
 ``learner.learner.loss()`` will call the correct loss method.
 
-.. execute::
+.. jupyter-execute::
 
     runner = adaptive.Runner(learner, goal=lambda l: l.learner.loss() < 0.1)
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     await runner.task  # This is not needed in a notebook environment!
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_info()
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_plot(plotter=lambda l: l.learner.plot(), update_interval=0.1)
 
 Now the ``DataSavingLearner`` will have an dictionary attribute
 ``extra_data`` that has ``x`` as key and the data that was returned by
 ``learner.function`` as values.
 
-.. execute::
+.. jupyter-execute::
 
     learner.extra_data

docs/source/tutorial/tutorial.IntegratorLearner.rst

@@ -8,11 +8,10 @@ Tutorial `~adaptive.IntegratorLearner`
 
 .. seealso::
     The complete source code of this tutorial can be found in
-    :jupyter-download:notebook:`IntegratorLearner`
+    :jupyter-download:notebook:`tutorial.IntegratorLearner`
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
-    :new-notebook: IntegratorLearner
 
     import adaptive
     adaptive.notebook_extension()
@@ -27,7 +26,7 @@ of the integral with it. It is based on Pedro Gonnet’s
 Let’s try the following function with cusps (that is difficult to
 integrate):
 
-.. execute::
+.. jupyter-execute::
 
     def f24(x):
         return np.floor(np.exp(x))
@@ -40,7 +39,7 @@ let’s try a familiar function integrator `scipy.integrate.quad`, which
 will give us warnings that it encounters difficulties (if we run it
 in a notebook.)
 
-.. execute::
+.. jupyter-execute::
 
     import scipy.integrate
     scipy.integrate.quad(f24, 0, 3)
@@ -50,7 +49,7 @@ we want to reach. Then in the `~adaptive.Runner` we pass
 ``goal=lambda l: l.done()`` where ``learner.done()`` is ``True`` when
 the relative tolerance has been reached.
 
-.. execute::
+.. jupyter-execute::
 
     from adaptive.runner import SequentialExecutor
 
@@ -61,24 +60,24 @@ the relative tolerance has been reached.
     # the overhead of evaluating the function in another process.
     runner = adaptive.Runner(learner, executor=SequentialExecutor(), goal=lambda l: l.done())
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     await runner.task  # This is not needed in a notebook environment!
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_info()
 
 Now we could do the live plotting again, but lets just wait untill the
 runner is done.
 
-.. execute::
+.. jupyter-execute::
 
     if not runner.task.done():
         raise RuntimeError('Wait for the runner to finish before executing the cells below!')
 
-.. execute::
+.. jupyter-execute::
 
     print('The integral value is {} with the corresponding error of {}'.format(learner.igral, learner.err))
     learner.plot()

docs/source/tutorial/tutorial.Learner1D.rst

@@ -8,11 +8,10 @@ Tutorial `~adaptive.Learner1D`
 
 .. seealso::
     The complete source code of this tutorial can be found in
-    :jupyter-download:notebook:`Learner1D`
+    :jupyter-download:notebook:`tutorial.Learner1D`
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
-    :new-notebook: Learner1D
 
     import adaptive
     adaptive.notebook_extension()
@@ -30,7 +29,7 @@ We start with the most common use-case: sampling a 1D function
 We will use the following function, which is a smooth (linear)
 background with a sharp peak at a random location:
 
-.. execute::
+.. jupyter-execute::
 
     offset = random.uniform(-0.5, 0.5)
 
@@ -47,7 +46,7 @@ We start by initializing a 1D “learner”, which will suggest points to
 evaluate, and adapt its suggestions as more and more points are
 evaluated.
 
-.. execute::
+.. jupyter-execute::
 
     learner = adaptive.Learner1D(f, bounds=(-1, 1))
 
@@ -61,13 +60,13 @@ On Windows systems the runner will try to use a `distributed.Client`
 if `distributed` is installed. A `~concurrent.futures.ProcessPoolExecutor`
 cannot be used on Windows for reasons.
 
-.. execute::
+.. jupyter-execute::
 
     # The end condition is when the "loss" is less than 0.1. In the context of the
     # 1D learner this means that we will resolve features in 'func' with width 0.1 or wider.
     runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     await runner.task  # This is not needed in a notebook environment!
@@ -76,23 +75,23 @@ When instantiated in a Jupyter notebook the runner does its job in the
 background and does not block the IPython kernel. We can use this to
 create a plot that updates as new data arrives:
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_info()
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_plot(update_interval=0.1)
 
 We can now compare the adaptive sampling to a homogeneous sampling with
 the same number of points:
 
-.. execute::
+.. jupyter-execute::
 
     if not runner.task.done():
         raise RuntimeError('Wait for the runner to finish before executing the cells below!')
 
-.. execute::
+.. jupyter-execute::
 
     learner2 = adaptive.Learner1D(f, bounds=learner.bounds)
 
@@ -107,7 +106,7 @@ vector output: ``f:ℝ → ℝ^N``
 
 Sometimes you may want to learn a function with vector output:
 
-.. execute::
+.. jupyter-execute::
 
     random.seed(0)
     offsets = [random.uniform(-0.8, 0.8) for _ in range(3)]
@@ -121,20 +120,20 @@ Sometimes you may want to learn a function with vector output:
 ``adaptive`` has you covered! The ``Learner1D`` can be used for such
 functions:
 
-.. execute::
+.. jupyter-execute::
 
     learner = adaptive.Learner1D(f_levels, bounds=(-1, 1))
     runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)
 
-.. execute::
+.. jupyter-execute::
     :hide-code:
 
     await runner.task  # This is not needed in a notebook environment!
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_info()
 
-.. execute::
+.. jupyter-execute::
 
     runner.live_plot(update_interval=0.1)