part-1/lecture-slides.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b1330b7e-9039-4d4b-99d3-5aa5943e2cd8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Part 1: Array-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd660f4-b7fe-4637-8a35-7ca03ee7e124",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "_(To be viewed with [jupyterlab-deck](https://jupyterlab-deck.readthedocs.io/).)_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03df504f-a94a-479e-b46d-4f1b7100ad85",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## What is \"array-oriented programming\"?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c14679bc-c15f-44fe-9b23-0267bfff03b2",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "It's a programming paradigm, alongside paradigms like \"imperative,\" \"object-oriented,\" and \"functional.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff59691a-dcc5-4b84-bdfb-b31a4a28cf3a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<br><br>\n",
    "\n",
    "**In array-oriented programming, the primary data type is an array, and most functions perform one operation on all the elements of the array.**\n",
    "\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39888cca-4edf-4acd-a669-28e2001e232d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cc727e5-381d-4d96-95a6-e1a3611a08a6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "For instance, this is _not_ array-oriented:\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f6fa88b-e119-480f-ba0e-61c4d0fd6f0d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "input_data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "output_data = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
    "\n",
    "for i in range(len(input_data)):             # explicitly specifies an order of execution\n",
    "    output_data[i] = input_data[i]**2        # user says what happens to each element\n",
    "\n",
    "output_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7694536-56dc-46be-93c0-e396d494567e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "And this is _not_ array-oriented:\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84994cc2-37fa-470c-85e4-062009ac9336",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "input_data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    "output_data = np.fromiter(\n",
    "    map(lambda x: x**2, input_data), int     # still focused on the individual element \"x\"\n",
    ")\n",
    "\n",
    "output_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab0c669e-2fa1-47f5-a52d-1680fc36f6b9",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "_This_ is array-oriented:\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7809e65d-5c32-47d9-98fa-03cf853b35ea",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "input_data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    "output_data = input_data**2                  # implicit indexes, no individual elements\n",
    "\n",
    "output_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b550f7da-1a90-482a-9d78-a2f53981ed71",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "As with all programming paradigms, there isn't a sharply defined rule to cleanly separate them, and a single codebase can use several paradigms.\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e7740a3-8aba-4a2b-80f0-24ac6009c18b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "They are _styles_, and they're useful because they each bring different programming concepts into the foreground:\n",
    "\n",
    "| Paradigm | Emphasizes |\n",
    "|:-:|:-:|\n",
    "| imperative/procedural | low-level algorithms |\n",
    "| object-oriented | large-scale program structure |\n",
    "| actor-based | temporal locality |\n",
    "| literate | human instruction |\n",
    "| event-driven | cause-and-effect |\n",
    "| declarative | properties of desired result |\n",
    "| symbolic | formula transformations |\n",
    "| functional | data transformations |\n",
    "| array-oriented | data distributions |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd6f1f9e-97f5-4745-8252-7b005d8b7cfb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## What is array-oriented programming good for?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "899bacbb-56e3-4cb5-b30d-bf0a30a6c0cc",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "All of the languages/major libraries that emphasize array-oriented programming (that I know of):\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eafc2bd-e26c-47a1-a881-a4ae27bedaab",
   "metadata": {
    "tags": []
   },
   "source": [
    "<img src=\"../img/apl-timeline.svg\" width=\"100%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf78544b-43de-4064-9042-aa4a617cf3a5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Almost all of them are intended as _interactive data-analysis_ environments.\n",
    "\n",
    "(Fortran-90 is the only one that is not interactive.)\n",
    "\n",
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aa5607a-0b01-4b64-a87f-df77d6436050",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Almost all feature:\n",
    "\n",
    "* interactive REPL (read-evaluate-print loop)\n",
    "* concise notation\n",
    "* unabashedly mathematical"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12bb9a58-eb1a-44d7-95cb-e13160d07a84",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Distributions and interactivity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c002e0d0-63a9-4f41-91f6-547268f558c0",
   "metadata": {
    "tags": []
   },
   "source": [
    "Array-oriented languages bring data _distributions_ to the foreground.\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58d9d659-8fa3-4dd4-be19-0ce97d405be8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from hist import Hist  # histogram library"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "522decc8-22ac-40b3-af5e-571afa672240",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<br>\n",
    "\n",
    "Given a large dataset..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bc01b0b-81ed-402e-b77d-f096518b7421",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dataset = np.random.normal(0, 1, 1000000)  # one MILLION data points"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ecbf8d6-cab8-456a-8b1a-4686c30929be",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<br>\n",
    "\n",
    "How are the data _distributed_?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97faa90f-d56d-41d2-9b20-7db69884a477",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "Hist.new.Reg(100, -5, 5).Double().fill(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95c4994b-ce5c-4eda-923f-e2c3f51f8c25",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "What happens if we apply a function to _all values in the distribution_?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0838ca5d-1870-4cbb-bd3a-254d57c885dc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dataset2 = dataset**2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68f55197-2f54-4d9b-a514-a27ee435acdc",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cdf355a-8cc0-4aa9-878e-3b1623e090e8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "Hist.new.Reg(100, -1, 10).Double().fill(dataset2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0ef0321-5fc0-4bca-98b7-763fe12afdbc",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Can anyone guess what this distribution will look like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17ea1227-ddc9-4188-a57a-92ef2139d8f9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dataset3 = np.sin(1/dataset2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "298888cc-c0cc-4f06-a981-74a2cf9463af",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "(I can't.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02f4ab09-a785-46b0-9339-72e3efe73858",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "Hist.new.Reg(100, -1, 1).Double().fill(dataset3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03dd5b3-9b3c-4f61-9f69-57a97cbd19ad",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Human readability advantage:**\n",
    "\n",
    "  * Mathematical expressions are concise, more convenient to type interactivity.\n",
    "\n",
    "<br>\n",
    "\n",
    "**Computational advantage:**\n",
    "\n",
    "  * The right _part_ of the computation is accelerated: the loop over all values in the distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b48a09e-502d-4733-b001-ac105613d141",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a9bdd55-4184-4622-aad4-4a01b4262d5f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "<img src=\"../img/Numpy_Python_Cheat_Sheet.svg\" width=\"100%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2d7e96a-e262-44ef-904a-746e3c31658b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "NumPy's version of adding arrays elementwise is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52e2ea06-7b5a-409d-8056-ecdec100ea0c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "np.array([10, 20, 30]) + np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55cd427e-7519-4a17-b0b3-9844ad30f0f9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<br><br>\n",
    "\n",
    "Since all scalar → scalar operators (and scalar → scalar functions in `np.*`) are promoted to elementwise operations on arrays, any [closed form](https://en.wikipedia.org/wiki/Closed-form_expression) expression duck-types between scalars and arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53e464dd-e2fe-425c-97c1-be9066e4cd9a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def quadratic_formula(a, b, c):\n",
    "    return (-b + np.sqrt(b**2 - 4*a*c)) / (2*a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b4e75d2-eec3-4b5c-9fda-bd5f711b5698",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Compute the quadratic formula on one set of scalar values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c0331ca-f238-4ad6-a6fe-5da430e71cfd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 10\n",
    "c = -0.1\n",
    "\n",
    "quadratic_formula(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39a121ab-18cf-44d7-b99c-858677b784f6",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "Compute the quadratic formula on a million values in arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90c325c5-4aad-49d7-86f3-8e39beae89a3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = np.random.uniform(5, 10, 1000000)\n",
    "b = np.random.uniform(10, 20, 1000000)\n",
    "c = np.random.uniform(-0.1, 0.1, 1000000)\n",
    "\n",
    "quadratic_formula(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f11f3cf3-baa0-4ecb-b34b-ebeef5647c9e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### A note about performance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c12751f-d6da-4c9e-a51a-48ae45dcc8af",
   "metadata": {
    "tags": []
   },
   "source": [
    "Although NumPy makes each step of the calculation fast, the whole expression is not optimized.\n",
    "\n",
    "The execution of `quadratic_formula` is _similar to_ this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07a44e1c-95f9-4a3f-8941-24510a6b488b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def pedantic_quadratic_formula(a, b, c):\n",
    "    tmp1 = np.negative(b)            # -b\n",
    "    tmp2 = np.square(b)              # b**2\n",
    "    tmp3 = np.multiply(4, a)         # 4*a\n",
    "    tmp4 = np.multiply(tmp3, c)      # tmp3*c\n",
    "    del tmp3\n",
    "    tmp5 = np.subtract(tmp2, tmp4)   # tmp2 - tmp4\n",
    "    del tmp2, tmp4\n",
    "    tmp6 = np.sqrt(tmp5)             # sqrt(tmp5)\n",
    "    del tmp5\n",
    "    tmp7 = np.add(tmp1, tmp6)        # tmp1 + tmp6\n",
    "    del tmp1, tmp6\n",
    "    tmp8 = np.multiply(2, a)         # 2*a\n",
    "    return np.divide(tmp7, tmp8)     # tmp7 / tmp8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d748f8c-d1b7-46f6-943a-8c56f3a9ce4f",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81232bc2-1664-4d46-83d0-cf9cde235532",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pedantic_quadratic_formula(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7fe7bca-4468-4691-852e-290d6ad1bf7e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Although it's faster than Python `for` loops..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82f837b8-9877-4888-bafd-e27be8438643",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "imperative = np.empty_like(c)\n",
    "for i, (ai, bi, ci) in enumerate(zip(a, b, c)):\n",
    "    imperative[i] = quadratic_formula(ai, bi, ci)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b8e6569-ce8e-4ff3-b0e1-816a1852c7c8",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6469e4c9-01e0-4dc3-8929-1c8934c62a0f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "quadratic_formula(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "448645db-de6e-4a0b-9f58-dea7719e0107",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b405446d-ff23-4430-a2d8-42df15877502",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "\n",
    "pedantic_quadratic_formula(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e97f498e-033c-4423-9810-33edf8275150",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "...it's not as fast as a single \"fused\" loop over the data.\n",
    "\n",
    "Other libraries fill this performance gap:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd9e66d3-10d1-4afe-9792-184a9ff282cc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numexpr as ne\n",
    "\n",
    "ne.evaluate(\"(-b + sqrt(b**2 - 4*a*c)) / (2*a)\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23fc2ee1-4a71-494a-a343-d24c36a43378",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42250db8-3083-4cd2-ab1f-caa7515a019c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numba as nb\n",
    "\n",
    "@nb.vectorize\n",
    "def numba_quadratic_formula(a, b, c):\n",
    "    return (-b + np.sqrt(b**2 - 4*a*c)) / (2*a)\n",
    "\n",
    "numba_quadratic_formula(a, b, c);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78fc4bee-821e-4c2b-be71-dacf292e918b",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbb2a972-1f12-4461-ba90-bac7a0631db6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import jax\n",
    "jax.config.update(\"jax_platform_name\", \"cpu\"); jax.config.update(\"jax_enable_x64\", True)\n",
    "\n",
    "@jax.jit\n",
    "def jax_quadratic_formula(a, b, c):\n",
    "    return (-b + jax.numpy.sqrt(b**2 - 4*a*c)) / (2*a)\n",
    "\n",
    "jax_quadratic_formula(a, b, c);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09904bab-a042-417d-a137-5c7cfbfaab3c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "quadratic_formula(a, b, c)         # NumPy (loop over data for each operation... mostly)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9fe1a8c-4f66-48c9-b08d-5655f8cb5612",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aadbaafe-0264-4852-b7a4-2d21b080cd44",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "ne.re_evaluate()                   # NumExpr (fast virtual machine)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320c2204-29c1-47dd-b20e-e2783726aea1",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e62af063-99e9-4fba-8228-c92690858e6e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "numba_quadratic_formula(a, b, c)   # Numba (compiles with LLVM)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6796f02-3e15-490d-860e-d105e3f44655",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fb76e60-dbed-47b7-9a5a-4c0c5e07adcc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "jax_quadratic_formula(a, b, c)     # JAX (compiles with XLA)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2405977e-8b8b-4458-b0f5-cbd6b75d9d27",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Compiling Python or binding compiled code to Python is an open field, without a clearly dominant solution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "109a53f7-85bd-4510-b68b-69d95eb06691",
   "metadata": {},
   "source": [
    "<img src=\"../img/history-of-bindings-2.svg\" width=\"100%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c55b4e8-41a7-42f6-b2f9-0378744dd0f9",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Expressibility in NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87e979bf-fb4f-4dfd-9b98-4f6c525a9fe4",
   "metadata": {},
   "source": [
    "The amazing thing is that we can express so much by piecing together precompiled routines.\n",
    "\n",
    "Combine\n",
    "\n",
    "  * elementwise operations (\"ufuncs\")\n",
    "  * broadcasting\n",
    "  * basic and advanced slicing\n",
    "  * slice-assignment\n",
    "  * reshaping\n",
    "  * reducers\n",
    "  * specialized functions\n",
    "\n",
    "to do great things!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "216f0888-acf8-4a15-ae09-ef7bee0df604",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Example:** Compute the size of the spaces between consecutive elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "336586b5-114d-4280-8f02-c8b333d2ddab",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "array = np.array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e836999-c085-47c4-892e-be379209b8b9",
   "metadata": {},
   "source": [
    "<br><br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6debb143-a089-463c-8ba1-fb5317855460",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "array[1:] - array[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebe58bc7-9263-4197-b951-e0683224bce0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "<center>\n",
    "<img src=\"../img/flat-operation.svg\" width=\"70%\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a05f3f9f-9b87-4967-9f53-7c9a1c6c88b0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "<center>\n",
    "<img src=\"../img/shifted-operation.svg\" width=\"70%\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd56969c-5465-4ce9-adda-38aeb100ca26",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Quizlet:** Compute the length of the curve sampled by arrays `x` and `y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d7638b1-7a77-4d02-a784-a6cb33be75d8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "t = np.linspace(0, 2*np.pi, 10000)\n",
    "x = np.sin(3*t)\n",
    "y = np.sin(4*t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0fc26bb-879e-42c6-a4d7-96b31758e975",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "<center>\n",
    "<img src=\"../img/length-by-segment.svg\" width=\"55%\">\n",
    "</center>\n",
    "\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd416dc4-acad-486d-ae17-54c2870ca9b8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a126187-a462-4920-a625-6e6479f36b56",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "plt.plot(x, y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c12affbb-811b-46b1-a7ce-e172655dfe68",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<!-- This will only work on the day of the live tutorial. -->\n",
    "<div style=\"overflow: hidden;\"><iframe src=\"https://app.sli.do/event/dFsiXggxZ3t2B9yhr5zmxZ\" width=\"100%\" height=\"280\" scrolling=\"no\" style=\"border: none;\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74a1c5d8-576d-4252-bfdf-60cbfefde52f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Answer:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "679d905c-788e-4d35-9cd2-b93245b3f8c5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "np.sum(np.sqrt((x[1:] - x[:-1])**2 + (y[1:] - y[:-1])**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dabf0a01-a9d8-4689-beb5-44074f4f3557",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Example:** Big-endian to little-endian conversion.\n",
    "\n",
    "(Note: `view` and `reshape` do not change the array data, only its interpretation.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d700f2c7-4a4d-4967-aad4-82b740829d4d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "big_endian = np.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype=\">f8\")\n",
    "wrong_endianness = big_endian.view(np.float64)\n",
    "wrong_endianness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20960951-abfd-41a1-be0d-6ca70995db7c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "raw_bytes = wrong_endianness.view(np.uint8)\n",
    "raw_bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee33fad0-629f-4ec2-b054-63928d928da2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped = raw_bytes.reshape(len(raw_bytes) // 8, 8)\n",
    "grouped"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f06aa8f4-9f66-4fde-9742-3d72aceaf684",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Note: `:` is a full slice (changing nothing) and `::-1` reverses a dimension (`step == -1`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f341d506-f47a-431c-ba4b-97e78b7b2c25",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "reversed_grouped = grouped[:, ::-1]\n",
    "reversed_grouped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec09ee6c-d574-41e1-9142-7ef8042cfb00",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "flattened = reversed_grouped.reshape(len(raw_bytes))\n",
    "flattened"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80c94020-e570-4c3b-a7e9-3bd243b6e226",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "flattened.view(wrong_endianness.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ef1f88-6002-4df9-a2b4-001958e1f35c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Quizlet:** Downsample this curve to make it less noisy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "646d9d6a-5af4-410a-bb1a-b597207cf98f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "noisy_data = np.sin(np.linspace(0, 2*np.pi, 1000)) + np.random.normal(0, 0.5, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c107bfcc-0db9-4426-bc22-e51de436bf7e",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "That is, replace every 10 consecutive array elements with their average value, reducing the number of array elements from 1000 to 100, but representing the same curve (ranging from ‒1 to 1)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebce6088-1c37-4327-aaaa-fb4ef9a02cc5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Note: this is how `axis` works for reducers.\n",
    "\n",
    "<center>\n",
    "<img src=\"../img/example-reducer-2d.svg\" width=\"40%\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "305b9e6d-22da-45ba-96b1-3093c69aedba",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "plt.plot(noisy_data);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07e103c9-62e2-44e5-9f7b-55d3e80fba68",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<!-- This will only work on the day of the live tutorial. -->\n",
    "<div style=\"overflow: hidden;\"><iframe src=\"https://app.sli.do/event/dFsiXggxZ3t2B9yhr5zmxZ\" width=\"100%\" height=\"280\" scrolling=\"no\" style=\"border: none;\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c85a5351-864b-4e43-98de-535beba12534",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Answer:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02031603-db3b-45ae-9726-027e5f504468",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "downsampled = np.mean(noisy_data.reshape(len(noisy_data) // 10, 10), axis=1)\n",
    "plt.plot(downsampled);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc9d6222-ec14-45bc-8452-a9c93fa05d28",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "**Go to the [Part 1 project](project.ipynb) now!**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "scipy2024-tutorial-thinking-in-arrays",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}