adding exercises

Author: Cheukting

01 - Go fast with Numba.ipynb

@@ -80,7 +80,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As you can see, the time that run the function with compliation for the 1st time is much slower than runing it without the complilation. However, after compliation, it is way faster. \n",
+    "As you can see, the time that run the function with compliation for the 1st time is much slower than runing it without the complilation. However, after compliation, it is way faster.\n",
+    "\n",
+    "**Question: Why it is slower the 1st time?**\n",
     "\n",
     "So we always have a trade off. If the function is only used a couple of times, it may as will be better without the compliation."
    ]
@@ -242,7 +244,45 @@
    "source": [
     "As you see now, the different between the vetor operation and the elementwise looping operation is almost none. In other words, the `@njit` speed up the operation almost 10 folds.\n",
     "\n",
-    "There are still improvement of the vector operations but it is not as much as the elementwise looping."
+    "There are still improvement of the vector operations but it is not as much as the elementwise looping.\n",
+    "\n",
+    "**Exercise: Can you change the following into elementwise operation?**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def julia_fast(mesh, c=-1, num_iter=10, radius=2):\n",
+    "\n",
+    "    z = mesh.copy()\n",
+    "    diverge_len = np.zeros(z.shape)\n",
+    "\n",
+    "    for i in range(num_iter):\n",
+    "        conv_mask = np.abs(z) < radius\n",
+    "        z[conv_mask] = np.square(z[conv_mask]) + c\n",
+    "        diverge_len[conv_mask] += 1\n",
+    "\n",
+    "    return diverge_len"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Un-commend the line below to see how we do it.\n",
+    "#%load element_op.py"
    ]
   },
   {
@@ -314,7 +354,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As you see, the fast math version is takes almost only half the time. (Is it?)"
+    "As you see, the fast math version is takes almost only half the time."
    ]
   },
   {
@@ -359,7 +399,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Depending on how many cores your have on your computer, you will see carious degrees of improvement. On my 3.1 GHz Dual-Core Intel Core i7 early 2015 MacBook Pro, it is slightly faster than the one using njit and almost 7 times faster than without compilation."
+    "Depending on how many cores your have on your computer, you will see carious degrees of improvement. On my 3.1 GHz Dual-Core Intel Core i7 early 2015 MacBook Pro, it is slightly faster than the one using njit and almost 7 times faster than without compilation. On my new 8 Core M2 2022 Macbook air, it is 10 times faster. \n",
+    "\n",
+    "**Question: What about yours?**"
    ]
   },
   {

02 - What can go wrong and how to fix it.ipynb

@@ -5,7 +5,9 @@
    "metadata": {},
    "source": [
     "## Python object vs nopython mode\n",
-    "A lof of times, we will run into compilation problem that we will never exepriecne with Numba. It is because, in pure Python we do not complie any code. Here is an example of how we can run into a compilation error when using nopython mode"
+    "A lof of times, we will run into compilation problem that we will never exepriecne with Numba. It is because, in pure Python we do not complie any code. Here is an example of how we can run into a compilation error when using nopython mode\n",
+    "\n",
+    "First consider the code below:"
    ]
   },
   {
@@ -14,11 +16,80 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from numba import njit\n",
-    "\n",
-    "@njit #remember that njit is the short hand for @jit(nopython=True)\n",
     "def adding_numbers(x, y):\n",
-    "    return int(x) + int(y)"
+    "    return x + y"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is a simple function adding two numbers so"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adding_numbers(1,2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "would gives you 3, let's try change the first input into a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adding_numbers(\"1\",2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Would have an error as we are trying to add a string to an integer.\n",
+    "\n",
+    "**Exercise: change the code in \"adding_numbers\" to \"fix\" the above**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise: use `njit` on the \"fixed\" function**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Un-commend the line below to see how we do it.\n",
+    "#%load adding_numbers.py"
    ]
   },
   {
@@ -59,19 +130,26 @@
    "source": [
     "We see a compilation error that we would never see when using pure Python. This is an error that came from Numba. From the Traceback we see there is an error message that mension TypingError and it's something to do with the nopython mode pipeline.\n",
     "\n",
-    "So let's try to make Python object avaliable."
+    "So let's try to make Python object avaliable.\n",
+    "\n",
+    "**Exercise: rename \"adding_numbers\" to \"adding_numbers_again\" and use `jit` on it**"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from numba import jit\n",
-    "@jit\n",
-    "def adding_numbers_again(x, y):\n",
-    "    return int(x) + int(y)"
+    "# Un-commend the line below to see how we do it.\n",
+    "#%load adding_numbers_again.py"
    ]
   },
   {
@@ -94,7 +172,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we see that the g function does compiled, we ony get a warning from Numba, which says we are now using object mode. (so it will be slower than expected, see **Extra Task** below)\n",
+    "Now we see that the function does compiled, we ony get a warning from Numba, which says we are now using object mode. (so it will be slower than expected, see **Extra Task** below)\n",
     "\n",
     "Now it is your turn to try.\n",
     "\n",
@@ -130,7 +208,7 @@
    "source": [
     "It is quite fustriting as we cannot compile this function, it is due to Numba not able to  determine the return type of a function for compilation. Maybe the Python interpreter can help?\n",
     "\n",
-    "**TODO: use the proper decorator for the function below**"
+    "**Exercise: use the proper decorator for the function below**"
    ]
   },
   {
@@ -250,7 +328,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now, can you figure it out a way to return an empty list using `njit`? We have to somehow state the type of the items in the list without putting any items in the list..."
+    "Now, can you figure it out a way to return an empty list using `njit`? We have to somehow state the type of the items in the list without putting any items in the list...\n",
+    "\n",
+    "**Exercise: try to \"fix\" the above**"
    ]
   },
   {

adding_numbers.py

@@ -0,0 +1,5 @@
+from numba import njit
+
+@njit #remember that njit is the short hand for @jit(nopython=True)
+def adding_numbers(x, y):
+    return int(x) + int(y)

adding_numbers_again.py

@@ -0,0 +1,4 @@
+from numba import jit
+@jit
+def adding_numbers_again(x, y):
+    return int(x) + int(y)

element_op.py

@@ -0,0 +1,20 @@
+@jit(nopython=True, nogil=True)
+def element_op(z, div_len, c, radius):
+    for x in range(z.shape[0]):
+        for y in range(z.shape[1]):
+            if np.abs(z[x][y]) < radius:
+                z[x][y] = np.square(z[x][y]) + c
+                div_len[x][y] +=1
+    return z, div_len
+            
+
+@jit(nopython=True,nogil=True)
+def julia_fast(mesh, c=-1, num_iter=10, radius=2):
+
+    z = mesh.copy()
+    diverge_len = np.zeros(z.shape)
+
+    for i in range(num_iter):
+        z, diverge_len = element_op(z, diverge_len, c,radius)
+
+    return diverge_len