02_tools-and-packages/02_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "[Table of contents](../toc.ipynb)\n",
    "\n",
    "<img src=\"https://github.com/numpy/numpy/raw/master/doc/source/_static/numpy_logo.png\" alt=\"Numpy\" width=\"350\" align=\"right\">\n",
    "\n",
    "# NumPy\n",
    "\n",
    "* Numpy is probably the most applied and used Python package. Almost any scientific package builds on numpy.\n",
    "* Numpy provides multidimensional array objects, and allows to deal with matrix computations.\n",
    "* Add to this, numpy provides interfaces to C and C++.\n",
    "* Numpy's methods are very efficient implemented.\n",
    "* Please find numpy's documentation here [https://numpy.org/](https://numpy.org/).\n",
    "* Numpy is one building block of Python's scientific eco system. If you want to know more about scientific Python, consult the scipy lecture notes on [https://scipy-lectures.org/](https://scipy-lectures.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Numpy import\n",
    "\n",
    "First, let us import numpy, create a vector and compare this with a Python list, which ships per default with Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list = range(0, 8000)\n",
    "a_np_array = np.arange(0, 8000) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now, let us compare how long it takes to loop over the list and over the numpy array with `%timeit` magic command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "412 µs ± 16.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [i + 3 for i in a_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.67 µs ± 40.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit a_np_array + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Numpy is much faster than the list and the code of numpy is easier to read!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Create arrays manually\n",
    "\n",
    "* The \"manual\" syntax to create a numpy array is \n",
    "  * `np.array([x, x])` for one dimensional arrays \n",
    "  * and `np.array([[x, x], [x, x]])` for multidimensional arrays.\n",
    "* Add to this, various functions like `np.ones()`, `np.eye()`, `np.arrange()`, `np.linspace()`, and many more create specific arrays which are often required in matrix computing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a one dimensional array\n",
    "a = np.array([0, 1, 2, 3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# here two dimesions\n",
    "b = np.array([[0, 1], [2, 3]])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "# now check their shapes\n",
    "print(a.shape)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic attributes\n",
    "\n",
    "In addition to `ndarray.shape`, numpy arrays contain the attributes:\n",
    "* `ndarray.ndim` which is the dimension of the array,\n",
    "* `ndarray.size` which is the number of elements in the array,\n",
    "* `ndarray.dtype` which is the type of the array (int16, int32, uint16, ..., the default is int64, or float64)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can also specify the type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3], dtype=uint16)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3], dtype=np.uint16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More array constructors\n",
    "\n",
    "### np.arange\n",
    "\n",
    "* Create arrays with start, stop, and step size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# liniear growing array, zero based\n",
    "np.arange(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.arange with start, end, step call\n",
    "np.arange(0, 12, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### np.linspace\n",
    "\n",
    "* Create equidistant arrays with start, stop, and number of points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  5., 10.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.83333333,  1.66666667,  2.5       ,  3.33333333,\n",
       "        4.16666667,  5.        ,  5.83333333,  6.66666667,  7.5       ,\n",
       "        8.33333333,  9.16666667, 10.        ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Special matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape=(3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(shape=(3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Random number arrays\n",
    "\n",
    "* Numpy's `np.random.xxx` module offers many random number generators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.85364355, 0.20699322, 0.18675912],\n",
       "       [0.98231555, 0.52772497, 0.54494537],\n",
       "       [0.93818789, 0.91388519, 0.44828561]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3, 3) # is uniform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.20626319, -0.63197416,  0.80843017],\n",
       "       [-0.33016822,  0.56584215, -0.16235999],\n",
       "       [ 1.76202852, -0.18058352, -0.03921261]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(3, 3) # standard normal distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operators\n",
    "\n",
    "* All operators `+`, `-`, `*`, `>`, ..., work element wise per default.\n",
    "* A new array will be created unless you use the `+=`, `-=` and so forth operators.\n",
    "* Matrix multiplication can be done with `@` operator (requires Python 3.5) or dot method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5., 5., 5., 5.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.ones(4)\n",
    "a + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 2., 2., 2.])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2] = 5\n",
    "a > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 4, 9])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2, 3])\n",
    "b = np.array([0, 1, 2, 3])\n",
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a @ b # matrix product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(b) # the \"old\" way to write a matrix prodcuct"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Universal functions\n",
    "\n",
    "* Numpy offers almost all mathematical functions you might need, such as\n",
    "  * exp\n",
    "  * max, min\n",
    "  * sqrt\n",
    "  * argmax\n",
    "  * median, mean, stdev\n",
    "  * ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 1.70460487e+00, 2.90567775e+00, 4.95303242e+00,\n",
       "       8.44296317e+00, 1.43919161e+01, 2.45325302e+01, 4.18182703e+01,\n",
       "       7.12836271e+01, 1.21510418e+02, 2.07127249e+02, 3.53070116e+02,\n",
       "       6.01845038e+02, 1.02590798e+03, 1.74876773e+03, 2.98095799e+03])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.linspace(0, 8, 16)\n",
    "np.exp(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Shape modification\n",
    "\n",
    "* There are many ways to change the shape of an array.\n",
    "* Most prominent methods are `reshape` and `transpose`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.ones((3,4))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(a.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.zeros((1, 4))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.transpose() # transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.T # transpose, short hand code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ravel() # flattens the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing and iterating\n",
    "\n",
    "* Is very similar to lists.\n",
    "* Indexing is done by braces `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = np.random.rand(3, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# modify one element\n",
    "a[1, 1] = 96"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9015626721609997"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.90156267, 0.15860076, 0.92586081])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.90156267 0.15860076 0.92586081]\n",
      "[ 0.82601745 96.          0.33312838]\n",
      "[0.60133987 0.53074791 0.81656546]\n"
     ]
    }
   ],
   "source": [
    "# iteration over first dimension\n",
    "for row in a:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If you want to iterate over all elements instead, use the flat attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9015626721609997\n",
      "0.15860075987052058\n",
      "0.9258608073857245\n",
      "0.8260174527163244\n",
      "96.0\n",
      "0.3331283759775331\n",
      "0.6013398695667754\n",
      "0.5307479085804412\n",
      "0.8165654631841754\n"
     ]
    }
   ],
   "source": [
    "for i in a.flat:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slicing arrays\n",
    "\n",
    "* Slicing is also done with braces. \n",
    "* There is a great \"conversion\" table for Matlab users here [https://numpy.org/devdocs/user/numpy-for-matlab-users.html](https://numpy.org/devdocs/user/numpy-for-matlab-users.html).\n",
    "* The basic slicing syntax is `[start:stop:step]`, see a full tutorial here [https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(20)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "All indices are zero based, the stop is not inclusive, and negative means to reverse counting (count from end to start)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1] # last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0] # first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:-1:2] # start from index 2 to last index and take every second value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stacking arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [3., 3., 3.]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.ones(3)\n",
    "b = np.ones(3) + 2\n",
    "np.vstack((a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 3., 3., 3.])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparing floats\n",
    "\n",
    "* The `numpy.allclose` is ideal to compare arrays element wise with relative or absolute tolerance.\n",
    "* The syntax is `np.allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose([1e10,1e-7], [1.00001e10,1e-8], atol=1e-3) # with larger absolute tolerance, it returns True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Linear algebra\n",
    "\n",
    "* Numpy comes with a linear algebra module `numpy.linalg`.\n",
    "* Next comes an example to solve an overdetermined system of equations where:\n",
    "  * $A \\in \\mathbb{R}^{n \\times m}$ denotes input data,\n",
    "  * $X \\in \\mathbb{R}^{n}$ is the parameter vector, \n",
    "  * and $b \\in \\mathbb{R}^{m}$ is the output vector which follows $b = A^\\top X$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.],\n",
       "       [5.]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 2; m = 20\n",
    "A = np.random.rand(n, m) # input data, two dimensions, 20 samples\n",
    "X = np.array([[3], [5]]) # two dimensional prameter vector\n",
    "b = A.T @ X # model the output\n",
    "\n",
    "# now solve the system of equations\n",
    "np.linalg.solve(a=(A @ A.T), b=(A @ b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.34901833, -0.31003372],\n",
       "       [-0.31003372,  0.46588732]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(A @ A.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Read csv data\n",
    "\n",
    "* Numpy's `genfromtxt` is very convenient to read csv files into numpy arrays.\n",
    "* The syntax is `dat = genfromtxt('my_file.csv', delimiter=',')`, and there are many additional import properties like skip_rows, missing_values, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We will load this .csv file into a numpy array.\n",
    "\n",
    "```\n",
    "\"Time\", \"Torque\"\n",
    "0, 200\n",
    "1, 220\n",
    "2, 225\n",
    "3, 230\n",
    "4, 231\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# This if else is a fix to make the file available for Jupyter and Travis CI\n",
    "import os\n",
    "\n",
    "if os.path.isfile('my_file.csv'):\n",
    "    file = 'my_file.csv'\n",
    "else:\n",
    "    file = '02_tools-and-packages/my_file.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0., 200.],\n",
       "       [  1., 220.],\n",
       "       [  2., 225.],\n",
       "       [  3., 230.],\n",
       "       [  4., 231.]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import genfromtxt\n",
    "\n",
    "genfromtxt(file, delimiter=',', skip_header=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can also use the column names during the import with `names=True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([(0., 200.), (1., 220.), (2., 225.), (3., 230.), (4., 231.)],\n",
       "      dtype=[('Time', '<f8'), ('Torque', '<f8')])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dat = genfromtxt(file, delimiter=',', names=True)\n",
    "dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 2. 3. 4.]\n",
      "[200. 220. 225. 230. 231.]\n"
     ]
    }
   ],
   "source": [
    "print(dat[\"Time\"])\n",
    "print(dat[\"Torque\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Matrix computations become so much simpler with numpy\n",
    "\n",
    "Remember from last lesson that we used lists to plot for instance a parabola. This code was not that handy. \n",
    "\n",
    "```\n",
    "x = [i for i in range(-20, 20)]\n",
    "y = [x[i]**2 for i in range(0,40)]\n",
    "```\n",
    "\n",
    "With numpy, such tasks become very simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(-20, 20, 0.01)\n",
    "\n",
    "plt.plot(x, x**2) # x**2 is easy to read compared with a list [x[i]**2 for i in range(0,40)]\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise:  Numpy mini project (20 minutes)\n",
    "\n",
    "<img src=\"../_static/exercise.png\" alt=\"Exercise\" width=\"75\" align=\"left\">\n",
    "\n",
    "Know that you are familiar with matplotlib and numpy, you can solve the first more elaborate data task.\n",
    "\n",
    "This is what you should strive for:\n",
    "\n",
    "* Write a Python script which creates a linear multiplier model of type $AX \\approx b$. The dimension of $A$ should be 1000 times 2, and the respective dimension of X becomes 2. \n",
    "* Select two values for $X$ as you like. These are the true model parameters.\n",
    "* Generate input data (random numbers or sine waves, as you like) and compute $b$.\n",
    "* The $\\approx$ sign in the above equation is due to noise that you should add to $b$.\n",
    "* The noise should be Gaussian $\\mathcal{N} \\sim(0, 0.01)$.\n",
    "* Plot the noisy data $b$.\n",
    "* Use `np.linalg.solve` to compute the least squares solution $\\hat{X}$ for the parameters.\n",
    "* Use the same input data and $\\hat{X}$ to compute and to plot the fit of the least squares solution.\n",
    "* Print the true and estimated parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Solution\n",
    "\n",
    "Please find one possible solution in [`solution_numpy.py`](solution_numpy.py) file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True params [ 3. -8.]\n",
      "Estimated params [ 2.99942396 -7.99943241]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%run solution_numpy.py"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}