se different YAML meta data format

Author: basnijholt

README.md

@@ -91,9 +91,8 @@ runner.live_info()
 runner.live_plot()
 ```
 
-```{raw} html
 <img src="https://user-images.githubusercontent.com/6897215/38739170-6ac7c014-3f34-11e8-9e8f-93b3a3a3d61b.gif" width='20%'> </img> <img src="https://user-images.githubusercontent.com/6897215/35219611-ac8b2122-ff73-11e7-9332-adffab64a8ce.gif" width='40%'> </img> <img src="https://user-images.githubusercontent.com/6897215/47256441-d6d53700-d480-11e8-8224-d1cc49dbdcf5.gif" width='20%'> </img>
-```
+
 
 % not-in-documentation-end
 

docs/source/algorithms_and_examples.md

@@ -42,10 +42,8 @@ In addition to the learners, `adaptive` also provides primitives for running the
 Here are some examples of how Adaptive samples vs. homogeneous sampling.
 Click on the *Play* {fa}`play` button or move the sliders.
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 import itertools
 import adaptive
@@ -83,10 +81,8 @@ runner.live_info()  # shows a widget with status information
 runner.live_plot()
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 
 def f(x, offset=0.07357338543088588):
@@ -124,10 +120,8 @@ layout.opts(plot=dict(toolbar=None))
 
 ## {class}`adaptive.Learner2D`
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 
 def ring(xy):
@@ -159,10 +153,8 @@ hv.HoloMap(plots, kdims=["npoints"]).collate()
 
 ## {class}`adaptive.AverageLearner`
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 
 def g(n):
@@ -187,10 +179,8 @@ hv.HoloMap(plots, kdims=["npoints"])
 
 ## {class}`adaptive.LearnerND`
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 
 def sphere(xyz):

docs/source/conf.py

@@ -74,6 +74,7 @@
 # myst-nb configuration
 nb_execution_mode = "cache"
 nb_execution_timeout = 180
+execution_fail_on_error = True
 
 
 def setup(app):

docs/source/logo.md

@@ -10,7 +10,7 @@ jupytext:
     jupytext_version: 1.13.8
 ---
 
-```{code-cell}
+```{code-cell} ipython3
 ---
 tags: [remove-input]
 ---

docs/source/tutorial/tutorial.AverageLearner.md

@@ -16,10 +16,8 @@ Because this documentation consists of static html, the `live_plot` and `live_in
 Download the notebook in order to see the real behaviour. [^download]
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 import adaptive
 
@@ -31,7 +29,7 @@ The next type of learner averages a function until the uncertainty in the averag
 This is useful for sampling a random variable.
 The function passed to 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).
 
-```{code-cell}
+```{code-cell} ipython3
 def g(n):
     import random
     from time import sleep
@@ -45,25 +43,23 @@ def g(n):
     return val
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 learner = adaptive.AverageLearner(g, atol=None, rtol=0.01)
 # `loss < 1` means that we reached the `rtol` or `atol`
 runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 1)
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 await runner.task  # This is not needed in a notebook environment!
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_info()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_plot(update_interval=0.1)
 ```
 

docs/source/tutorial/tutorial.AverageLearner1D.md

@@ -16,10 +16,8 @@ Because this documentation consists of static html, the `live_plot` and `live_in
 Download the notebook in order to see the real behaviour. [^download]
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 import adaptive
 
@@ -34,7 +32,7 @@ from functools import partial
 
 First, we define the (noisy) function to be sampled. Note that the parameter `sigma` corresponds to the standard deviation of the Gaussian noise.
 
-```{code-cell}
+```{code-cell} ipython3
 def noisy_peak(seed_x, sigma=0, peak_width=0.05, offset=-0.5):
     seed, x = seed_x  # tuple with seed and `x` value
     y = x**3 - x + 3 * peak_width**2 / (peak_width**2 + (x - offset) ** 2)
@@ -45,15 +43,15 @@ def noisy_peak(seed_x, sigma=0, peak_width=0.05, offset=-0.5):
 
 This is how the function looks in the absence of noise:
 
-```{code-cell}
+```{code-cell} ipython3
 xs = np.linspace(-2, 2, 500)
 ys = [noisy_peak((seed, x), sigma=0) for seed, x in enumerate(xs)]
 hv.Path((xs, ys))
 ```
 
 And an example of a single realization of the noisy function:
 
-```{code-cell}
+```{code-cell} ipython3
 ys = [noisy_peak((seed, x), sigma=1) for seed, x in enumerate(xs)]
 hv.Path((xs, ys))
 ```
@@ -63,14 +61,14 @@ The learner will autonomously determine whether the next samples should be taken
 
 We start by initializing a 1D average learner:
 
-```{code-cell}
+```{code-cell} ipython3
 learner = adaptive.AverageLearner1D(partial(noisy_peak, sigma=1), bounds=(-2, 2))
 ```
 
 As with other types of learners, we need to initialize a runner with a certain goal to run our learner.
 In this case, we set 10000 samples as the goal (the second condition ensures that we have at least 20 samples at each point):
 
-```{code-cell}
+```{code-cell} ipython3
 def goal(nsamples):
     def _goal(learner):
         return learner.nsamples >= nsamples and learner.min_samples_per_point >= 20
@@ -81,15 +79,13 @@ def goal(nsamples):
 runner = adaptive.Runner(learner, goal=goal(10_000))
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 await runner.task  # This is not needed in a notebook environment!
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_info()
 runner.live_plot(update_interval=0.1)
 ```
@@ -110,43 +106,39 @@ The most relevant are:
 As an example, assume that we wanted to resample the points from the previous learner.
 We can decrease `delta` to 0.1 and set `min_error` to 0.05 if we do not require accuracy beyond this value:
 
-```{code-cell}
+```{code-cell} ipython3
 learner.delta = 0.1
 learner.min_error = 0.05
 runner = adaptive.Runner(learner, goal=goal(20_000))
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 await runner.task  # This is not needed in a notebook environment!
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_info()
 runner.live_plot(update_interval=0.1)
 ```
 
 On the contrary, if we want to push forward the "exploration", we can set a larger `delta` and limit the maximum number of samples taken at each point:
 
-```{code-cell}
+```{code-cell} ipython3
 learner.delta = 0.3
 learner.max_samples = 1000
 
 runner = adaptive.Runner(learner, goal=goal(25_000))
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 await runner.task  # This is not needed in a notebook environment!
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_info()
 runner.live_plot(update_interval=0.1)
 ```

docs/source/tutorial/tutorial.BalancingLearner.md

@@ -16,10 +16,8 @@ Because this documentation consists of static html, the `live_plot` and `live_in
 Download the notebook in order to see the real behaviour. [^download]
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 import adaptive
 
@@ -36,7 +34,7 @@ When you request a point from the balancing learner, it will query all of its 
 
 The balancing learner can for example be used to implement a poor-man’s 2D learner by using the {class}`~adaptive.Learner1D`.
 
-```{code-cell}
+```{code-cell} ipython3
 def h(x, offset=0):
     a = 0.01
     return x + a**2 / (a**2 + (x - offset) ** 2)
@@ -51,19 +49,17 @@ bal_learner = adaptive.BalancingLearner(learners)
 runner = adaptive.Runner(bal_learner, goal=lambda l: l.loss() < 0.01)
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 await runner.task  # This is not needed in a notebook environment!
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_info()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 plotter = lambda learner: hv.Overlay([L.plot() for L in learner.learners])
 runner.live_plot(plotter=plotter, update_interval=0.1)
 ```
@@ -72,7 +68,7 @@ Often one wants to create a set of `learner`s for a cartesian product of paramet
 For that particular case we’ve added a `classmethod` called {class}`~adaptive.BalancingLearner.from_product`.
 See how it works below
 
-```{code-cell}
+```{code-cell} ipython3
 from scipy.special import eval_jacobi
 
 

docs/source/tutorial/tutorial.DataSaver.md

@@ -16,10 +16,8 @@ Because this documentation consists of static html, the `live_plot` and `live_in
 Download the notebook in order to see the real behaviour. [^download]
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 import adaptive
 
@@ -30,7 +28,7 @@ If the function that you want to learn returns a value along with some metadata,
 
 In the following example the function to be learned returns its result and the execution time in a dictionary:
 
-```{code-cell}
+```{code-cell} ipython3
 from operator import itemgetter
 
 
@@ -56,29 +54,27 @@ learner = adaptive.DataSaver(_learner, arg_picker=itemgetter("y"))
 
 `learner.learner` is the original learner, so `learner.learner.loss()` will call the correct loss method.
 
-```{code-cell}
+```{code-cell} ipython3
 runner = adaptive.Runner(learner, goal=lambda l: l.learner.loss() < 0.1)
 ```
 
-```{code-cell}
----
-tags: [hide-cell]
----
+```{code-cell} ipython3
+:tags: [hide-cell]
 
 await runner.task  # This is not needed in a notebook environment!
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 runner.live_info()
 ```
 
-```{code-cell}
+```{code-cell} ipython3
 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.
 
-```{code-cell}
+```{code-cell} ipython3
 learner.extra_data
 ```