@@ -14,7 +14,7 @@ Tutorial `~adaptive.IntegratorLearner`

     :hide-code:

     import adaptive

-    adaptive.notebook_extension(_inline_js=False)

+    adaptive.notebook_extension()

     import holoviews as hv

     import numpy as np

@@ -10,8 +10,6 @@ Tutorial `~adaptive.IntegratorLearner`

     The complete source code of this tutorial can be found in

     :jupyter-download:notebook:`tutorial.IntegratorLearner`

-.. thebe-button:: Run the code live inside the documentation!

-

 .. jupyter-execute::

     :hide-code:

@@ -10,6 +10,8 @@ Tutorial `~adaptive.IntegratorLearner`

     The complete source code of this tutorial can be found in

     :jupyter-download:notebook:`tutorial.IntegratorLearner`

+.. thebe-button:: Run the code live inside the documentation!

+

 .. jupyter-execute::

     :hide-code:

@@ -14,7 +14,7 @@ Tutorial `~adaptive.IntegratorLearner`

     :hide-code:

     import adaptive

-    adaptive.notebook_extension()

+    adaptive.notebook_extension(_inline_js=False)

     import holoviews as hv

     import numpy as np

@@ -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()

new file mode 100644

@@ -0,0 +1,84 @@

+Tutorial `~adaptive.IntegratorLearner`

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

+

+.. note::

+   Because this documentation consists of static html, the ``live_plot``

+   and ``live_info`` widget is not live. Download the notebook

+   in order to see the real behaviour.

+

+.. seealso::

+    The complete source code of this tutorial can be found in

+    :jupyter-download:notebook:`IntegratorLearner`

+

+.. execute::

+    :hide-code:

+    :new-notebook: IntegratorLearner

+

+    import adaptive

+    adaptive.notebook_extension()

+

+    import holoviews as hv

+    import numpy as np

+

+This learner learns a 1D function and calculates the integral and error

+of the integral with it. It is based on Pedro Gonnet’s

+`implementation <https://www.academia.edu/1976055/Adaptive_quadrature_re-revisited>`__.

+

+Let’s try the following function with cusps (that is difficult to

+integrate):

+

+.. execute::

+

+    def f24(x):

+        return np.floor(np.exp(x))

+

+    xs = np.linspace(0, 3, 200)

+    hv.Scatter((xs, [f24(x) for x in xs]))

+

+Just to prove that this really is a difficult to integrate function,

+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::

+

+    import scipy.integrate

+    scipy.integrate.quad(f24, 0, 3)

+

+We initialize a learner again and pass the bounds and relative tolerance

+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::

+

+    from adaptive.runner import SequentialExecutor

+

+    learner = adaptive.IntegratorLearner(f24, bounds=(0, 3), tol=1e-8)

+

+    # We use a SequentialExecutor, which runs the function to be learned in

+    # *this* process only. This means we don't pay

+    # the overhead of evaluating the function in another process.

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

+

+.. execute::

+    :hide-code:

+

+    await runner.task  # This is not needed in a notebook environment!

+

+.. execute::

+

+    runner.live_info()

+

+Now we could do the live plotting again, but lets just wait untill the

+runner is done.

+

+.. execute::

+

+    if not runner.task.done():

+        raise RuntimeError('Wait for the runner to finish before executing the cells below!')

+

+.. execute::

+

+    print('The integral value is {} with the corresponding error of {}'.format(learner.igral, learner.err))

+    learner.plot()