numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert block alert-info alert\">\n",
    "\n",
    "# <center> Scientific Programming in Python\n",
    "\n",
    "## <center>Karl N. Kirschner<br>Bonn-Rhein-Sieg University of Applied Sciences<br>Sankt Augustin, Germany\n",
    "\n",
    "# <center> NumPy: NUMerical PYthon\n",
    "\n",
    "**Source**: https://numpy.org/doc/stable/\n",
    "<br><br>\n",
    "\n",
    "\n",
    "Numpy is the foundation for\n",
    "- Pandas\n",
    "- Matplotlib\n",
    "- Scikit-learn\n",
    "- PyTorch\n",
    "\n",
    "\n",
    "- Excels at large **arrays** of data (i.e., VERY efficient)\n",
    "    - RAM usage, and thus\n",
    "    - Speed\n",
    "\n",
    "\n",
    "- Array: an n-dimensional array (i.e., NumPy's name: ndarray):\n",
    "    - a collections of values that have 1 or more dimensions\n",
    "    - 1D array --> vector\n",
    "    - 2D array --> matrix\n",
    "    - nD array --> tensor\n",
    "\n",
    "\n",
    "- All array data must be the same (i.e., homogeneous)\n",
    "\n",
    "\n",
    "- Can perform computations on entire arrays without the need of loops\n",
    "\n",
    "\n",
    "- Contains some nice mathematical funtions/tools (e.g., data extrapolation) - will be covered in the SciPy lecture\n",
    "\n",
    "\n",
    "- Does not come by default with Python - must be installed\n",
    "\n",
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "**Comparisons to a regular list**:\n",
    "1. Both are a container for items/elements\n",
    "2. Numpy allows for faster items/elements getting (allows for faster mathematics), but\n",
    "3. List are faster to insert new and remove existing items/elements\n",
    "\n",
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "#### Key Concept for Numpy\n",
    "1. Each element in an array must be the same type (e.g., floats)\n",
    "    - allows for efficient usage of RAM\n",
    "    - NumPy always knows what the content of the array is\n",
    "\n",
    "\n",
    "2. **Vectorizing operations**<br>\n",
    "    \"This practice of replacing explicit loops with array expressions is commonly referred to as vectorization.\"\n",
    "    - source: https://www.oreilly.com/library/view/python-for-data/9781449323592/ch04.html\n",
    "    - do math operations all at once (i.e., does it one time only) on an ndarray\n",
    "\n",
    "\n",
    "3. Integrates with C, C++ and Fortran to improve performance\n",
    "    - In this sense, NumPy is  an intermediary between these low-level libraries and Python\n",
    "\n",
    "\n",
    "4. The raw array data is put into a contiguous (and fixed) block of RAM\n",
    "    - good at allocating space in RAM for storing the ndarrays\n",
    "    \n",
    "\n",
    "**More Information** for what is happening \"under-the-hood\": https://numpy.org/doc/stable/dev/internals.html#numpy-internals\n",
    "\n",
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "**Citing Numpy**: (https://numpy.org/citing-numpy/)\n",
    "\n",
    "Harris, C.R., Millman, K.J., van der Walt, S.J. et al. Array programming with NumPy. Nature 585, 357–362 (2020).\n",
    "\n",
    "@Article{         harris2020array,  \n",
    " title         = {Array programming with {NumPy}},  \n",
    " author        = {Charles R. Harris and K. Jarrod Millman and St{\\'{e}}fan J.\n",
    "                 van der Walt and Ralf Gommers and Pauli Virtanen and David\n",
    "                 Cournapeau and Eric Wieser and Julian Taylor and Sebastian\n",
    "                 Berg and Nathaniel J. Smith and Robert Kern and Matti Picus\n",
    "                 and Stephan Hoyer and Marten H. van Kerkwijk and Matthew\n",
    "                 Brett and Allan Haldane and Jaime Fern{\\'{a}}ndez del\n",
    "                 R{\\'{i}}o and Mark Wiebe and Pearu Peterson and Pierre\n",
    "                 G{\\'{e}}rard-Marchant and Kevin Sheppard and Tyler Reddy and\n",
    "                 Warren Weckesser and Hameer Abbasi and Christoph Gohlke and\n",
    "                 Travis E. Oliphant},  \n",
    " year          = {2020},  \n",
    " month         = sep,  \n",
    " journal       = {Nature},  \n",
    " volume        = {585},  \n",
    " number        = {7825},  \n",
    " pages         = {357--362},  \n",
    " doi           = {10.1038/s41586-020-2649-2},  \n",
    " publisher     = {Springer Science and Business Media {LLC}},  \n",
    " url           = {https://doi.org/10.1038/s41586-020-2649-2}  \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## For extra information given within the lectures\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "\n",
    "def set_code_background(color: str):\n",
    "    ''' Set the background color for code cells.\n",
    "\n",
    "        Source: psychemedia via https://stackoverflow.com/questions/49429585/\n",
    "                how-to-change-the-background-color-of-a-single-cell-in-a-jupyter-notebook-jupy\n",
    "\n",
    "        To match Jupyter's dev class colors:\n",
    "            \"alert alert-block alert-warning\" = #fcf8e3\n",
    "\n",
    "        Args:\n",
    "            color: HTML color, rgba, hex\n",
    "    '''\n",
    "\n",
    "    script = (\"var cell = this.closest('.code_cell');\"\n",
    "              \"var editor = cell.querySelector('.input_area');\"\n",
    "              f\"editor.style.background='{color}';\"\n",
    "              \"this.parentNode.removeChild(this)\")\n",
    "    display(HTML(f'<img src onerror=\"{script}\">'))\n",
    "\n",
    "\n",
    "set_code_background(color='#fcf8e3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import timeit\n",
    "\n",
    "print(np.__version__)\n",
    "print(pd.__version__)\n",
    "\n",
    "#%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## N-dimensional array object (i.e. ndarray)\n",
    "\n",
    "Let's create two objects:\n",
    "1. a regular list\n",
    "2. a numpy array via **A**rray **RANGE** (`arange`): https://numpy.org/doc/stable/reference/generated/numpy.arange.html), and\n",
    "\n",
    "\n",
    "Then we can find demonstrate which is faster using the timeit library.\n",
    "\n",
    "- timeit (to time code for performance): https://docs.python.org/3/library/timeit.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = list(range(100000))\n",
    "print(my_list)\n",
    "print(type(my_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array = np.arange(100000)\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's multiply containers by 2, and do that math 10000 times.\n",
    "\n",
    "We need two \"callable\" functions for using `timeit` library.\n",
    "\n",
    "**Disclaimer** - I am not properly formulating the functions below (e.g., including typing, context, etc.) in order to simplify the content for learning purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_multiply(test_list):\n",
    "    return test_list*2\n",
    "\n",
    "\n",
    "def numpy_multiply(test_array):\n",
    "    return test_array*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### timeit\n",
    "https://docs.python.org/3/library/timeit.html\n",
    "\n",
    "An very good library for testing code performance.\n",
    "\n",
    "Multiply containers by 2, and do that math 10000 times.\n",
    "\n",
    "For `timeit`, we can call our function through the use of a `lambda` (i.e., anonymous) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeit.timeit(lambda:list_multiply(my_list), number=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeit.timeit(lambda:numpy_multiply(my_array), number=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Result** - the use of Numpy arrays is significantly faster than that for lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "## Extra Information\n",
    "\n",
    "### 1. `lambda` functions\n",
    "- anonymous functions for quick tasks\n",
    "- https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions\n",
    "\n",
    "### 2. `time`\n",
    "- an alternative timing library\n",
    "- https://docs.python.org/3/library/time.html\n",
    "\n",
    "### 3. `_` - underscore\n",
    "\n",
    "Notice how the underscore symbol will be used above. There are several instances where one can use `_` in Python (see https://www.datacamp.com/tutorial/role-underscore-python), but in the below example it is employed\n",
    "\n",
    "1. to represent a variable that is not used further."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_code_background(color='#fcf8e3')\n",
    "\n",
    "import time\n",
    "\n",
    "\n",
    "## Regular List\n",
    "start_time = time.process_time()\n",
    "\n",
    "for _ in range(10000):\n",
    "    list_multiply(my_list)\n",
    "\n",
    "stop_time = time.process_time()\n",
    "\n",
    "print(f\"List timing: {stop_time - start_time:0.1f} seconds\")\n",
    "\n",
    "\n",
    "## Numpy Array\n",
    "start_time = time.process_time()\n",
    "\n",
    "for _ in range(10000):\n",
    "    numpy_multiply(my_array)\n",
    "\n",
    "stop_time = time.process_time()\n",
    "\n",
    "print(f\"Numpy timing: {stop_time - start_time:0.1f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "## Creating Numpy Arrays from Scratch\n",
    "\n",
    "In the following we will create several arrays that we can uses throughout this lecture.\n",
    "\n",
    "### Conversion from lists\n",
    "Let's create 2 data lists with 5 data points each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_1 = [6, 1, 6, 7, 9]\n",
    "list_2 = [3, 5, 4, 2, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now create two arrays, with **shapes** of **(5,)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1 = np.array(list_1)\n",
    "array_2 = np.array(list_2)\n",
    "\n",
    "display(array_1)\n",
    "display(array_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new **nested list**, and then **convert** the nested lists to a **Numpy array**, with a **shape** of **(2, 5)**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_3 = [list_1, list_2]\n",
    "list_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3 = np.array(list_3)\n",
    "array_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Put `array_3` to memory - we will use it later in the lecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array shapes and dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1D shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that we created `array_1` via:\n",
    "\n",
    "`list_1 = [6, 1, 6, 7, 9]`\n",
    "\n",
    "`array_1 = np.array(list_1)`\n",
    "\n",
    "Since we have it as a Numpy array, we can get's it shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(array_1)\n",
    "\n",
    "array_1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: this would change if you added **double brackets** (i.e., a nested list) to the above declaration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example = [[6, 1, 6, 7, 9]]\n",
    "\n",
    "test = np.array(example)\n",
    "\n",
    "display(test)\n",
    "\n",
    "test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### nD shape\n",
    "\n",
    "Use `array_3` as an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data types\n",
    "\n",
    "Describes what **type** that the **items** are **within** an array.\n",
    "\n",
    "- https://numpy.org/doc/stable/reference/arrays.dtypes.html\n",
    "- https://numpy.org/doc/stable/user/basics.types.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reminder of using `type` to figure out what the object is that you are dealing with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(array_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "## More on creating new arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An array that contains the same number - `np.fill`\n",
    "\n",
    "Create an array with a shape of **(3, 5)**, and **fill** it with an approximate **pi** value (e.g., 3.14):\n",
    "- <font color='dodgerblue'>1 ndarray</font>, containing\n",
    "- <font color='dodgerblue'>3 lists</font>, with\n",
    "- each containing <font color='dodgerblue'>5 ca. pi</font> values\n",
    "\n",
    "\n",
    "- `np.full`: https://numpy.org/devdocs/reference/generated/numpy.full.html#numpy.full\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.full((3, 5), 3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An array of integers - `np.arange`\n",
    "\n",
    "Create an array with a shape of **(1, 30)** from **-10 to 50** using a **stepping size of 2**\n",
    "\n",
    "(similar to built-in `range` function)\n",
    "\n",
    "- `np.arrange`: https://numpy.org/doc/stable/reference/generated/numpy.arange.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(-10, 52, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An array of floats - `np.linspace`\n",
    "\n",
    "Create an array wiha shape of **(10,)** that contains **10 evenly spaced values** between **-1 and 1**\n",
    "\n",
    "- `np.linspace`: https://numpy.org/devdocs/reference/generated/numpy.linspace.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linspace(-1, 1, num=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "## Extra Information\n",
    "\n",
    "### 1. Creating an array of nested lists containing floats\n",
    "\n",
    "Source: Fırat Korkmaz, \"Is there a multi-dimensional version of arange/linspace in numpy?\" https://stackoverflow.com/questions/32208359/is-there-a-multi-dimensional-version-of-arange-linspace-in-numpy/55675355#55675355. Accessed on Nov. 15, 2022.\n",
    "<br><br>\n",
    "\n",
    "\n",
    "Create an array with 15 nested lists containing 2 items each (i.e., an array with shape (15,2))\n",
    "- the first (i.e. `(1.0, 2.0)`) and last (i.e. `(10.0, 20.0)`) tuple specifies the values for the first and last list (indexed sequentially), with the indexes of the middle lists filled with values that range between the respective values (i.e. from 1.0--10.0 and from 2.0--20.0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_code_background(color='#fcf8e3')\n",
    "\n",
    "np.linspace((1.0, 2.0), (10.0, 20.0), num=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "For further illustration...\n",
    "\n",
    "Create an array with 15 nested lists containing 3 items each (i.e., an array with shape (15,3)):\n",
    "\n",
    "Notice for each nested list:\n",
    "- index 0 ranges from 1.0--10.0\n",
    "- index 1 ranges from 1.5--15.0\n",
    "- index 2 ranges from 2.0--20.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_code_background(color='#fcf8e3')\n",
    "\n",
    "np.linspace((1.0, 1.5, 2.0), (10.0, 15.0, 20.0), num=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "#### An array of random numbers - `np.random.random_sample`\n",
    "\n",
    "Create array with random, but continuous distributed, values between 0 and 1\n",
    "- random.random_sample function: https://numpy.org/doc/stable/reference/random/generated/numpy.random.random_sample.html#numpy.random.random_sample\n",
    "\n",
    "An array with a shape of **(3,)**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.random_sample(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An array with a shape of **(3, 4)**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.random_sample((3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "## Accessing arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One dimensional array\n",
    "Let's look at the **(5,)** `array_1` from above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing the fourth item position (i.e., at an index of 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A multidimensional array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now look at a 2D array (i.e., the **(2, 5)** array_3 from above)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access the fist sublist from the 2D array\n",
    "\n",
    "i.e., array([<font color=\"dodgerblue\">**[6,  1,  6,  7,  9]**</font>, [-5,  0,  2,  4,  3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access the second sublist, fourth item (i.e., list positions 1 and then item position 3)\n",
    "\n",
    "i.e., array([[6,  1,  6,  7,  9], [3, 5, 4, <font color=\"dodgerblue\">**2**</font>,  8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[1, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing an array\n",
    "\n",
    "Demo using `array_3[0]` and slicing via\n",
    "- [0:1]\n",
    "- [1:2]\n",
    "- [0:2]\n",
    "- [0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice to obtain the first nested array (same as `array_3[0]`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[0:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice to obtain the second nested array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[1:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice to obtain the entire array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notice** that we can specify upper numbers that go beyond the array, without giving an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[0:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But a better way would be to give just the array, since it **removes possible confusion** over the unclear slicing (i.e., **concise coding**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "## Filter (search) for elements\n",
    "\n",
    "- Numpy arrays <font color='dodgerblue'>are not</font> index like a list, so the more typical filtering/searching methods are not available (e.g. list comprehension)\n",
    "- `numpy.where` is used instead\n",
    "    - https://numpy.org/doc/stable/reference/generated/numpy.where.html\n",
    "\n",
    "**Reminder** - filtering a **regular list**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_4 = [-6,  1,  6,  7,  9, -5,  0,  2,  4,  3]\n",
    "\n",
    "[number for number in list_4 if number < 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "## Extra Information\n",
    "\n",
    "### 1. list comprehension\n",
    "- List comprehension are a Pythonic way to create a list using an iterative structure on one line\n",
    "- This approach is more concise, but sometimes it looses readability\n",
    "- https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions\n",
    "\n",
    "The above \"list comprehension\" code to filter `list_4` replaces the following more traditional code structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_code_background(color='#fcf8e3')\n",
    "\n",
    "filtered_list = []\n",
    "\n",
    "for number in list_4:\n",
    "    if number < 0:\n",
    "        filtered_list.append(number)\n",
    "\n",
    "filtered_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:1.5px dashed gray\"></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, how would we **filter** the `array_3` Numpy array for values less than 6\n",
    "\n",
    "- **filter** using `np.where`: https://numpy.org/doc/stable/reference/generated/numpy.where.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_items = np.where(array_3 < 6)\n",
    "\n",
    "array_3[filtered_items]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notice** that we obtained a 1 dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3[filtered_items].ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "### Flatten a multidimensional array & conversion to a list\n",
    "\n",
    "Collapsed a nD array into 1D:\n",
    "\n",
    "- `ndarray.flatten()`: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flatten.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3.flatten()\n",
    "# testing = array_3.flatten()\n",
    "# testing.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the results to a list:\n",
    "\n",
    "- 'ndarray.tolist()`: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tolist.html?highlight=tolist\n",
    "\n",
    "1D Numpy array to a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1.tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nD Numpy array to a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3.flatten().tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "## Joining arrays\n",
    "\n",
    "#### Multiple arrays with the <font color='dodgerblue'>same dimensions</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Concatenate**: https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html\n",
    "- Pass a `list` of `np.array`\n",
    "- Specify which axis you want to combine along\n",
    "\n",
    "\n",
    "- `axis=0`:\n",
    "    - Multiple **nD arrays**, along their first axis (i.e. <font color='dodgerblue'>**axis=0**</font>) - conceptually, this is like <font color='dodgerblue'> **adding more rows** </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_long = np.concatenate([array_1, array_2], axis=0)\n",
    "display(array_long)\n",
    "display(array_long.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, we can present a Numpy array a bit more aesthetically pleasing.\n",
    "\n",
    "Use **Pandas** to print out the table in a more human (e.g., a natural scientist) readable form"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(array_long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_big = np.concatenate([array_3, array_3, array_3], axis=0)\n",
    "\n",
    "display(array_big.shape)\n",
    "\n",
    "pd.DataFrame(array_big)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `axis=1`:\n",
    "    - Multiple **nD arrays**, along their second axis (i.e. <font color='dodgerblue'>**axis=1**</font>) - conceptually, this like <font color='dodgerblue'>**adding more columns**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_long = np.concatenate([array_3, array_3, array_3], axis=1)\n",
    "\n",
    "display(array_long.shape)\n",
    "\n",
    "pd.DataFrame(array_long)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiple arrays with <font color='dodgerblue'>inconsistent (i.e., *mixed*) dimensions</font>\n",
    "- <font color='dodgerblue'>must pay attention to the dimensions</font>\n",
    "\n",
    "\n",
    "- vertical stacked\n",
    "- horizontal stacked"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Vertical stacked\n",
    "- nD arrays must be (x, <font color='dodgerblue'>N</font>) and (y, <font color='dodgerblue'>N</font>) where <font color='dodgerblue'>N is the same value</font>\n",
    "\n",
    "Below we will combine `array_3` (shape: (2, 5)) with `array_big` (shape: (6, 5))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi_array = np.full((2, 5), 3.14)\n",
    "pi_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_big"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_vstack = np.vstack([pi_array, array_big])\n",
    "array_vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_vstack.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now logically, we can also do this with our array_1 (shape **(5,)**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_vstack = np.vstack([array_1, array_3])\n",
    "array_vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_vstack.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>When would this not work?</font>\n",
    "\n",
    "Demo when the arrays (ie. **(x, N)** and **(y, N)**) have **<font color='red'>different N</font> values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_4 = np.array([[99, 99, 99, 99]])\n",
    "array_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(array_3.shape)\n",
    "display(array_4.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.vstack([array_3, array_4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Horizontal Stacked\n",
    "- nD arrays must be (<font color='dodgerblue'>M</font>, x) and (<font color='dodgerblue'>M</font>, y) where <font color='dodgerblue'>M is the same value</font>\n",
    "\n",
    "Using our examples, we need a new array that has (2, x) values since array_3 is (2, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_5 = np.array([[99], [99]])\n",
    "array_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(array_3.shape)\n",
    "display(array_5.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_hstack = np.hstack([array_5, array_3])\n",
    "array_hstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_hstack.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>When would this not work?</font>\n",
    "\n",
    "Demo when the arrays (ie. **(M, x)** and **(M, y)**) have **<font color='red'>different M</font> values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_big"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(array_4.shape)\n",
    "print(array_big.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_hstack = np.hstack([array_4, array_big])\n",
    "array_hstack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "## Math with ndarrays\n",
    "\n",
    "https://numpy.org/doc/stable/reference/routines.math.html\n",
    "\n",
    "\n",
    "- `np.add` and `np.subtract`\n",
    "- `np.multiple` and `np.divide`\n",
    "- `np.power`\n",
    "- `np.negative` (multiply by -1)\n",
    "\n",
    "\n",
    "#### Math performed on a single array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Method 1: Numpy's function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.add(array_3, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Method 2: using Python3's built-in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3 + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**\n",
    "- Using the Numpy vs. built-in functions doesn't matter **too much** in this example since we are performing the action on a small numpy array.\n",
    "\n",
    "- Nevertheless, you should try to maximize the use of Numpy functions when speed is important."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "repeat = 2000000 # 2 million"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeit.timeit(lambda:np.add(array_3, 5), number=repeat) # Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeit.timeit(lambda:array_3 + 5, number=repeat) # Built-in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Math operations between arrays\n",
    "- math operations between **equal sized arrays** is done via **element-wise**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Add and subtract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.add(array_3, array_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.subtract(array_3, array_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Multiplication, Division and Power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.multiply(array_3, array_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.divide(1, array_3) ## i.e., 1/array_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.power(array_3, 3) ## i.e., item^3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Absolute values\n",
    "\n",
    "1. Use a Numpy function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "large_array = np.full((100, 5), -3.14)\n",
    "large_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.absolute(large_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeit.timeit(lambda: np.absolute(large_array), number=repeat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Python3's built-in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeit.timeit(lambda:abs(large_array), number=repeat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that sometimes, depending on the shape of the array, the built-in `abs` function has the edge over NumPy (at least on my local machine)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trigonometric\n",
    "- np.sin()\n",
    "- np.cos()\n",
    "- np.arcsin()\n",
    "- etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trigonometry on a single input value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sin(-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trigonometry on a NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sin(array_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exponents and logarithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.exp2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_sqr = np.exp2(x)        # i.e., 2^2 and 2^3\n",
    "example_pow10 = np.power(10, x) # i.e., 10^2 and 10^3\n",
    "example_exp = np.exp(x)         # i.e., e^2 and e^3\n",
    "\n",
    "print(f'x     = {x}')\n",
    "print(f'2^x   = {example_sqr}') # Note: possible bug: no commas (see example_sqr below)\n",
    "print(f'10^x  = {example_pow10}')\n",
    "print(f'e^x   = {example_exp}')\n",
    "\n",
    "example_sqr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='dodgerblue'>Recall: you **reverse** the **exponential** calculations using **log** functions.</font>\n",
    "\n",
    "Taking the above exponential output and operate on them using log functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"log2(x)  = {np.log2(example_sqr)}\")\n",
    "print(f\"log10(x) = {np.log10(example_pow10)}\")\n",
    "print(f\"ln(x)    = {np.log(example_exp)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_3 == 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "## Extra Information\n",
    "\n",
    "### A more complex, practical example\n",
    "\n",
    "**Temperature conversion**: Celsius to Fahrenheit\n",
    "\n",
    "Data set: Average temperature in Bonn throughout the calendar year (i.e., January ---> December)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_celsius = [2.0, 2.8, 5.7, 9.3, 13.3, 16.5, 18.1, 17.6, 14.9, 10.5, 6.1, 3.2]\n",
    "\n",
    "array_celsius = np.array(data_celsius)\n",
    "\n",
    "array_celsius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_fahrenheit = array_celsius*(9/5) + 32\n",
    "\n",
    "array_fahrenheit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<font color='dodgerblue'>Visualize</font> the resulting Numpy array using <font color='dodgerblue'>Pandas'</font> built-in function:\n",
    "- convert `np.array` to `pd.DataFrame`\n",
    "- visualization is often important for understanding data better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_celsius = pd.DataFrame(array_celsius, columns=['celsius'])\n",
    "df_fahrenheit = pd.DataFrame(array_fahrenheit, columns=['Fahrenheit'])\n",
    "\n",
    "df_temperature = pd.concat([df_celsius, df_fahrenheit], axis=1)\n",
    "\n",
    "df_temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperature_plot = df_temperature.plot(kind='line', fontsize=16, legend=True)\n",
    "\n",
    "temperature_plot.set_title('Celsius vs. Fahrenheit Temperature', fontsize=16)\n",
    "temperature_plot.set_xlabel('Calendar Month', fontsize=16)\n",
    "temperature_plot.set_ylabel('Temperature', fontsize=16)\n",
    "temperature_plot.legend(loc='upper left')\n",
    "\n",
    "temperature_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "## Numpy statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy's random number generators\n",
    "\n",
    "- generators that uses distribution (e.g., geometric, normal, binomial)\n",
    "    - https://numpy.org/doc/stable/reference/random/generator.html\n",
    "\n",
    "\n",
    "Two examples will be given as demonstrations.\n",
    "\n",
    "##### <font color='dodgerblue'>Geometric distribution</font> (a.k.a. sequence) \n",
    "- a sequence of numbers that follow a common (consistent) ratio.\n",
    "\n",
    "- https://numpy.org/doc/stable/reference/random/generated/numpy.random.geometric.html\n",
    "\n",
    "**Examples**\n",
    "- 2, 4, 8, 16 ...  (common ratio of 2)\n",
    "- 2, 6, 18, 54 ... (common ratio of 3)\n",
    "- 20, 10, 5, 2.5 ... (common ratio of 1/2)\n",
    "\n",
    "**Probability distribution** for something that has **2 outcomes (success/failure)** tend to follow a **geometric distribution**.\n",
    "\n",
    "Example systems\n",
    "- flipping of a coin (head/tails)\n",
    "- basketball free throws (make it/miss it)\n",
    "\n",
    "\n",
    "Generate a random distribution that contains **100 attempts** (e.g., meeting people) that have a success probability of **60%** (e.g., that they have brown eyes), where the distribution itself is governed by a **geometric distribution**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_size = 100\n",
    "\n",
    "random_geom = np.random.geometric(0.60, size=my_size)\n",
    "random_geom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many attempts were successful (i.e., items within array that are equal to 1)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(random_geom == 1).sum() / my_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: the probability will go closer to 60% as the size increases - try setting my_size to 1000, 10000, 100000."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <font color='dodgerblue'>Normal distribution</font>  (a.k.a. Gaussian)\n",
    "- a distribution that is symmetric about a mean\n",
    "\n",
    "\n",
    "- https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html\n",
    "\n",
    "Create a **(25, 3)** array (e.g., 25 data points collected by 3 sensors) that have a **Gaussian distributed** random values (e.g., temperatures):\n",
    "\n",
    "- **mean=10.0** and\n",
    "- **standard deviation=0.1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_data = np.random.normal(10.0, 0.1, (25, 3))\n",
    "\n",
    "random_data_df = pd.DataFrame(random_data, columns=['Sensor 1', 'Sensor 2', 'Sensor 3'])\n",
    "\n",
    "random_data_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize (i.e., plot) the random data array for clarity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fontsize = 14\n",
    "\n",
    "random_data_df.plot(kind='line',\n",
    "                    xlabel=\"Data Point\", ylabel=\"Temperature (Celsius)\",\n",
    "                    fontsize=my_fontsize, legend=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look at its distribution (via Kernel Density Estimate plot):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kde_graph = random_data_df.plot(kind='kde', fontsize=my_fontsize, legend=True)\n",
    "\n",
    "kde_graph.set_xlabel(\"Temperature (Celsius)\", fontsize=my_fontsize)\n",
    "kde_graph.set_ylabel(\"Occurance\", fontsize=my_fontsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also prove to ourselves that our mean is close to 10 and the standard deviation is close to 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(random_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(random_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In science, the mean and standard deviations are often presented together in the following way:\n",
    "\n",
    "mean $\\pm$ standard deviation\n",
    "\n",
    "$ 9.96 \\pm 0.43 $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<hr style=\"border:1.5px dashed gray\"></hr>\n",
    "\n",
    "## Extra Information\n",
    "\n",
    "### 1. Details concerning standard deviation and variance\n",
    "\n",
    "Why can't I reproduce results using spreadsheets or Matlab?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, 2, 4, 5, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "#### variance\n",
    "- Libreoffice spreadsheet give a variance of '=VAR(1,2,4,5,8)' of 7.5\n",
    "- I believe Matlab also gives 7.5\n",
    "\n",
    "Using the statistics's library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics.variance(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "These above results are actually termed 'the sample variance.'\n",
    "\n",
    "However, if you use NumPy by simply typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.var(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "In this case there is a \"hidden\" variable called `ddof` (\"Delta Degrees of Freedom\")\n",
    "    - the denomenator is divided by 'N -ddof'\n",
    "\n",
    "https://numpy.org/doc/1.18/reference/generated/numpy.var.html?highlight=variance\n",
    "\n",
    "- population: \"ddof=0 provides a maximum likelihood estimate of the variance for normally distributed variables\"\n",
    "- sample: \"ddof=1 provides an unbiased estimator of the variance of a hypothetical infinite population\"\n",
    "\n",
    "The same is true for standard deviation.\n",
    "\n",
    "Population variance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.var(data, ddof=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "Sample variance (always larger than the population variance):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.var(data, ddof=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "Standard deviation demo\n",
    "\n",
    "**Libreoffice** gives '=stdev(1,2,4,5,8)' of **2.7386127875**\n",
    "\n",
    "And the **Statistics library** gives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics.stdev(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "Numpy's sample standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(data, ddof=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "Numpy's population standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(data, ddof=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:1.5px dashed gray\"></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### And finally, some weirdness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following should provide a **mean value** of **1.0**\n",
    "\n",
    "(i.e., **sum** of the numbers is **4** and then **divide** by **4**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers_list = [1e30, 1, 3, -1e30]\n",
    "\n",
    "statistics.mean(numbers_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(numbers_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This appears to be coming from the data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(numbers_list).dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://numpy.org/doc/stable/reference/generated/numpy.mean.html\n",
    "\n",
    "`numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)`\n",
    "\n",
    "`dtype data-type, optional`\n",
    "- **Type to use in computing the mean**.\n",
    "    - For **integer** inputs, the **default** is **float64**\n",
    "    - For **floating point** inputs, it is the same as the **input dtype**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(numbers_list, dtype=np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(numbers_list, dtype=np.int8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take home message**: you should always take a look at NumPy's manual to make sure you are doing what you think you are doing\n",
    "\n",
    "- keep an eye out for default settings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border:2px solid gray\"></hr>\n",
    "\n",
    "Additional resource to further learn and test your knowledge: https://github.com/rougier/numpy-100\n",
    "\n",
    "<hr style=\"border:2px solid gray\"></hr>"
   ]
  }
 ],
 "metadata": {
  "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}