@@ -445,11 +445,11 @@ class LearnerND(BaseLearner):

                 # n = int(0.658 / sqrt(volumes(ip).min()))  # TODO fix this calculation

                 n = 50

-            xs = ys = np.linspace(-0.5, 0.5, n)

+            xs = ys = np.linspace(0, 1, n)

             xs = xs[:, None]

             ys = ys[None, :]

             i = values.index(None)

-            j = values.index(None)

+            j = values.index(None, i+1)

             bx, by = self.bounds[i], self.bounds[j]

@@ -247,6 +247,94 @@

     " learner2.plot(n, tri_alpha=0.4) + learner.plot(tri_alpha=0.4)).cols(2)"

    ]

   },

+  {

+   "cell_type": "markdown",

+   "metadata": {},

+   "source": [

+    "# N-dimensional function learner\n",

+    "Appart from the 1d and 2d learner, we can also learn N-d functions:  $\\ f: ℝ^N → ℝ, N \\ge 2$\n",

+    "\n",

+    "Do keep in mind the speed of the learner drops quickly with increasing number of dimensions."

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "# this step takes a lot of time, it will finish at about 3300 points, which can take up to 6 minutes\n",

+    "\n",

+    "def sphere(xyz):\n",

+    "    x, y, z = xyz\n",

+    "    a = 0.4\n",

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

+    "\n",

+    "learner = adaptive.LearnerND(sphere, bounds=[(-1, 1), (-1, 1), (-1, 1)])\n",

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

+    "runner.live_info()"

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "learner.loss()"

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "# We plot 2d slices of the 3d method at different values for x\n",

+    "(learner.plot_slice((0.0, None, None), n=100).relabel(\"x=0\") + \n",

+    " learner.plot_slice((0.2, None, None), n=100).relabel(\"x=0.2\") +\n",

+    " learner.plot_slice((0.4, None, None), n=100).relabel(\"x=0.4\") + \n",

+    " learner.plot_slice((0.6, None, None), n=100).relabel(\"x=0.6\") + \n",

+    " learner.plot_slice((0.8, None, None), n=100).relabel(\"x=0.8\")\n",

+    ").cols(2)"

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "# We can also plot slices in a different direction\n",

+    "(learner.plot_slice((None, None, 0.0), n=100).relabel(\"z=0\") + \n",

+    " learner.plot_slice((None, None, 0.2), n=100).relabel(\"z=0.2\") +\n",

+    " learner.plot_slice((None, None, 0.4), n=100).relabel(\"z=0.4\") + \n",

+    " learner.plot_slice((None, None, 0.6), n=100).relabel(\"z=0.6\") + \n",

+    " learner.plot_slice((None, None, 0.8), n=100).relabel(\"z=0.8\")\n",

+    ").cols(2)"

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "# Or we can plot 1d slices\n",

+    "(learner.plot_slice((None, 0.0, 0.0), n=100).relabel(\"y=0 z=0\") + \n",

+    " learner.plot_slice((None, 0.0, 0.5), n=100).relabel(\"y=0 z=0.5\") +\n",

+    " learner.plot_slice((0.0, None, 0.0), n=100).relabel(\"x=0 z=0\") + \n",

+    " learner.plot_slice((0.0, 0.5, None), n=100).relabel(\"x=0.5 y=0\")\n",

+    ").cols(2)"

+   ]

+  },

+  {

+   "cell_type": "markdown",

+   "metadata": {},

+   "source": [

+    "The plots show some wobbles while the original function was smooth, this is a result of the fact that the learner chooses points in 3 dimensions and the simplices are not in the same face as we try to interpolate our lines. However, as always, when you sample more points the graph will become gradually smoother."

+   ]

+  },

   {

    "cell_type": "markdown",

    "metadata": {},