10-introduction-to-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming Design\n",
    "\n",
    "> Introduction to NumPy\n",
    "\n",
    "Yao-Jen Kuo <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Importing libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Getting Started with NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is NumPy?\n",
    "\n",
    "> NumPy, as in numerical Python is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.\n",
    "\n",
    "Source: <https://numpy.org/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Two Python array packages existed before NumPy\n",
    "\n",
    "- The `Numeric` package was developed in the mid-1990s.\n",
    "- The `Numarray` package was a reimplementation of `Numeric`.\n",
    "- `NumPy` emerged as a best of both combining the features of `Numarray` and `Numeric` in 2005.\n",
    "\n",
    "Source: <https://www.nature.com/articles/s41586-020-2649-2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Import NumPy with `import` keyword\n",
    "\n",
    "NumPy is officially aliased as `np`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If NumPy is not installed, we will encounter a `ModuleNotFoundError`\n",
    "\n",
    "```\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "ModuleNotFoundError: No module named 'numpy'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `pip install` at Terminal to install numpy\n",
    "\n",
    "```bash\n",
    "pip install numpy\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Check version and its installation file path\n",
    "\n",
    "- `__version__` attribute\n",
    "- `__file__` attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.25.2\n",
      "/Users/kuoyaojen/miniconda3/lib/python3.11/site-packages/numpy/__init__.py\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)\n",
    "print(np.__file__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why NumPy?\n",
    "\n",
    "- Built-in data structures come with great flexibility that is able to contain heterogeneous data types.\n",
    "- To allow these flexible types, each item in the structure must contain its own type info, reference count.\n",
    "- Fixed-type arrays lack this flexibility, but are much more efficient for storing and manipulating data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A heterogenous `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'bool'>\n",
      "<class 'bool'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "heterogeneous_list = [False, True, 5566, 55.66, '5566']\n",
    "print(type(heterogeneous_list))\n",
    "for i in heterogeneous_list:\n",
    "    print(type(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A homogeneous `ndarray`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.str_'>\n"
     ]
    }
   ],
   "source": [
    "homogeneous_arr = np.array(heterogeneous_list)\n",
    "print(type(homogeneous_arr))\n",
    "for i in homogeneous_arr:\n",
    "    print(type(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The advantage of fix typed arrays\n",
    "\n",
    "More efficient for storing and manipulating data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "m = 1000000\n",
    "large_array = np.random.randint(1, 100, size=m)\n",
    "large_list = list(large_array)\n",
    "print(type(large_list))\n",
    "print(type(large_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing time for 1,000,000 repicprocals: 0.23 seconds.\n"
     ]
    }
   ],
   "source": [
    "# Computing reciprocals for large list\n",
    "start_time = time.time()\n",
    "reciprocals = [1 / i for i in large_list]\n",
    "end_time = time.time()\n",
    "computing_time = end_time - start_time\n",
    "print(f\"Computing time for {m:,} repicprocals: {computing_time:.2f} seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing time for 1,000,000 repicprocals: 0.03 seconds.\n"
     ]
    }
   ],
   "source": [
    "# Computing for large array\n",
    "start_time = time.time()\n",
    "reciprocals = 1 / large_array\n",
    "end_time = time.time()\n",
    "computing_time = end_time - start_time\n",
    "print(f\"Computing time for {m:,} repicprocals: {computing_time:.2f} seconds.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Key functionalities we rely on NumPy:\n",
    "\n",
    "- Array manipulations\n",
    "- Universal/aggregate functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a `ndarray`?\n",
    "\n",
    "> A ndarray is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "lst = list(range(1, 11))\n",
    "print(type(lst))\n",
    "arr = np.array(lst)\n",
    "print(type(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from scratch: zeros, ones, and full functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0.]\n",
      "[1. 1. 1. 1. 1.]\n",
      "[6. 6. 6. 6. 6.]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros(5))\n",
    "print(np.ones(5))\n",
    "print(np.full(5, 6.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from scratch: generating sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7 9]\n",
      "[1. 3. 5. 7. 9.]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(1, 11, 2))\n",
    "print(np.linspace(1, 9, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Creating arrays from scratch: randomness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9947568  0.51235275 0.54967515 ... 0.87308724 0.18720451 0.9355039 ]\n",
      "[-1.35535462 -0.30094536  1.44169501 ...  0.19661879  0.38415252\n",
      " -0.03949102]\n",
      "[4 3 1 ... 5 5 4]\n"
     ]
    }
   ],
   "source": [
    "uniform_arr = np.random.random(10000)\n",
    "normal_arr = np.random.normal(0, 1, 10000)\n",
    "randint_arr = np.random.randint(1, 7, size=10000)\n",
    "print(uniform_arr)\n",
    "print(normal_arr)\n",
    "print(randint_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Validating distribution with histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAk4klEQVR4nO3de3BU12HH8d9aj0XI0hYhs49oI8uNcIIFNJViQHnwEsKKgdi4Ay0dD3SIxx4MtSooRdCp5U6CCBkejolp66Fg84iYxpbjGTBGDEZGUWlBhQmPTEJicKSx1ipE7EqgrLB8+oeHbRYJmxV6nBXfz8yd8d579urcO5j9cveu1mGMMQIAALDIPYM9AQAAgJsRKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACskzjYE+iNTz75RB9++KHS0tLkcDgGezoAAOA2GGPU1tYmn8+ne+757GskcRkoH374ofx+/2BPAwAA9EJjY6OysrI+c0xcBkpaWpqkTw8wPT19kGcDAABuRygUkt/vj7yOf5a4DJQbb+ukp6cTKAAAxJnbuT2Dm2QBAIB1CBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGCdxMGeAAAA6B/3r9rX6+deXPdoH84kdlxBAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFiHX9QGxIF4/mVLANAbXEEBAADWIVAAAIB1CBQAAGAdAgUAAFiHm2QB4C7GDdiwFYHSA/6HBQBgcMX0Fs/WrVs1btw4paenKz09XZMmTdLbb78d2b5o0SI5HI6oZeLEiVH7CIfDWrZsmTIzM5Wamqo5c+aoqampb44GAAAMCTEFSlZWltatW6cTJ07oxIkTmjZtmr7zne/o7NmzkTGPPPKImpubI8v+/fuj9lFaWqrq6mpVVVWprq5O7e3tmjVrlrq6uvrmiAAAQNyL6S2e2bNnRz3+/ve/r61bt+rYsWN66KGHJElOp1Mej6fH5weDQW3btk07d+5UUVGRJGnXrl3y+/06dOiQZs6c2ZtjAAAAQ0yvP8XT1dWlqqoqXb16VZMmTYqsP3LkiEaNGqXRo0frqaeeUktLS2RbQ0ODrl+/ruLi4sg6n8+nvLw81dfX3/JnhcNhhUKhqAUAAAxdMQfK6dOnde+998rpdOqZZ55RdXW1xowZI0kqKSnR7t27dfjwYW3YsEHHjx/XtGnTFA6HJUmBQEDJyckaMWJE1D7dbrcCgcAtf2ZlZaVcLldk8fv9sU4bAADEkZg/xfPggw/q1KlTunLlil5//XUtXLhQtbW1GjNmjObPnx8Zl5eXp4KCAmVnZ2vfvn2aO3fuLfdpjJHD4bjl9vLycpWVlUUeh0IhIgW9xqe0AMB+MQdKcnKyvvSlL0mSCgoKdPz4cb344ov613/9125jvV6vsrOzdf78eUmSx+NRZ2enWltbo66itLS0qLCw8JY/0+l0yul0xjpVAAAQp+74N8kaYyJv4dzs8uXLamxslNfrlSTl5+crKSlJNTU1kTHNzc06c+bMZwYKAAC4u8R0BWX16tUqKSmR3+9XW1ubqqqqdOTIER04cEDt7e2qqKjQE088Ia/Xq4sXL2r16tXKzMzU448/LklyuVxavHixli9frpEjRyojI0MrVqzQ2LFjI5/qAQAAiClQPvroIz355JNqbm6Wy+XSuHHjdODAAc2YMUMdHR06ffq0XnvtNV25ckVer1dTp07V3r17lZaWFtnHpk2blJiYqHnz5qmjo0PTp0/Xjh07lJCQ0OcHh9vDPRkAANvEFCjbtm275baUlBS98847n7uPYcOG6aWXXtJLL70Uy4+GpYgbAOhfd/L3bDzju3iGiLv1DzAAYGi645tkAQAA+hqBAgAArEOgAAAA63APCgAAt4EPBQwsrqAAAADrcAUFwJAyWJ9o41/IseFqBD4PgWIRPioMAMCnCBTEJWIOAIY27kEBAADW4QoKMMTxXj+AeESgALgl4gbAYCFQACCOcT8WhiruQQEAANYhUAAAgHV4iweDhkvTAIBbIVCAAUKQAcDtI1AAYJARr0B3BEof4y8aAADuHDfJAgAA63AFBQCAfsbV9dhxBQUAAFiHKyhADPhXEAAMDAIFANArBDv6E4ECAIgrfInl3YFAAYA+wNUEoG9xkywAALAOgQIAAKxDoAAAAOtwDwoA63A/BwCuoAAAAOtwBQUAcNfg6lz84AoKAACwDoECAACsQ6AAAADrECgAAMA6MQXK1q1bNW7cOKWnpys9PV2TJk3S22+/HdlujFFFRYV8Pp9SUlI0ZcoUnT17Nmof4XBYy5YtU2ZmplJTUzVnzhw1NTX1zdEAAIAhIaZAycrK0rp163TixAmdOHFC06ZN03e+851IhKxfv14bN27Uli1bdPz4cXk8Hs2YMUNtbW2RfZSWlqq6ulpVVVWqq6tTe3u7Zs2apa6urr49MgAAELdiCpTZs2fr29/+tkaPHq3Ro0fr+9//vu69914dO3ZMxhht3rxZa9as0dy5c5WXl6dXX31V165d0549eyRJwWBQ27Zt04YNG1RUVKSvfvWr2rVrl06fPq1Dhw71ywECAID40+t7ULq6ulRVVaWrV69q0qRJunDhggKBgIqLiyNjnE6nJk+erPr6eklSQ0ODrl+/HjXG5/MpLy8vMgYAACDmX9R2+vRpTZo0SX/4wx907733qrq6WmPGjIkEhtvtjhrvdrv1wQcfSJICgYCSk5M1YsSIbmMCgcAtf2Y4HFY4HI48DoVCsU4bAADEkZgD5cEHH9SpU6d05coVvf7661q4cKFqa2sj2x0OR9R4Y0y3dTf7vDGVlZV64YUXYp0qgEHEb+wEcCdifosnOTlZX/rSl1RQUKDKykqNHz9eL774ojwejyR1uxLS0tISuari8XjU2dmp1tbWW47pSXl5uYLBYGRpbGyMddoAACCO3PHvQTHGKBwOKycnRx6PRzU1NZFtnZ2dqq2tVWFhoSQpPz9fSUlJUWOam5t15syZyJieOJ3OyEebbywAAGDoiuktntWrV6ukpER+v19tbW2qqqrSkSNHdODAATkcDpWWlmrt2rXKzc1Vbm6u1q5dq+HDh2vBggWSJJfLpcWLF2v58uUaOXKkMjIytGLFCo0dO1ZFRUX9coAAACD+xBQoH330kZ588kk1NzfL5XJp3LhxOnDggGbMmCFJWrlypTo6OrRkyRK1trZqwoQJOnjwoNLS0iL72LRpkxITEzVv3jx1dHRo+vTp2rFjhxISEvr2yAAAQNxyGGPMYE8iVqFQSC6XS8FgsF/e7uHmPgDA3e7iukf7fJ+xvH7zXTwAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6MQVKZWWlvva1ryktLU2jRo3SY489pl/96ldRYxYtWiSHwxG1TJw4MWpMOBzWsmXLlJmZqdTUVM2ZM0dNTU13fjQAAGBIiClQamtr9eyzz+rYsWOqqanRxx9/rOLiYl29ejVq3COPPKLm5ubIsn///qjtpaWlqq6uVlVVlerq6tTe3q5Zs2apq6vrzo8IAADEvcRYBh84cCDq8fbt2zVq1Cg1NDToW9/6VmS90+mUx+PpcR/BYFDbtm3Tzp07VVRUJEnatWuX/H6/Dh06pJkzZ8Z6DAAAYIi5o3tQgsGgJCkjIyNq/ZEjRzRq1CiNHj1aTz31lFpaWiLbGhoadP36dRUXF0fW+Xw+5eXlqb6+vsefEw6HFQqFohYAADB09TpQjDEqKyvTN77xDeXl5UXWl5SUaPfu3Tp8+LA2bNig48ePa9q0aQqHw5KkQCCg5ORkjRgxImp/brdbgUCgx59VWVkpl8sVWfx+f2+nDQAA4kBMb/H8saVLl+oXv/iF6urqotbPnz8/8t95eXkqKChQdna29u3bp7lz595yf8YYORyOHreVl5errKws8jgUChEpAAAMYb26grJs2TK99dZbevfdd5WVlfWZY71er7Kzs3X+/HlJksfjUWdnp1pbW6PGtbS0yO1297gPp9Op9PT0qAUAAAxdMQWKMUZLly7VG2+8ocOHDysnJ+dzn3P58mU1NjbK6/VKkvLz85WUlKSamprImObmZp05c0aFhYUxTh8AAAxFMb3F8+yzz2rPnj362c9+prS0tMg9Iy6XSykpKWpvb1dFRYWeeOIJeb1eXbx4UatXr1ZmZqYef/zxyNjFixdr+fLlGjlypDIyMrRixQqNHTs28qkeAABwd4spULZu3SpJmjJlStT67du3a9GiRUpISNDp06f12muv6cqVK/J6vZo6dar27t2rtLS0yPhNmzYpMTFR8+bNU0dHh6ZPn64dO3YoISHhzo8IAADEPYcxxgz2JGIVCoXkcrkUDAb75X6U+1ft6/N9AgAQTy6ue7TP9xnL6zffxQMAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALBOTIFSWVmpr33ta0pLS9OoUaP02GOP6Ve/+lXUGGOMKioq5PP5lJKSoilTpujs2bNRY8LhsJYtW6bMzEylpqZqzpw5ampquvOjAQAAQ0JMgVJbW6tnn31Wx44dU01NjT7++GMVFxfr6tWrkTHr16/Xxo0btWXLFh0/flwej0czZsxQW1tbZExpaamqq6tVVVWluro6tbe3a9asWerq6uq7IwMAAHHLYYwxvX3y//7v/2rUqFGqra3Vt771LRlj5PP5VFpaqn/4h3+Q9OnVErfbrR/84Ad6+umnFQwGdd9992nnzp2aP3++JOnDDz+U3+/X/v37NXPmzM/9uaFQSC6XS8FgUOnp6b2d/i3dv2pfn+8TAIB4cnHdo32+z1hev+/oHpRgMChJysjIkCRduHBBgUBAxcXFkTFOp1OTJ09WfX29JKmhoUHXr1+PGuPz+ZSXlxcZAwAA7m6JvX2iMUZlZWX6xje+oby8PElSIBCQJLnd7qixbrdbH3zwQWRMcnKyRowY0W3MjeffLBwOKxwORx6HQqHeThsAAMSBXl9BWbp0qX7xi1/oJz/5SbdtDocj6rExptu6m33WmMrKSrlcrsji9/t7O20AABAHehUoy5Yt01tvvaV3331XWVlZkfUej0eSul0JaWlpiVxV8Xg86uzsVGtr6y3H3Ky8vFzBYDCyNDY29mbaAAAgTsQUKMYYLV26VG+88YYOHz6snJycqO05OTnyeDyqqamJrOvs7FRtba0KCwslSfn5+UpKSooa09zcrDNnzkTG3MzpdCo9PT1qAQAAQ1dM96A8++yz2rNnj372s58pLS0tcqXE5XIpJSVFDodDpaWlWrt2rXJzc5Wbm6u1a9dq+PDhWrBgQWTs4sWLtXz5co0cOVIZGRlasWKFxo4dq6Kior4/QgAAEHdiCpStW7dKkqZMmRK1fvv27Vq0aJEkaeXKlero6NCSJUvU2tqqCRMm6ODBg0pLS4uM37RpkxITEzVv3jx1dHRo+vTp2rFjhxISEu7saAAAwJBwR78HZbDwe1AAAOhfcf17UAAAAPoDgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALBOzIHy3nvvafbs2fL5fHI4HHrzzTejti9atEgOhyNqmThxYtSYcDisZcuWKTMzU6mpqZozZ46ampru6EAAAMDQEXOgXL16VePHj9eWLVtuOeaRRx5Rc3NzZNm/f3/U9tLSUlVXV6uqqkp1dXVqb2/XrFmz1NXVFfsRAACAIScx1ieUlJSopKTkM8c4nU55PJ4etwWDQW3btk07d+5UUVGRJGnXrl3y+/06dOiQZs6cGeuUAADAENMv96AcOXJEo0aN0ujRo/XUU0+ppaUlsq2hoUHXr19XcXFxZJ3P51NeXp7q6+t73F84HFYoFIpaAADA0NXngVJSUqLdu3fr8OHD2rBhg44fP65p06YpHA5LkgKBgJKTkzVixIio57ndbgUCgR73WVlZKZfLFVn8fn9fTxsAAFgk5rd4Ps/8+fMj/52Xl6eCggJlZ2dr3759mjt37i2fZ4yRw+HocVt5ebnKysoij0OhEJECAMAQ1u8fM/Z6vcrOztb58+clSR6PR52dnWptbY0a19LSIrfb3eM+nE6n0tPToxYAADB09XugXL58WY2NjfJ6vZKk/Px8JSUlqaamJjKmublZZ86cUWFhYX9PBwAAxIGY3+Jpb2/Xb37zm8jjCxcu6NSpU8rIyFBGRoYqKir0xBNPyOv16uLFi1q9erUyMzP1+OOPS5JcLpcWL16s5cuXa+TIkcrIyNCKFSs0duzYyKd6AADA3S3mQDlx4oSmTp0aeXzj3pCFCxdq69atOn36tF577TVduXJFXq9XU6dO1d69e5WWlhZ5zqZNm5SYmKh58+apo6ND06dP144dO5SQkNAHhwQAAOKdwxhjBnsSsQqFQnK5XAoGg/1yP8r9q/b1+T4BAIgnF9c92uf7jOX1m+/iAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWCfmQHnvvfc0e/Zs+Xw+ORwOvfnmm1HbjTGqqKiQz+dTSkqKpkyZorNnz0aNCYfDWrZsmTIzM5Wamqo5c+aoqanpjg4EAAAMHTEHytWrVzV+/Hht2bKlx+3r16/Xxo0btWXLFh0/flwej0czZsxQW1tbZExpaamqq6tVVVWluro6tbe3a9asWerq6ur9kQAAgCEjMdYnlJSUqKSkpMdtxhht3rxZa9as0dy5cyVJr776qtxut/bs2aOnn35awWBQ27Zt086dO1VUVCRJ2rVrl/x+vw4dOqSZM2feweEAAIChoE/vQblw4YICgYCKi4sj65xOpyZPnqz6+npJUkNDg65fvx41xufzKS8vLzLmZuFwWKFQKGoBAABDV58GSiAQkCS53e6o9W63O7ItEAgoOTlZI0aMuOWYm1VWVsrlckUWv9/fl9MGAACW6ZdP8TgcjqjHxphu6272WWPKy8sVDAYjS2NjY5/NFQAA2KdPA8Xj8UhStyshLS0tkasqHo9HnZ2dam1tveWYmzmdTqWnp0ctAABg6OrTQMnJyZHH41FNTU1kXWdnp2pra1VYWChJys/PV1JSUtSY5uZmnTlzJjIGAADc3WL+FE97e7t+85vfRB5fuHBBp06dUkZGhr74xS+qtLRUa9euVW5urnJzc7V27VoNHz5cCxYskCS5XC4tXrxYy5cv18iRI5WRkaEVK1Zo7NixkU/1AACAu1vMgXLixAlNnTo18risrEyStHDhQu3YsUMrV65UR0eHlixZotbWVk2YMEEHDx5UWlpa5DmbNm1SYmKi5s2bp46ODk2fPl07duxQQkJCHxwSAACIdw5jjBnsScQqFArJ5XIpGAz2y/0o96/a1+f7BAAgnlxc92if7zOW12++iwcAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADWIVAAAIB1CBQAAGAdAgUAAFinzwOloqJCDocjavF4PJHtxhhVVFTI5/MpJSVFU6ZM0dmzZ/t6GgAAII71yxWUhx56SM3NzZHl9OnTkW3r16/Xxo0btWXLFh0/flwej0czZsxQW1tbf0wFAADEoX4JlMTERHk8nshy3333Sfr06snmzZu1Zs0azZ07V3l5eXr11Vd17do17dmzpz+mAgAA4lC/BMr58+fl8/mUk5Ojv/zLv9T7778vSbpw4YICgYCKi4sjY51OpyZPnqz6+vpb7i8cDisUCkUtAABg6OrzQJkwYYJee+01vfPOO3rllVcUCARUWFioy5cvKxAISJLcbnfUc9xud2RbTyorK+VyuSKL3+/v62kDAACL9HmglJSU6IknntDYsWNVVFSkffv2SZJeffXVyBiHwxH1HGNMt3V/rLy8XMFgMLI0Njb29bQBAIBF+v1jxqmpqRo7dqzOnz8f+TTPzVdLWlpaul1V+WNOp1Pp6elRCwAAGLr6PVDC4bB++ctfyuv1KicnRx6PRzU1NZHtnZ2dqq2tVWFhYX9PBQAAxInEvt7hihUrNHv2bH3xi19US0uLvve97ykUCmnhwoVyOBwqLS3V2rVrlZubq9zcXK1du1bDhw/XggUL+noqAAAgTvV5oDQ1Nemv/uqvdOnSJd13332aOHGijh07puzsbEnSypUr1dHRoSVLlqi1tVUTJkzQwYMHlZaW1tdTAQAAccphjDGDPYlYhUIhuVwuBYPBfrkf5f5V+/p8nwAAxJOL6x7t833G8vrNd/EAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsQ6AAAADrECgAAMA6BAoAALAOgQIAAKxDoAAAAOsQKAAAwDoECgAAsA6BAgAArEOgAAAA6xAoAADAOgQKAACwDoECAACsM6iB8vLLLysnJ0fDhg1Tfn6+jh49OpjTAQAAlhi0QNm7d69KS0u1Zs0anTx5Ut/85jdVUlKi3/3ud4M1JQAAYIlBC5SNGzdq8eLF+u53v6uvfOUr2rx5s/x+v7Zu3TpYUwIAAJZIHIwf2tnZqYaGBq1atSpqfXFxserr67uND4fDCofDkcfBYFCSFAqF+mV+n4Sv9ct+AQCIF/3xGntjn8aYzx07KIFy6dIldXV1ye12R613u90KBALdxldWVuqFF17ott7v9/fbHAEAuJu5Nvffvtva2uRyuT5zzKAEyg0OhyPqsTGm2zpJKi8vV1lZWeTxJ598ot///vcaOXJkj+PvRCgUkt/vV2Njo9LT0/t03/h/nOeBwXkeGJzngcO5Hhj9dZ6NMWpra5PP5/vcsYMSKJmZmUpISOh2taSlpaXbVRVJcjqdcjqdUev+5E/+pD+nqPT0dP7wDwDO88DgPA8MzvPA4VwPjP44z5935eSGQblJNjk5Wfn5+aqpqYlaX1NTo8LCwsGYEgAAsMigvcVTVlamJ598UgUFBZo0aZL+7d/+Tb/73e/0zDPPDNaUAACAJQYtUObPn6/Lly/rn//5n9Xc3Ky8vDzt379f2dnZgzUlSZ++nfT88893e0sJfYvzPDA4zwOD8zxwONcDw4bz7DC381kfAACAAcR38QAAAOsQKAAAwDoECgAAsA6BAgAArHNXBsrLL7+snJwcDRs2TPn5+Tp69Ohnjq+trVV+fr6GDRumBx54QP/yL/8yQDONb7Gc5zfeeEMzZszQfffdp/T0dE2aNEnvvPPOAM42fsX65/mGn//850pMTNSf/dmf9e8Eh4hYz3M4HNaaNWuUnZ0tp9OpP/3TP9W///u/D9Bs41es53n37t0aP368hg8fLq/Xq7/5m7/R5cuXB2i28em9997T7Nmz5fP55HA49Oabb37ucwblddDcZaqqqkxSUpJ55ZVXzLlz58xzzz1nUlNTzQcffNDj+Pfff98MHz7cPPfcc+bcuXPmlVdeMUlJSeanP/3pAM88vsR6np977jnzgx/8wPz3f/+3+fWvf23Ky8tNUlKS+Z//+Z8Bnnl8ifU833DlyhXzwAMPmOLiYjN+/PiBmWwc6815njNnjpkwYYKpqakxFy5cMP/1X/9lfv7znw/grONPrOf56NGj5p577jEvvviief/9983Ro0fNQw89ZB577LEBnnl82b9/v1mzZo15/fXXjSRTXV39meMH63XwrguUhx9+2DzzzDNR67785S+bVatW9Th+5cqV5stf/nLUuqefftpMnDix3+Y4FMR6nnsyZswY88ILL/T11IaU3p7n+fPnm3/8x380zz//PIFyG2I9z2+//bZxuVzm8uXLAzG9ISPW8/zDH/7QPPDAA1HrfvSjH5msrKx+m+NQczuBMlivg3fVWzydnZ1qaGhQcXFx1Pri4mLV19f3+Jz//M//7DZ+5syZOnHihK5fv95vc41nvTnPN/vkk0/U1tamjIyM/pjikNDb87x9+3b99re/1fPPP9/fUxwSenOe33rrLRUUFGj9+vX6whe+oNGjR2vFihXq6OgYiCnHpd6c58LCQjU1NWn//v0yxuijjz7ST3/6Uz366KMDMeW7xmC9Dg7qtxkPtEuXLqmrq6vbFxK63e5uX1x4QyAQ6HH8xx9/rEuXLsnr9fbbfONVb87zzTZs2KCrV69q3rx5/THFIaE35/n8+fNatWqVjh49qsTEu+p//17rzXl+//33VVdXp2HDhqm6ulqXLl3SkiVL9Pvf/577UG6hN+e5sLBQu3fv1vz58/WHP/xBH3/8sebMmaOXXnppIKZ81xis18G76grKDQ6HI+qxMabbus8b39N6RIv1PN/wk5/8RBUVFdq7d69GjRrVX9MbMm73PHd1dWnBggV64YUXNHr06IGa3pARy5/nTz75RA6HQ7t379bDDz+sb3/729q4caN27NjBVZTPEct5PnfunP72b/9W//RP/6SGhgYdOHBAFy5c4Dvd+sFgvA7eVf+EyszMVEJCQrcab2lp6VaHN3g8nh7HJyYmauTIkf0213jWm/N8w969e7V48WL9x3/8h4qKivpzmnEv1vPc1tamEydO6OTJk1q6dKmkT19IjTFKTEzUwYMHNW3atAGZezzpzZ9nr9erL3zhC1FfK/+Vr3xFxhg1NTUpNze3X+ccj3pznisrK/X1r39df//3fy9JGjdunFJTU/XNb35T3/ve97jC3UcG63XwrrqCkpycrPz8fNXU1EStr6mpUWFhYY/PmTRpUrfxBw8eVEFBgZKSkvptrvGsN+dZ+vTKyaJFi7Rnzx7eQ74NsZ7n9PR0nT59WqdOnYoszzzzjB588EGdOnVKEyZMGKipx5Xe/Hn++te/rg8//FDt7e2Rdb/+9a91zz33KCsrq1/nG696c56vXbume+6JfhlLSEiQ9P//wsedG7TXwX69BddCNz7Gtm3bNnPu3DlTWlpqUlNTzcWLF40xxqxatco8+eSTkfE3Pl71d3/3d+bcuXNm27ZtfMz4NsR6nvfs2WMSExPNj3/8Y9Pc3BxZrly5MliHEBdiPc8341M8tyfW89zW1maysrLMX/zFX5izZ8+a2tpak5uba7773e8O1iHEhVjP8/bt201iYqJ5+eWXzW9/+1tTV1dnCgoKzMMPPzxYhxAX2trazMmTJ83JkyeNJLNx40Zz8uTJyMe5bXkdvOsCxRhjfvzjH5vs7GyTnJxs/vzP/9zU1tZGti1cuNBMnjw5avyRI0fMV7/6VZOcnGzuv/9+s3Xr1gGecXyK5TxPnjzZSOq2LFy4cOAnHmdi/fP8xwiU2xfref7lL39pioqKTEpKisnKyjJlZWXm2rVrAzzr+BPref7Rj35kxowZY1JSUozX6zV//dd/bZqamgZ41vHl3Xff/cy/b215HXQYw3UwAABgl7vqHhQAABAfCBQAAGAdAgUAAFiHQAEAANYhUAAAgHUIFAAAYB0CBQAAWIdAAQAA1iFQAACAdQgUAABgHQIFAABYh0ABAADW+T9ti4LO7xl8yQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "ax.hist(uniform_arr, bins=30)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "ax.hist(normal_arr, bins=30)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjEAAAGdCAYAAADjWSL8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlEUlEQVR4nO3df1DU953H8dceP1blYOtClt2dIOF6xnpCrEJPIW2D0aLbINfoRa05qhdLmqnRcsi0IZleyE0qaW8S08OpEx2rUcjg3Fw1uTPFQBO1njEqHq0ax2JDTmxYyXmwiPUWqt/74ybf6wbUQiHLB5+Pme8M+/1+9st7d5zJM9/dZR2WZVkCAAAwzJ9EewAAAIChIGIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGCk22gOMlOvXr+uDDz5QYmKiHA5HtMcBAAB/AMuydPnyZfn9fv3Jn9z8WsuYjZgPPvhAaWlp0R4DAAAMQVtbm+68886brhmzEZOYmCjp/56EpKSkKE8DAAD+EN3d3UpLS7P/O34zYzZiPnoJKSkpiYgBAMAwf8hbQXhjLwAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIg46YgwcPauHChfL7/XI4HNqzZ0/EcYfDMeD2j//4j/aa/Pz8fseXLVsWcZ7Ozk4VFxfL5XLJ5XKpuLhYXV1dQ3qQAABg7Bl0xFy5ckXTp0/Xxo0bBzze3t4esf34xz+Ww+HQ4sWLI9aVlJRErHvppZciji9fvlzNzc2qr69XfX29mpubVVxcPNhxAQDAGDXorx0IBAIKBAI3PO71eiNuv/rqq5ozZ47+7M/+LGL/hAkT+q39yJkzZ1RfX68jR45o1qxZkqQtW7YoNzdXZ8+e1ZQpUwY7NgAAGGNG9D0xFy9e1N69e7Vq1ap+x2pra5WSkqJp06apvLxcly9fto+9/fbbcrlcdsBI0uzZs+VyuXT48OEBf1c4HFZ3d3fEBgAAxq4R/QLIl19+WYmJiVq0aFHE/ocfflgZGRnyer06deqUKioq9Itf/EINDQ2SpGAwKI/H0+98Ho9HwWBwwN9VVVWlZ555ZvgfBAAAGJVGNGJ+/OMf6+GHH9a4ceMi9peUlNg/Z2ZmavLkycrJydGJEyc0c+ZMSQN/e6VlWTf8VsuKigqVlZXZtz/6Km8AADA2jVjE/PznP9fZs2e1a9euW66dOXOm4uLi1NLSopkzZ8rr9erixYv91n344YdKTU0d8BxOp1NOp/OPnhsYbe56Ym+0R4iK9597INojABjlRuw9MVu3blV2dramT59+y7WnT59WX1+ffD6fJCk3N1ehUEhHjx6117zzzjsKhULKy8sbqZEBAIBBBn0lpqenR+fOnbNvt7a2qrm5WW63W5MmTZL0fy/l/PM//7Oef/75fvf/9a9/rdraWn35y19WSkqK3n33Xa1bt04zZszQvffeK0maOnWqFixYoJKSEvuj148++qgKCwv5ZBIAAJA0hCsxx48f14wZMzRjxgxJUllZmWbMmKG///u/t9fU1dXJsix99atf7Xf/+Ph4/exnP9P8+fM1ZcoUrV27VgUFBWpsbFRMTIy9rra2VllZWSooKFBBQYHuuece7dy5cyiPEQAAjEEOy7KsaA8xErq7u+VyuRQKhZSUlBTtcYAh4z0xAG4ng/nvN9+dBAAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBII/oFkGMZf7sDAIDo4koMAAAwEhEDAACMRMQAAAAjETEAAMBIvLEXnyjeEI1PCv/W8Em5Xf+tSdH/98aVGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEbiu5MAALbb9XuAov0dQBgarsQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADDSoCPm4MGDWrhwofx+vxwOh/bs2RNxfOXKlXI4HBHb7NmzI9aEw2GtWbNGKSkpSkhIUFFRkS5cuBCxprOzU8XFxXK5XHK5XCouLlZXV9egHyAAABibBh0xV65c0fTp07Vx48YbrlmwYIHa29vt7fXXX484Xlpaqt27d6uurk6HDh1ST0+PCgsLde3aNXvN8uXL1dzcrPr6etXX16u5uVnFxcWDHRcAAIxRsYO9QyAQUCAQuOkap9Mpr9c74LFQKKStW7dq586dmjdvniSppqZGaWlpamxs1Pz583XmzBnV19fryJEjmjVrliRpy5Ytys3N1dmzZzVlypTBjg0AAMaYEXlPzP79++XxeHT33XerpKREHR0d9rGmpib19fWpoKDA3uf3+5WZmanDhw9Lkt5++225XC47YCRp9uzZcrlc9pqPC4fD6u7ujtgAAMDYNewREwgEVFtbqzfffFPPP/+8jh07pvvvv1/hcFiSFAwGFR8fr4kTJ0bcLzU1VcFg0F7j8Xj6ndvj8dhrPq6qqsp+/4zL5VJaWtowPzIAADCaDPrlpFtZunSp/XNmZqZycnKUnp6uvXv3atGiRTe8n2VZcjgc9u3f//lGa35fRUWFysrK7Nvd3d2EDAAAY9iIf8Ta5/MpPT1dLS0tkiSv16ve3l51dnZGrOvo6FBqaqq95uLFi/3O9eGHH9prPs7pdCopKSliAwAAY9eIR8ylS5fU1tYmn88nScrOzlZcXJwaGhrsNe3t7Tp16pTy8vIkSbm5uQqFQjp69Ki95p133lEoFLLXAACA29ugX07q6enRuXPn7Nutra1qbm6W2+2W2+1WZWWlFi9eLJ/Pp/fff19PPvmkUlJS9OCDD0qSXC6XVq1apXXr1ik5OVlut1vl5eXKysqyP600depULViwQCUlJXrppZckSY8++qgKCwv5ZBIAAJA0hIg5fvy45syZY9/+6H0oK1as0KZNm3Ty5Ent2LFDXV1d8vl8mjNnjnbt2qXExET7Phs2bFBsbKyWLFmiq1evau7cudq+fbtiYmLsNbW1tVq7dq39KaaioqKb/m0aAABwexl0xOTn58uyrBse37dv3y3PMW7cOFVXV6u6uvqGa9xut2pqagY7HgAAuE3w3UkAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIw06Ig5ePCgFi5cKL/fL4fDoT179tjH+vr69J3vfEdZWVlKSEiQ3+/X1772NX3wwQcR58jPz5fD4YjYli1bFrGms7NTxcXFcrlccrlcKi4uVldX15AeJAAAGHsGHTFXrlzR9OnTtXHjxn7Hfvvb3+rEiRP67ne/qxMnTugnP/mJfvWrX6moqKjf2pKSErW3t9vbSy+9FHF8+fLlam5uVn19verr69Xc3Kzi4uLBjgsAAMao2MHeIRAIKBAIDHjM5XKpoaEhYl91dbX+8i//UufPn9ekSZPs/RMmTJDX6x3wPGfOnFF9fb2OHDmiWbNmSZK2bNmi3NxcnT17VlOmTBns2AAAYIwZ8ffEhEIhORwOfepTn4rYX1tbq5SUFE2bNk3l5eW6fPmyfeztt9+Wy+WyA0aSZs+eLZfLpcOHD4/0yAAAwACDvhIzGP/zP/+jJ554QsuXL1dSUpK9/+GHH1ZGRoa8Xq9OnTqliooK/eIXv7Cv4gSDQXk8nn7n83g8CgaDA/6ucDiscDhs3+7u7h7mRwMAAEaTEYuYvr4+LVu2TNevX9ePfvSjiGMlJSX2z5mZmZo8ebJycnJ04sQJzZw5U5LkcDj6ndOyrAH3S1JVVZWeeeaZYXwEAABgNBuRl5P6+vq0ZMkStba2qqGhIeIqzEBmzpypuLg4tbS0SJK8Xq8uXrzYb92HH36o1NTUAc9RUVGhUChkb21tbX/8AwEAAKPWsEfMRwHT0tKixsZGJScn3/I+p0+fVl9fn3w+nyQpNzdXoVBIR48etde88847CoVCysvLG/AcTqdTSUlJERsAABi7Bv1yUk9Pj86dO2ffbm1tVXNzs9xut/x+v/76r/9aJ06c0L/927/p2rVr9ntY3G634uPj9etf/1q1tbX68pe/rJSUFL377rtat26dZsyYoXvvvVeSNHXqVC1YsEAlJSX2R68fffRRFRYW8skkAAAgaQgRc/z4cc2ZM8e+XVZWJklasWKFKisr9dprr0mSPvvZz0bc76233lJ+fr7i4+P1s5/9TD/84Q/V09OjtLQ0PfDAA3r66acVExNjr6+trdXatWtVUFAgSSoqKhrwb9MAAIDb06AjJj8/X5Zl3fD4zY5JUlpamg4cOHDL3+N2u1VTUzPY8QAAwG2C704CAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABhp0BFz8OBBLVy4UH6/Xw6HQ3v27Ik4blmWKisr5ff7NX78eOXn5+v06dMRa8LhsNasWaOUlBQlJCSoqKhIFy5ciFjT2dmp4uJiuVwuuVwuFRcXq6ura9APEAAAjE2DjpgrV65o+vTp2rhx44DHf/CDH+iFF17Qxo0bdezYMXm9Xn3pS1/S5cuX7TWlpaXavXu36urqdOjQIfX09KiwsFDXrl2z1yxfvlzNzc2qr69XfX29mpubVVxcPISHCAAAxqLYwd4hEAgoEAgMeMyyLL344ot66qmntGjRIknSyy+/rNTUVL3yyiv6xje+oVAopK1bt2rnzp2aN2+eJKmmpkZpaWlqbGzU/PnzdebMGdXX1+vIkSOaNWuWJGnLli3Kzc3V2bNnNWXKlKE+XgAAMEYM63tiWltbFQwGVVBQYO9zOp267777dPjwYUlSU1OT+vr6Itb4/X5lZmbaa95++225XC47YCRp9uzZcrlc9pqPC4fD6u7ujtgAAMDYNawREwwGJUmpqakR+1NTU+1jwWBQ8fHxmjhx4k3XeDyefuf3eDz2mo+rqqqy3z/jcrmUlpb2Rz8eAAAweo3Ip5McDkfEbcuy+u37uI+vGWj9zc5TUVGhUChkb21tbUOYHAAAmGJYI8br9UpSv6slHR0d9tUZr9er3t5edXZ23nTNxYsX+53/ww8/7HeV5yNOp1NJSUkRGwAAGLuGNWIyMjLk9XrV0NBg7+vt7dWBAweUl5cnScrOzlZcXFzEmvb2dp06dcpek5ubq1AopKNHj9pr3nnnHYVCIXsNAAC4vQ3600k9PT06d+6cfbu1tVXNzc1yu92aNGmSSktLtX79ek2ePFmTJ0/W+vXrNWHCBC1fvlyS5HK5tGrVKq1bt07Jyclyu90qLy9XVlaW/WmlqVOnasGCBSopKdFLL70kSXr00UdVWFjIJ5MAAICkIUTM8ePHNWfOHPt2WVmZJGnFihXavn27vv3tb+vq1av65je/qc7OTs2aNUtvvPGGEhMT7fts2LBBsbGxWrJkia5evaq5c+dq+/btiomJsdfU1tZq7dq19qeYioqKbvi3aQAAwO1n0BGTn58vy7JueNzhcKiyslKVlZU3XDNu3DhVV1erurr6hmvcbrdqamoGOx4AALhN8N1JAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMNOwRc9ddd8nhcPTbVq9eLUlauXJlv2OzZ8+OOEc4HNaaNWuUkpKihIQEFRUV6cKFC8M9KgAAMNiwR8yxY8fU3t5ubw0NDZKkhx56yF6zYMGCiDWvv/56xDlKS0u1e/du1dXV6dChQ+rp6VFhYaGuXbs23OMCAABDxQ73Ce+4446I288995w+/elP67777rP3OZ1Oeb3eAe8fCoW0detW7dy5U/PmzZMk1dTUKC0tTY2NjZo/f/5wjwwAAAw0ou+J6e3tVU1NjR555BE5HA57//79++XxeHT33XerpKREHR0d9rGmpib19fWpoKDA3uf3+5WZmanDhw+P5LgAAMAgw34l5vft2bNHXV1dWrlypb0vEAjooYceUnp6ulpbW/Xd735X999/v5qamuR0OhUMBhUfH6+JEydGnCs1NVXBYPCGvyscDiscDtu3u7u7h/3xAACA0WNEI2br1q0KBALy+/32vqVLl9o/Z2ZmKicnR+np6dq7d68WLVp0w3NZlhVxNefjqqqq9MwzzwzP4AAAYNQbsZeT/vM//1ONjY36+te/ftN1Pp9P6enpamlpkSR5vV719vaqs7MzYl1HR4dSU1NveJ6KigqFQiF7a2tr++MfBAAAGLVGLGK2bdsmj8ejBx544KbrLl26pLa2Nvl8PklSdna24uLi7E81SVJ7e7tOnTqlvLy8G57H6XQqKSkpYgMAAGPXiLycdP36dW3btk0rVqxQbOz//4qenh5VVlZq8eLF8vl8ev/99/Xkk08qJSVFDz74oCTJ5XJp1apVWrdunZKTk+V2u1VeXq6srCz700oAAAAjEjGNjY06f/68HnnkkYj9MTExOnnypHbs2KGuri75fD7NmTNHu3btUmJior1uw4YNio2N1ZIlS3T16lXNnTtX27dvV0xMzEiMCwAADDQiEVNQUCDLsvrtHz9+vPbt23fL+48bN07V1dWqrq4eifEAAMAYwHcnAQAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIxExAAAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMNOwRU1lZKYfDEbF5vV77uGVZqqyslN/v1/jx45Wfn6/Tp09HnCMcDmvNmjVKSUlRQkKCioqKdOHCheEeFQAAGGxErsRMmzZN7e3t9nby5En72A9+8AO98MIL2rhxo44dOyav16svfelLunz5sr2mtLRUu3fvVl1dnQ4dOqSenh4VFhbq2rVrIzEuAAAwUOyInDQ2NuLqy0csy9KLL76op556SosWLZIkvfzyy0pNTdUrr7yib3zjGwqFQtq6dat27typefPmSZJqamqUlpamxsZGzZ8/fyRGBgAAhhmRKzEtLS3y+/3KyMjQsmXL9N5770mSWltbFQwGVVBQYK91Op267777dPjwYUlSU1OT+vr6Itb4/X5lZmbaawYSDofV3d0dsQEAgLFr2CNm1qxZ2rFjh/bt26ctW7YoGAwqLy9Ply5dUjAYlCSlpqZG3Cc1NdU+FgwGFR8fr4kTJ95wzUCqqqrkcrnsLS0tbZgfGQAAGE2GPWICgYAWL16srKwszZs3T3v37pX0fy8bfcThcETcx7Ksfvs+7lZrKioqFAqF7K2tre2PeBQAAGC0G/GPWCckJCgrK0stLS32+2Q+fkWlo6PDvjrj9XrV29urzs7OG64ZiNPpVFJSUsQGAADGrhGPmHA4rDNnzsjn8ykjI0Ner1cNDQ328d7eXh04cEB5eXmSpOzsbMXFxUWsaW9v16lTp+w1AAAAw/7ppPLyci1cuFCTJk1SR0eHnn32WXV3d2vFihVyOBwqLS3V+vXrNXnyZE2ePFnr16/XhAkTtHz5ckmSy+XSqlWrtG7dOiUnJ8vtdqu8vNx+eQoAAEAagYi5cOGCvvrVr+q//uu/dMcdd2j27Nk6cuSI0tPTJUnf/va3dfXqVX3zm99UZ2enZs2apTfeeEOJiYn2OTZs2KDY2FgtWbJEV69e1dy5c7V9+3bFxMQM97gAAMBQwx4xdXV1Nz3ucDhUWVmpysrKG64ZN26cqqurVV1dPczTAQCAsYLvTgIAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGGnYI6aqqkqf+9znlJiYKI/Ho6985Ss6e/ZsxJqVK1fK4XBEbLNnz45YEw6HtWbNGqWkpCghIUFFRUW6cOHCcI8LAAAMNewRc+DAAa1evVpHjhxRQ0ODfve736mgoEBXrlyJWLdgwQK1t7fb2+uvvx5xvLS0VLt371ZdXZ0OHTqknp4eFRYW6tq1a8M9MgAAMFDscJ+wvr4+4va2bdvk8XjU1NSkL37xi/Z+p9Mpr9c74DlCoZC2bt2qnTt3at68eZKkmpoapaWlqbGxUfPnzx/usQEAgGFG/D0xoVBIkuR2uyP279+/Xx6PR3fffbdKSkrU0dFhH2tqalJfX58KCgrsfX6/X5mZmTp8+PCAvyccDqu7uztiAwAAY9eIRoxlWSorK9PnP/95ZWZm2vsDgYBqa2v15ptv6vnnn9exY8d0//33KxwOS5KCwaDi4+M1ceLEiPOlpqYqGAwO+LuqqqrkcrnsLS0tbeQeGAAAiLphfznp9z3++OP65S9/qUOHDkXsX7p0qf1zZmamcnJylJ6err1792rRokU3PJ9lWXI4HAMeq6ioUFlZmX27u7ubkAEAYAwbsSsxa9as0Wuvvaa33npLd955503X+nw+paenq6WlRZLk9XrV29urzs7OiHUdHR1KTU0d8BxOp1NJSUkRGwAAGLuGPWIsy9Ljjz+un/zkJ3rzzTeVkZFxy/tcunRJbW1t8vl8kqTs7GzFxcWpoaHBXtPe3q5Tp04pLy9vuEcGAAAGGvaXk1avXq1XXnlFr776qhITE+33sLhcLo0fP149PT2qrKzU4sWL5fP59P777+vJJ59USkqKHnzwQXvtqlWrtG7dOiUnJ8vtdqu8vFxZWVn2p5UAAMDtbdgjZtOmTZKk/Pz8iP3btm3TypUrFRMTo5MnT2rHjh3q6uqSz+fTnDlztGvXLiUmJtrrN2zYoNjYWC1ZskRXr17V3LlztX37dsXExAz3yAAAwEDDHjGWZd30+Pjx47Vv375bnmfcuHGqrq5WdXX1cI0GAADGEL47CQAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkYgYAABgJCIGAAAYiYgBAABGImIAAICRiBgAAGAkIgYAABiJiAEAAEYiYgAAgJGIGAAAYCQiBgAAGImIAQAARiJiAACAkUZ9xPzoRz9SRkaGxo0bp+zsbP385z+P9kgAAGAUGNURs2vXLpWWluqpp57Sf/zHf+gLX/iCAoGAzp8/H+3RAABAlI3qiHnhhRe0atUqff3rX9fUqVP14osvKi0tTZs2bYr2aAAAIMpioz3AjfT29qqpqUlPPPFExP6CggIdPny43/pwOKxwOGzfDoVCkqTu7u4Rme96+Lcjct7R7o99PnneBo/nbGh43oaG523wbtfnTBqZ/8Z+dE7Lsm692BqlfvOb31iSrH//93+P2P+9733Puvvuu/utf/rppy1JbGxsbGxsbGNga2tru2UrjNorMR9xOBwRty3L6rdPkioqKlRWVmbfvn79uv77v/9bycnJA643VXd3t9LS0tTW1qakpKRoj2MMnrfB4zkbGp63oeF5G5qx+LxZlqXLly/L7/ffcu2ojZiUlBTFxMQoGAxG7O/o6FBqamq/9U6nU06nM2Lfpz71qZEcMaqSkpLGzD/YTxLP2+DxnA0Nz9vQ8LwNzVh73lwu1x+0btS+sTc+Pl7Z2dlqaGiI2N/Q0KC8vLwoTQUAAEaLUXslRpLKyspUXFysnJwc5ebmavPmzTp//rwee+yxaI8GAACibFRHzNKlS3Xp0iX9wz/8g9rb25WZmanXX39d6enp0R4tapxOp55++ul+L53h5njeBo/nbGh43oaG521obvfnzWFZf8hnmAAAAEaXUfueGAAAgJshYgAAgJGIGAAAYCQiBgAAGImIMcTBgwe1cOFC+f1+ORwO7dmzJ9ojjXpVVVX63Oc+p8TERHk8Hn3lK1/R2bNnoz3WqLdp0ybdc8899h/Pys3N1U9/+tNoj2WUqqoqORwOlZaWRnuUUa2yslIOhyNi83q90R7LCL/5zW/0N3/zN0pOTtaECRP02c9+Vk1NTdEe6xNHxBjiypUrmj59ujZu3BjtUYxx4MABrV69WkeOHFFDQ4N+97vfqaCgQFeuXIn2aKPanXfeqeeee07Hjx/X8ePHdf/99+uv/uqvdPr06WiPZoRjx45p8+bNuueee6I9ihGmTZum9vZ2ezt58mS0Rxr1Ojs7de+99youLk4//elP9e677+r5558f03+l/kZG9d+Jwf8LBAIKBALRHsMo9fX1Ebe3bdsmj8ejpqYmffGLX4zSVKPfwoULI25/73vf06ZNm3TkyBFNmzYtSlOZoaenRw8//LC2bNmiZ599NtrjGCE2NparL4P0/e9/X2lpadq2bZu976677oreQFHElRjcNkKhkCTJ7XZHeRJzXLt2TXV1dbpy5Ypyc3OjPc6ot3r1aj3wwAOaN29etEcxRktLi/x+vzIyMrRs2TK999570R5p1HvttdeUk5Ojhx56SB6PRzNmzNCWLVuiPVZUEDG4LViWpbKyMn3+859XZmZmtMcZ9U6ePKk//dM/ldPp1GOPPabdu3frL/7iL6I91qhWV1enEydOqKqqKtqjGGPWrFnasWOH9u3bpy1btigYDCovL0+XLl2K9mij2nvvvadNmzZp8uTJ2rdvnx577DGtXbtWO3bsiPZonzheTsJt4fHHH9cvf/lLHTp0KNqjGGHKlClqbm5WV1eX/uVf/kUrVqzQgQMHCJkbaGtr07e+9S298cYbGjduXLTHMcbvv0SelZWl3NxcffrTn9bLL7+ssrKyKE42ul2/fl05OTlav369JGnGjBk6ffq0Nm3apK997WtRnu6TxZUYjHlr1qzRa6+9prfeekt33nlntMcxQnx8vP78z/9cOTk5qqqq0vTp0/XDH/4w2mONWk1NTero6FB2drZiY2MVGxurAwcO6J/+6Z8UGxura9euRXtEIyQkJCgrK0stLS3RHmVU8/l8/f6HYurUqTp//nyUJooersRgzLIsS2vWrNHu3bu1f/9+ZWRkRHskY1mWpXA4HO0xRq25c+f2+1TN3/7t3+ozn/mMvvOd7ygmJiZKk5klHA7rzJkz+sIXvhDtUUa1e++9t9+fi/jVr351W345MhFjiJ6eHp07d86+3draqubmZrndbk2aNCmKk41eq1ev1iuvvKJXX31ViYmJCgaDkiSXy6Xx48dHebrR68knn1QgEFBaWpouX76suro67d+/v9+nvfD/EhMT+73XKiEhQcnJybwH6ybKy8u1cOFCTZo0SR0dHXr22WfV3d2tFStWRHu0Ue3v/u7vlJeXp/Xr12vJkiU6evSoNm/erM2bN0d7tE+eBSO89dZblqR+24oVK6I92qg10PMlydq2bVu0RxvVHnnkESs9Pd2Kj4+37rjjDmvu3LnWG2+8Ee2xjHPfffdZ3/rWt6I9xqi2dOlSy+fzWXFxcZbf77cWLVpknT59OtpjGeFf//VfrczMTMvpdFqf+cxnrM2bN0d7pKhwWJZlRamfAAAAhow39gIAACMRMQAAwEhEDAAAMBIRAwAAjETEAAAAIxExAADASEQMAAAwEhEDAACMRMQAAAAjETEAAMBIRAwAADASEQMAAIz0v/CWNXyP78X9AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes()\n",
    "uniques, counts = np.unique(randint_arr, return_counts=True)\n",
    "ax.bar(uniques, counts)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common attributes to examine a `ndarray`\n",
    "\n",
    "- `ndim`: as in number of dimensions\n",
    "- `shape`\n",
    "- `size`\n",
    "- `dtype`: as in data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(4,)\n",
      "4\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([5, 5, 6, 6])\n",
    "print(arr.ndim)\n",
    "print(arr.shape)\n",
    "print(arr.size)\n",
    "print(arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Different nicknames vs. different number of dimensions\n",
    "\n",
    "- Scalar: 0-dimension\n",
    "- Vector: 1-dimension\n",
    "- Matrix: 2-dimension\n",
    "- Tensor: 3-dimension or more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scalar, vector, matrix, and tensor\n",
    "\n",
    "![Imgur](https://i.imgur.com/81fM6Hf.png)\n",
    "\n",
    "Source: <https://dev.to/juancarlospaco/tensors-for-busy-people-315k>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566\n",
      "0\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "scalar = np.array(5566)\n",
    "print(scalar)\n",
    "print(scalar.ndim)\n",
    "print(scalar.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5566]\n",
      "1\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "vector = np.array([5566])\n",
    "print(vector)\n",
    "print(vector.ndim)\n",
    "print(vector.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 5]\n",
      " [6 6]]\n",
      "2\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[5, 5],\n",
    "                   [6, 6]])\n",
    "print(matrix)\n",
    "print(matrix.ndim)\n",
    "print(matrix.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[5 5]\n",
      "  [6 6]]\n",
      "\n",
      " [[5 5]\n",
      "  [6 6]]\n",
      "\n",
      " [[5 5]\n",
      "  [6 6]]]\n",
      "3\n",
      "(3, 2, 2)\n"
     ]
    }
   ],
   "source": [
    "tensor = np.array([[[5, 5],\n",
    "                    [6, 6]],\n",
    "                   [[5, 5],\n",
    "                    [6, 6]],\n",
    "                   [[5, 5],\n",
    "                    [6, 6]]])\n",
    "print(tensor)\n",
    "print(tensor.ndim)\n",
    "print(tensor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing/slicing arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indexing a 1d-array is the same as indexing a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From start to stop:\n",
      "55\n",
      "66\n",
      "56\n",
      "5566\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([55, 66, 56, 5566])\n",
    "print(\"From start to stop:\")\n",
    "print(arr[0])\n",
    "print(arr[1])\n",
    "print(arr[2])\n",
    "print(arr[arr.size - 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From stop to start:\n",
      "5566\n",
      "56\n",
      "66\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "print(\"From stop to start:\")\n",
    "print(arr[-1])\n",
    "print(arr[-2])\n",
    "print(arr[-3])\n",
    "print(arr[-arr.size])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Slicing a 1-d array is the same as slicing a list\n",
    "\n",
    "```python\n",
    "arr[start:stop:step]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 11 12 13 14 15 16 17 18 19]\n",
      "[10 12 14 16 18]\n",
      "[10 11 12 13 14]\n",
      "[15 16 17 18 19]\n",
      "[19 18 17 16 15 14 13 12 11 10]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10, 20)\n",
    "print(arr[::])   # default\n",
    "print(arr[::2])  # step=2\n",
    "print(arr[:5])   # stop=5, exclusive\n",
    "print(arr[5:])   # start=5, inclusive\n",
    "print(arr[::-1]) # step=-1, reverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Indexing/slicing a multi-dimensional array is more convenient with syntax `[i, j, ...]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 13).reshape(3, 4)\n",
    "print(arr)\n",
    "print(arr[1, 1])  # 6 is located at (1, 1)\n",
    "print(arr[2, -3]) # 10 is located at (2, -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using syntax `[i, j, ...]` is way more convenient than nested lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  6 10]\n",
      "[[ 2]\n",
      " [ 6]\n",
      " [10]]\n"
     ]
    }
   ],
   "source": [
    "print(arr[:, 1])\n",
    "print(arr[:, [1]]) # to keep dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Special indexing syntax with `ndarray`\n",
    "\n",
    "- Fancy indexing\n",
    "- Boolean indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is fancy indexing?\n",
    "\n",
    "> Passing a sequence of indexes in brackets instead of a single integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45 48 65 68 68 10 84 22 37 88]\n",
      "[45 65 37]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "arr = np.random.randint(1, 100, size=(10,))\n",
    "odd_indexes = [0, 2, 8]\n",
    "print(arr)\n",
    "print(arr[odd_indexes])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is boolean indexing?\n",
    "\n",
    "> Passing a sequence of booleans in brackets instead of an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45 65 37]\n"
     ]
    }
   ],
   "source": [
    "is_odd = [True, False, True, False, False, False, False, False, True, False]\n",
    "print(arr[is_odd])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True False False False False False  True False]\n",
      "[45 65 37]\n"
     ]
    }
   ],
   "source": [
    "is_odd = arr % 2 == 1\n",
    "print(is_odd)\n",
    "print(arr[is_odd])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Common array manipulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Reshaping an array with\n",
    "\n",
    "- `reshape(m, n, ...)`\n",
    "- `ravel()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "(9,)\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "print(arr)\n",
    "print(arr.shape)\n",
    "print(arr.reshape(3, 3))\n",
    "print(arr.reshape(3, 3).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## It is more convenient to specify `-1` in one of the dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 13)\n",
    "print(arr.reshape(3, -1))\n",
    "print(arr.reshape(-1, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `ravel()` method to convert n-dimensional arrays back to 1-dimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "2\n",
      "(9,)\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10).reshape(3, -1)\n",
    "print(arr.shape)\n",
    "print(arr.ndim)\n",
    "print(arr.ravel().shape)\n",
    "print(arr.ravel().ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The assignment of new object does not copy the array\n",
    "\n",
    "Instead, it creates a view for the original object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   1    2    3]\n",
      " [   4 5566    6]\n",
      " [   7    8    9]]\n",
      "[   1    2    3    4 5566    6    7    8    9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "mat = arr.reshape(3, 3)\n",
    "mat[1, 1] = 5566\n",
    "print(mat)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Specify `copy()` to explicitly copy the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   1    2    3]\n",
      " [   4 5566    6]\n",
      " [   7    8    9]]\n",
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "mat = arr.copy()\n",
    "mat = mat.reshape(3, 3)\n",
    "mat[1, 1] = 5566\n",
    "print(mat)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `np.concatenate()`  function to combine arrays\n",
    "\n",
    "- `axis=0`, combining vertically in default.\n",
    "- `axis=1`, combining horizontally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "arr_a = np.arange(1, 5).reshape(2, 2)\n",
    "arr_b = np.arange(5, 9).reshape(2, 2)\n",
    "print(arr_a)\n",
    "print(arr_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(np.concatenate([arr_a, arr_b]))         # default, axis=0\n",
    "print(np.concatenate([arr_a, arr_b], axis=1)) # axis=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `np.split()`  function to split arrays\n",
    "\n",
    "- `axis=0`, splitting vertically in default.\n",
    "- `axis=1`, splitting horizontally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 9).reshape(4, -1)\n",
    "upper_arr, lower_arr = np.split(arr, 2)\n",
    "print(upper_arr)\n",
    "print(lower_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [3]\n",
      " [5]\n",
      " [7]]\n",
      "[[2]\n",
      " [4]\n",
      " [6]\n",
      " [8]]\n"
     ]
    }
   ],
   "source": [
    "left_arr, right_arr = np.split(arr, 2, axis=1)\n",
    "print(left_arr)\n",
    "print(right_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1]\n",
      " [ 2  3]\n",
      " [ 4  5]\n",
      " [ 6  7]\n",
      " [ 8  9]\n",
      " [10 11]\n",
      " [12 13]]\n",
      "[[14 15]\n",
      " [16 17]\n",
      " [18 19]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(20).reshape(10, -1)\n",
    "upper_arr, lower_arr = np.split(arr, [7])\n",
    "print(upper_arr)\n",
    "print(lower_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## NumPy functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## NumPy provides abundant functions for fast computations\n",
    "\n",
    "- Universal functions(ufuncs)\n",
    "- Aggregate functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a universal function?\n",
    "\n",
    "> A vectorized wrapper for a function that takes a fixed number of specific inputs and produces a fixed number of specific outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[ 0  1  4  9 16 25 36 49 64 81]\n"
     ]
    }
   ],
   "source": [
    "# np.power\n",
    "arr = np.arange(10)\n",
    "print(arr)\n",
    "print(np.power(arr, 2)) # arr**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01\n",
      " 5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03\n",
      " 2.98095799e+03 8.10308393e+03]\n"
     ]
    }
   ],
   "source": [
    "# np.exp\n",
    "print(np.exp(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947\n",
      " 1.94591015 2.07944154 2.19722458 2.30258509]\n"
     ]
    }
   ],
   "source": [
    "# np.log\n",
    "arr = np.arange(1, 11)\n",
    "print(arr)\n",
    "print(np.log(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## NumPy offers a way to define ufuncs by ourselves\n",
    "\n",
    "Using `vectorize` to turn a scalar function into a universal function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5566"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# abs as a scalar function\n",
    "abs(-5566)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bad operand type for abs(): 'list'\n"
     ]
    }
   ],
   "source": [
    "# abs as a scalar function\n",
    "try:\n",
    "    lst = [-5, -5, -6, -6]\n",
    "    print(abs(lst))\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.vectorize'>\n",
      "[5 5 6 6]\n"
     ]
    }
   ],
   "source": [
    "abs_ufunc = np.vectorize(abs)\n",
    "lst = [-5, -5, -6, -6]\n",
    "print(type(abs_ufunc))\n",
    "print(abs_ufunc(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is an aggregate function?\n",
    "\n",
    "> A function where the values of multiple rows are grouped together to form a single summary value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## There are 2 characteristics in NumPy's aggregate functions\n",
    "\n",
    "1. Aggregate along specific axis.\n",
    "2. Similar function names for array with Not a Number values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "[18 21 24 27 30]\n",
      "[[15]\n",
      " [40]\n",
      " [65]]\n"
     ]
    }
   ],
   "source": [
    "# Aggregate along specific axis\n",
    "mat = np.arange(1, 16).reshape(3, 5)\n",
    "print(np.sum(mat))\n",
    "print(np.sum(mat, axis=0, keepdims=False)) # column sums\n",
    "print(np.sum(mat, axis=1, keepdims=True))  # row sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Not a Number(NaN) is a member of NumPy constants\n",
    "\n",
    "Source: <https://numpy.org/doc/stable/reference/constants.html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.nan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. nan]\n",
      "nan\n",
      "105.0\n"
     ]
    }
   ],
   "source": [
    "# Similar function names for array with Not a Number values\n",
    "arr = np.arange(1, 16, dtype=float)\n",
    "arr[-1] = np.nan\n",
    "print(arr)\n",
    "print(np.sum(arr))\n",
    "print(np.nansum(arr))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 4
}