More fixes

Author: basnijholt

adaptive/types.py

@@ -8,7 +8,7 @@
 else:
     from typing_extensions import TypeAlias
 
-Float: TypeAlias = Union[float, np.float_]
+Float: TypeAlias = Union[float, np.float64]
 Bool: TypeAlias = Union[bool, np.bool_]
 Int: TypeAlias = Union[int, np.int_]
 Real: TypeAlias = Union[Float, Int]

docs/source/algorithms_and_examples.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
@@ -217,7 +217,10 @@ scatter = fig.data[0]
 coords_col = [
     (x, y, z, color)
     for x, y, z, color in zip(
-        scatter["x"], scatter["y"], scatter["z"], scatter.marker["color"]
+        scatter["x"],
+        scatter["y"],
+        scatter["z"],
+        scatter.marker["color"],
     )
     if not (x > 0 and y > 0)
 ]

docs/source/benchmarks.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: adaptive
   language: python
@@ -138,7 +138,7 @@ def run_and_plot(learner, **goal):
     bms[learner.function.__name__] = bm
     display(pd.DataFrame([bm]))  # noqa: F821
     return plot(learner, homo_learner).relabel(
-        f"{learner.function.__name__} function with {learner.npoints} points"
+        f"{learner.function.__name__} function with {learner.npoints} points",
     )
 
 
@@ -207,7 +207,7 @@ Nonetheless, the algorithm still focuses on areas of the function that have more
 ```{code-cell} ipython3
 def gaussian(x, mu=0, sigma=0.5):
     return (1 / np.sqrt(2 * np.pi * sigma**2)) * np.exp(
-        -((x - mu) ** 2) / (2 * sigma**2)
+        -((x - mu) ** 2) / (2 * sigma**2),
     )
 
 
@@ -359,7 +359,7 @@ def gaussian_surface(xy, mu=(0, 0), sigma=(1, 1)):
     mu_x, mu_y = mu
     sigma_x, sigma_y = sigma
     return (1 / (2 * np.pi * sigma_x * sigma_y)) * np.exp(
-        -((x - mu_x) ** 2 / (2 * sigma_x**2) + (y - mu_y) ** 2 / (2 * sigma_y**2))
+        -((x - mu_x) ** 2 / (2 * sigma_x**2) + (y - mu_y) ** 2 / (2 * sigma_y**2)),
     )
 
 
@@ -380,7 +380,8 @@ def sinusoidal_surface(xy, amplitude=1, frequency=(0.3, 3)):
 
 
 learner = adaptive.Learner2D(
-    sinusoidal_surface, bounds=[(-2 * np.pi, 2 * np.pi), (-2 * np.pi, 2 * np.pi)]
+    sinusoidal_surface,
+    bounds=[(-2 * np.pi, 2 * np.pi), (-2 * np.pi, 2 * np.pi)],
 )
 run_and_plot(learner, loss_goal=0.01)
 ```

docs/source/logo.md

@@ -4,13 +4,11 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: Python 3 (ipykernel)
   language: python
   name: python3
-execution:
-  timeout: 300
 ---
 
 ```{code-cell} ipython3
@@ -197,7 +195,7 @@ def save_webm(fname, fnames):
         "-y",
         fname,
     ]
-    return subprocess.run(args, capture_output=True)
+    return subprocess.run(args, capture_output=True, check=False)
 
 
 if __name__ == "__main__":

docs/source/tutorial/tutorial.BalancingLearner.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
@@ -88,7 +88,10 @@ combos = {
 }
 
 learner = adaptive.BalancingLearner.from_product(
-    jacobi, adaptive.Learner1D, {"bounds": (0, 1)}, combos
+    jacobi,
+    adaptive.Learner1D,
+    {"bounds": (0, 1)},
+    combos,
 )
 
 runner = adaptive.BlockingRunner(learner, loss_goal=0.01)

docs/source/tutorial/tutorial.IntegratorLearner.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.7
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
@@ -80,13 +80,13 @@ runner is done.
 ```{code-cell} ipython3
 if not runner.task.done():
     raise RuntimeError(
-        "Wait for the runner to finish before executing the cells below!"
+        "Wait for the runner to finish before executing the cells below!",
     )
 ```
 
 ```{code-cell} ipython3
 print(
-    f"The integral value is {learner.igral} with the corresponding error of {learner.err}"
+    f"The integral value is {learner.igral} with the corresponding error of {learner.err}",
 )
 learner.plot()
 ```

docs/source/tutorial/tutorial.Learner1D.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
@@ -92,7 +92,7 @@ We can now compare the adaptive sampling to a homogeneous sampling with the same
 ```{code-cell} ipython3
 if not runner.task.done():
     raise RuntimeError(
-        "Wait for the runner to finish before executing the cells below!"
+        "Wait for the runner to finish before executing the cells below!",
     )
 ```
 
@@ -119,7 +119,7 @@ offsets = [random.uniform(-0.8, 0.8) for _ in range(3)]
 def f_levels(x, offsets=offsets):
     a = 0.01
     return np.array(
-        [offset + x + a**2 / (a**2 + (x - offset) ** 2) for offset in offsets]
+        [offset + x + a**2 / (a**2 + (x - offset) ** 2) for offset in offsets],
     )
 ```
 
@@ -129,7 +129,8 @@ The `Learner1D` can be used for such functions:
 ```{code-cell} ipython3
 learner = adaptive.Learner1D(f_levels, bounds=(-1, 1))
 runner = adaptive.Runner(
-    learner, loss_goal=0.01
+    learner,
+    loss_goal=0.01,
 )  # continue until `learner.loss()<=0.01`
 ```
 

docs/source/tutorial/tutorial.LearnerND.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
@@ -88,7 +88,9 @@ def plot_cut(x1, x2, directions, learner=learner):
 
 dm = hv.DynamicMap(plot_cut, kdims=["v1", "v2", "directions"])
 dm = dm.redim.values(
-    v1=np.linspace(-1, 1, 6), v2=np.linspace(-1, 1, 6), directions=["xy", "xz", "yz"]
+    v1=np.linspace(-1, 1, 6),
+    v2=np.linspace(-1, 1, 6),
+    directions=["xy", "xz", "yz"],
 )
 
 # In a notebook one would run `dm` however we want a statically generated

docs/source/tutorial/tutorial.advanced-topics.md

@@ -4,11 +4,12 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
 ---
+
 (TutorialAdvancedTopics)=
 # Advanced Topics
 
@@ -92,7 +93,8 @@ def slow_f(x):
 learner = adaptive.Learner1D(slow_f, bounds=[0, 1])
 runner = adaptive.Runner(learner, npoints_goal=100)
 runner.start_periodic_saving(
-    save_kwargs={"fname": "data/periodic_example.p"}, interval=6
+    save_kwargs={"fname": "data/periodic_example.p"},
+    interval=6,
 )
 ```
 
@@ -241,7 +243,7 @@ def will_raise(x):
 
 learner = adaptive.Learner1D(will_raise, (-1, 1))
 runner = adaptive.Runner(
-    learner
+    learner,
 )  # without 'goal' the runner will run forever unless cancelled
 ```
 
@@ -365,6 +367,7 @@ await runner.task  # This is not needed in a notebook environment!
 # The result will only be set when the runner is done.
 timer.result()
 ```
+
 (CustomParallelization)=
 ## Custom parallelization using coroutines
 
@@ -378,8 +381,7 @@ We will focus on a function `f(x)` that consists of two distinct components: a s
 
 ```{code-cell} ipython3
 def f(x):  # example function without caching
-    """
-    Integer part of `x` repeats and should be reused
+    """Integer part of `x` repeats and should be reused
     Decimal part requires a new computation
     """
     return g(int(x)) + h(x % 1)

docs/source/tutorial/tutorial.custom_loss.md

@@ -4,7 +4,7 @@ jupytext:
     extension: .md
     format_name: myst
     format_version: 0.13
-    jupytext_version: 1.14.5
+    jupytext_version: 1.16.1
 kernelspec:
   display_name: python3
   name: python3
@@ -72,7 +72,9 @@ def f_divergent_1d(x):
 
 
 learner = adaptive.Learner1D(
-    f_divergent_1d, (-1, 1), loss_per_interval=uniform_sampling_1d
+    f_divergent_1d,
+    (-1, 1),
+    loss_per_interval=uniform_sampling_1d,
 )
 runner = adaptive.BlockingRunner(learner, loss_goal=0.01)
 learner.plot().select(y=(0, 10000))
@@ -92,12 +94,15 @@ def f_divergent_2d(xy):
 
 
 learner = adaptive.Learner2D(
-    f_divergent_2d, [(-1, 1), (-1, 1)], loss_per_triangle=uniform_sampling_2d
+    f_divergent_2d,
+    [(-1, 1), (-1, 1)],
+    loss_per_triangle=uniform_sampling_2d,
 )
 
 # this takes a while, so use the async Runner so we know *something* is happening
 runner = adaptive.Runner(
-    learner, goal=lambda lrn: lrn.loss() < 0.03 or lrn.npoints > 1000
+    learner,
+    goal=lambda lrn: lrn.loss() < 0.03 or lrn.npoints > 1000,
 )
 ```
 
@@ -134,7 +139,8 @@ After all subdomains are appropriately small it will prioritise places where the
 ```{code-cell} ipython3
 def resolution_loss_function(min_distance=0, max_distance=1):
     """min_distance and max_distance should be in between 0 and 1
-    because the total area is normalized to 1."""
+    because the total area is normalized to 1.
+    """
 
     def resolution_loss(ip):
         from adaptive.learner.learner2D import areas, default_loss
@@ -143,10 +149,10 @@ def resolution_loss_function(min_distance=0, max_distance=1):
 
         A = areas(ip)
         # Setting areas with a small area to zero such that they won't be chosen again
-        loss[A < min_distance**2] = 0
+        loss[min_distance**2 > A] = 0
 
         # Setting triangles that have a size larger than max_distance to infinite loss
-        loss[A > max_distance**2] = np.inf
+        loss[max_distance**2 < A] = np.inf
 
         return loss
 
@@ -158,7 +164,8 @@ loss = resolution_loss_function(min_distance=0.01)
 learner = adaptive.Learner2D(f_divergent_2d, [(-1, 1), (-1, 1)], loss_per_triangle=loss)
 runner = adaptive.BlockingRunner(learner, loss_goal=0.02)
 learner.plot(tri_alpha=0.3).relabel("1 / (x^2 + y^2) in log scale").opts(
-    hv.opts.EdgePaths(color="w"), hv.opts.Image(logz=True, colorbar=True)
+    hv.opts.EdgePaths(color="w"),
+    hv.opts.Image(logz=True, colorbar=True),
 )
 ```
 

example-notebook.ipynb

@@ -490,7 +490,7 @@
     "\n",
     "print(\n",
     "    f\"The integral value is {learner.igral} \"\n",
-    "    f\"with a corresponding error of {learner.err}\"\n",
+    "    f\"with a corresponding error of {learner.err}\",\n",
     ")\n",
     "learner.plot()"
    ]
@@ -683,7 +683,9 @@
     "\n",
     "\n",
     "learner = adaptive.Learner1D(\n",
-    "    f_divergent_1d, (-1, 1), loss_per_interval=uniform_sampling_1d\n",
+    "    f_divergent_1d,\n",
+    "    (-1, 1),\n",
+    "    loss_per_interval=uniform_sampling_1d,\n",
     ")\n",
     "runner = adaptive.BlockingRunner(learner, loss_goal=0.01)\n",
     "learner.plot().select(y=(0, 10000))"
@@ -755,8 +757,8 @@
    "source": [
     "def resolution_loss(ip, min_distance=0, max_distance=1):\n",
     "    \"\"\"min_distance and max_distance should be in between 0 and 1\n",
-    "    because the total area is normalized to 1.\"\"\"\n",
-    "\n",
+    "    because the total area is normalized to 1.\n",
+    "    \"\"\"\n",
     "    from adaptive.learner.learner2D import areas, deviations\n",
     "\n",
     "    A = areas(ip)\n",
@@ -773,10 +775,10 @@
     "    loss = np.sqrt(A) * dev + A\n",
     "\n",
     "    # Setting areas with a small area to zero such that they won't be chosen again\n",
-    "    loss[A < min_distance**2] = 0\n",
+    "    loss[min_distance**2 > A] = 0\n",
     "\n",
     "    # Setting triangles that have a size larger than max_distance to infinite loss\n",
-    "    loss[A > max_distance**2] = np.inf\n",
+    "    loss[max_distance**2 < A] = np.inf\n",
     "\n",
     "    return loss\n",
     "\n",
@@ -874,7 +876,10 @@
     "}\n",
     "\n",
     "learner = adaptive.BalancingLearner.from_product(\n",
-    "    jacobi, adaptive.Learner1D, {\"bounds\": (0, 1)}, combos\n",
+    "    jacobi,\n",
+    "    adaptive.Learner1D,\n",
+    "    {\"bounds\": (0, 1)},\n",
+    "    combos,\n",
     ")\n",
     "\n",
     "runner = adaptive.BlockingRunner(learner, loss_goal=0.01)\n",
@@ -1249,7 +1254,8 @@
     "runner = adaptive.Runner(learner, npoints_goal=100)\n",
     "\n",
     "runner.start_periodic_saving(\n",
-    "    save_kwargs={\"fname\": \"data/periodic_example.p\"}, interval=6\n",
+    "    save_kwargs={\"fname\": \"data/periodic_example.p\"},\n",
+    "    interval=6,\n",
     ")\n",
     "\n",
     "runner.live_info()"
@@ -1487,7 +1493,7 @@
     "\n",
     "learner = adaptive.Learner1D(will_raise, (-1, 1))\n",
     "runner = adaptive.Runner(\n",
-    "    learner\n",
+    "    learner,\n",
     ")  # without 'goal' the runner will run forever unless cancelled\n",
     "runner.live_info()\n",
     "runner.live_plot()"