{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config InlineBackend.figure_formats = ['svg']\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [5, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 4: More NumPy and Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Lecture 4: More NumPy and Matplotlib\n",
    "\n",
    "In this lecture we will talk more about NumPy and introduce Matplotlib.\n",
    "- The material covers more parts from the NumPy User Manual [4] \n",
    "- as well parts of the Matplotlib User Guide [5]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Working with NumPy\n",
    "- Lecture 3 introduced NumPy and the `ndarray` array type\n",
    "- Now it's time to start working with these!\n",
    "\n",
    "To access the `numpy` package it is standard to use the import:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Element-wise (binary) operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "The first thing to note is that when working with `ndarrays`: Operations are **element-wise**\n",
    "\n",
    "## Example: Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(4.)\n",
    "\n",
    "b = a + 1\n",
    "\n",
    "print(\"type(a) = {}\\na = {}\\nb = {}\".format(type(a), a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b\n",
    "\n",
    "print('c =', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Example: Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(4)\n",
    "b = np.linspace(1., 2.5, num=4)\n",
    "\n",
    "c = a * b\n",
    "\n",
    "print(f\" a = {a} \\n b = {b} \\n c = {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Note:** The elements in an `ndarray` has a common `dtype`<br>\n",
    "the results of array operations is promoted to the proper type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a.dtype, b.dtype, c.dtype, sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Shape compatibility\n",
    "\n",
    "If shapes of operands are incompatible, NumPy will give you an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(4)\n",
    "b = np.linspace(1, 2, num=3)\n",
    "print(a.shape, b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "c = a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Broadcasting\n",
    "\n",
    "If the shapes of arrays does not match, NumPy tries to apply **broadcasting** rules\n",
    "\n",
    "- If one array has a dimension with only a single index, `.shape[d] == 1`\n",
    "- the elements in the other dimensions are repeated across"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = np.zeros(shape=(3, 4))\n",
    "b = np.arange(4.).reshape((1, 4))\n",
    "print('a =\\n', a)\n",
    "print('b =', b)\n",
    "print(a.shape, b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "c = a + b # What happens here!?!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Adding one-dimensional axies `np.newaxis`\n",
    "- To make broadcasting easy it is possible to add extra axies to arrays.\n",
    "- This is done using slicing and the `np.newaxis` (or `None`)\n",
    "- Consider the previous example again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = np.zeros(shape=(3, 4))\n",
    "b = np.arange(4.)\n",
    "\n",
    "c = a + b[np.newaxis, :]\n",
    "\n",
    "print(f'a =\\n{a}\\nb = {b}\\nc =\\n{c}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you like to think in index notation the above operation is equivalent to: $ c_{ij} = a_{ij} + b_{i} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What is `np.newaxis` actually doing?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = b[np.newaxis, :]\n",
    "print(b.shape)\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## More broadcasting\n",
    "\n",
    "Take the difference $d_{ij}$ of all pairs of entries in two vectors $a_i$ and $b_j$\n",
    "$$ d_{ij} \\equiv a_i - b_j $$\n",
    "\n",
    "Solve by applying broadcasting to both arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_i = np.arange(4.)\n",
    "b_j = np.arange(4., 0., -1.)\n",
    "\n",
    "print(f'a_i = {a_i}\\nb_j = {b_j}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_ij = ? # ToDo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Indexing and slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In many algorithms you need to work on parts of an array, i.e. only selected entries will be used.\n",
    "\n",
    "* When we talk about *indexing* we are choosing data for specific indices out of an array\n",
    "* For NumPy indexing, you can use Python lists or NumPy arrays as *index arrays*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Example: Index arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.linspace(1., 10., 7)\n",
    "index = np.array([0, 2, 3])\n",
    "\n",
    "print( f\"a = {a}\" )\n",
    "print( f\"index = {index}\" )\n",
    "print()\n",
    "print( a[0] )          # Single element\n",
    "print( a[[0, 2, 3]] )# Indexing with index array - Python list\n",
    "print( a[index] )      # Indexing with index array - NumPy array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Example: Boolean index arrays\n",
    "* You can also use arrays of Booleans as \"mask\" arrays to choose specific values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = a > 4\n",
    "print( f\"mask = {mask}\" )\n",
    "print( f\"a[mask] = {a[mask]}\"  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Example: Slicing\n",
    "* When we talk about *slicing* we are choosing specific data *continuously* or in a *regular pattern*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( a[0:2] )        # Slicing: Elements from (and including) no. 0 to no. 2 (not including)\n",
    "print( a[::2] )        # Slicing: Every second element from start to end\n",
    "print( a[:0:-1] )      # Slicing: Every element _except_ the first one, in reverse order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Example: Multidimensional slicing\n",
    "* NumPy arrays can be of _any_ dimension, indexing follows the same pattern as for one dimension. Different dimensions are separated with a comma (**,**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(24).reshape(3, 2, 4)\n",
    "print( f\"a = \\n{a}\" )\n",
    "print()\n",
    "print( \"a[0,:,:] = \\n{}\".format(a[0,:,:]) )    # \"block 0\"\n",
    "print()\n",
    "print( \"a[:,1,:] = \\n{}\".format(a[:,1,:]) )    # \"row 1\"\n",
    "print()\n",
    "print( \"a[:,:,2] = \\n{}\".format(a[:,:,2]) )    # \"column 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- For more ways to work with arrays, see the NumPy methods **where()**, **argsort()**, **concatenate()**, **hstack()** and **vstack()**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numerics with NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are **many** numerical routines available in NumPy\n",
    "* Standard mathematical functions: `np.sin`, `np.cosh`, `np.exp`, `np.log`, `np.log10`, `np.sign`, etc.\n",
    "* Reductions, `np.max`, `np.min`, `np.sum`, `np.prod`, `np.mean`, `np.median`, etc.\n",
    "* Cumulative functions: `np.cumsum`, `np.cumprod`\n",
    "* Integration and differentiation: `np.trapz`, `np.diff`, `np.gradient`\n",
    "* Contractions, i.e. matrix multiplication and its generalizations: `np.dot`, `np.tensordot`, `np.einsum`, etc.\n",
    "* Linear algebra `np.linalg`\n",
    "* Random number generators `np.random`\n",
    "* Fourier transforms `np.fft`\n",
    "* Polynomials `np.polynomial`\n",
    "* And more\n",
    "\n",
    "see the [NumPy reference manual](https://docs.scipy.org/doc/numpy/reference/) for a complete list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sums and Products (`np.sum`, `np.prod`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0.1 * np.arange(1., 25.).reshape(2, 3, 4)\n",
    "print(f\"a =\\n{a}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum all elements: $\\sum_{ijk} a_{ijk}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Product of all elements: $\\prod_{ijk} a_{ijk}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.prod(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To work over a subset of axes, use the `axis` key-word argument\n",
    "\n",
    "Sum all elements over 2nd axis: $\\sum_{j} a_{ijk}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Product of all elements over the 2nd and 3rd axis: $\\prod_{jk} a_{ijk}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " np.prod(a, axis=(1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Differentiation `np.diff`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference between neighbouring elements\n",
    "$$y_i = x_{i+1} - x_i$$\n",
    "\n",
    "can be computed by: `y = np.diff(x, n=1, axis=-1)`\n",
    "- `n :`  number of times to take the difference\n",
    "- `axis :` axis to work on, default `-1`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(5.)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.diff(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = np.diff(x, 2)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Gradients `np.gradient`\n",
    "Approximate the gradient calculation\n",
    "$$\\frac{df(x_n)}{dx} \\approx \\frac{f(x_{n+1})- 2f(x_n) + f(x_{n-1})}{2\\Delta x}$$\n",
    "use `np.gradient(f , [dx, dy, ....])`\n",
    "\n",
    "Example:\n",
    "$$f(x) = \\cos(x) \\quad \\Rightarrow \\quad f'(x) \\equiv \\frac{d}{dx}f(x) = \\frac{d}{dx} \\cos(x) = -\\sin(x)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dx = 0.1\n",
    "x = np.arange(0, 3*np.pi, dx)\n",
    "\n",
    "f = np.cos(x)\n",
    "f_prime = np.gradient(f, dx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x, f, label='$f(x)$')\n",
    "plt.plot(x, f_prime, label='$f\\'(x)$')\n",
    "plt.xlabel('$x$')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Cumulative sums (integration) `np.cumsum`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the Riemann sum approximation of an integral \n",
    "$$F(x) = \\int_{x_0}^x f(y) \\, dy \n",
    "\\quad \\Rightarrow \\quad F(x_n) \\approx \\Delta x \\cdot \\sum_{i = 0}^n f(x_i)$$\n",
    "\n",
    "* use `np.cumsum(f, axis=None, out=None)`\n",
    "* `axis` is the axis to work along (default is to *flatten* array and use all elements)\n",
    "\n",
    "* Example: $f(x) = \\cos(x) \\Rightarrow F(x) = \\sin(x)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 4*np.pi, num=400)\n",
    "dx = x[1] - x[0] # All distances equal\n",
    "  \n",
    "f = np.cos(x)  \n",
    "F = np.cumsum(f) * dx\n",
    "\n",
    "plt.plot(x, f, label='$f(x)$')\n",
    "plt.plot(x, F, label='$F(x)$')\n",
    "plt.xlabel('$x$')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For integration over an entire interval\n",
    "$$ \\int_{x_0}^{x_{-1}} f(x) \\, dx $$\n",
    "* use `numpy.trapz(f, x=None, dx=1.0, axis=-1)` (trapetzoidal rule)\n",
    "* give `x` **or** `dx`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F_trapz = np.trapz(f, x=x)\n",
    "\n",
    "print(\"Trapezoidal integration:\", F_trapz)\n",
    "print(\"Rieman integration:     \", F[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Array dot-product  `np.dot`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The standard binary operations, `+`, `-`, `*`, `/` etc., work *element-wise* on NumPy `ndarray`s\n",
    "- For Vector/matrix multiplications use `np.dot(a, b)`\n",
    "- Note: `ndarrays` have `.dot` *method*, see below\n",
    "\n",
    "The dot product `np.dot` is defined as\n",
    "* For vectors: $a \\cdot b = \\sum_j a_j b_j$ (the result is a scalar)\n",
    "* For matrices: $A \\cdot B = \\sum_k A_{ik} B_{kj}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1., 2., 3.])\n",
    "b = np.array([2., 1., 0.])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Matrix vector product\n",
    "\n",
    "`np.dot` does matrix-vector multiplication when given one 2D and one 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(6.).reshape( (3,2) )\n",
    "b = np.arange(2.)\n",
    "print( \"A =\\n{}\".format(A) )\n",
    "print( \"b = {}\".format(b) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.dot(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Matrix multiplication\n",
    "`np.dot` does matrix multiplication when given two 2D arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(9).reshape((3,3))\n",
    "B = np.random.randint(0,10,(3,3))\n",
    "print(\"A =\", A, 'B =', B, sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "A.dot(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Array manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Transpose given by the `T` view, e.g. `B.T`\n",
    "* Array conjugate using the `.conjugate` or `.conj` methods\n",
    "* General transpose-like operations, `np.swapaxes` etc.<br>\n",
    "  see [NumPy Array Manipulation Routines](https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "B = np.arange(6).reshape(2, 3)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.swapaxes(B, 0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Complex valued arrays and complex conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = (1 + 1j) * B\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C.conj()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## NumPy Linear Algebra module `np.linalg`\n",
    "Provides additional operations\n",
    "* `norm(A)`: matrix or vector norm (default: 2-norm)\n",
    "* `det(A)`: matrix determinant\n",
    "* `x = solve(A, b)`: linear equation system solver: $A \\cdot \\mathbf{x} = \\mathbf{b}$\n",
    "* `inv(A)`, `pinv(A)`: matrix inverse and pseudo inverse\n",
    "* `Q, R = qr(A)` QR-factorization\n",
    "* `eig(A)`: matrix eigen value and eigen vector decomposition\n",
    "* `svd(A)`: matrix single-value decomposition\n",
    "\n",
    "Example: inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([\n",
    "    [1, 0, 1],\n",
    "    [3, 1, 0],\n",
    "    [1, 2, 1]])\n",
    "\n",
    "A_inv = np.linalg.inv(A)\n",
    "print(A_inv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.dot(A_inv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information use the built-in help!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The matrix type `np.matrix`\n",
    "- It is **deprecated**, please do not use it!\n",
    "- Instead use the new matrix multiplication syntax: `A @ B`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here are the previous examples with `np.dot` replaced by `@`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(6.).reshape((3, 2))\n",
    "b = np.arange(2.)\n",
    "A @ b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(9).reshape((3 ,3))\n",
    "B = np.random.randint(0, 10, size=(3, 3))\n",
    "A @ B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([\n",
    "    [1, 0, 1],\n",
    "    [3, 1, 0],\n",
    "    [1, 2, 1]])\n",
    "\n",
    "A_inv = np.linalg.inv(A)\n",
    "A @ A_inv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## More NumPy!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "There are many additional sub-packages and functions in NumPy not covered here, for example the modules \n",
    "- `np.fft`,\n",
    "- `np.random`, and \n",
    "- `np.polynomial`, \n",
    "\n",
    "for more information use the built-in `help()` and the online documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Visualisation\n",
    "\n",
    "Visualization is a cornerstone of scientific computing\n",
    "\n",
    "There are many tools for data visualisation, e.g.\n",
    "- Matlab, Mathematica, GNUplot, R, etc., and\n",
    "- many more specialised software suites"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For Python the dominating package is:\n",
    "- **Matplotlib**, for 2D plots with some 3D support\n",
    "- there are interesting competitors, **plotly**, **Bokeh**, etc.\n",
    "\n",
    "Here we will only look into Matplotlib."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- is a Python 2D plotting library which produces publication quality figures\n",
    "\n",
    "Matplotlib can be used in \n",
    "  - Python scripts, \n",
    "  - the Python and IPython shell, \n",
    "  - the jupyter notebook, \n",
    "  - web application servers, and\n",
    "  - four graphical user interface toolkits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Matplotlib motto:\n",
    "\n",
    "*Matplotlib tries to make easy things easy and hard things possible.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can generate \n",
    "  - plots, \n",
    "  - histograms, \n",
    "  - power spectra, \n",
    "  - bar charts, \n",
    "  - errorcharts, \n",
    "  - scatterplots, etc., \n",
    "  \n",
    "with just a few lines of code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- For simple plotting the pyplot module provides a MATLAB-like interface, \n",
    "- For the power user, you have full control of line styles, font properties, axes properties, etc., \n",
    "  - via an object oriented interface or \n",
    "  - via a set of functions familiar to MATLAB users\n",
    "\n",
    "For a sampling, see the screenshots, [thumbnail gallery](https://matplotlib.org/gallery/index.html), and examples directory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `matplotlib.pyplot`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `matplotlib.pyplot` is the \"main\" module for plotting\n",
    "- this module contain all the things you need to create figures, draw axes, plot results etc.\n",
    "- it is standard to import Matplotlib according to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Figures, axes and plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand how to work with Matplotlib we need to know how Matplotlib constructs its figures.\n",
    "- The \"basic\" object for all figures is the `figure` object.\n",
    "- The figure object contains all the axes, plots and axis lables, etc. that you create\n",
    "\n",
    "- The figure object can be explicitly created using `plt.figure()`, \n",
    "- However, it is created automatically when using most plotting-commands.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure()\n",
    "plt.plot([0, 2, 3], [5, 3, 1]);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The call to `plt.plot(...)` creates a line plot (it also automatically creates an axes object and makes it the current axis)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What makes a figure?\n",
    "\n",
    "A figure comprise a number of components\n",
    "- **axes**, with \n",
    "  - title\n",
    "  - legend\n",
    "  - spines\n",
    "  - axis labels\n",
    "  - grid\n",
    "  - minor and major ticks, and\n",
    "  - tick labes\n",
    "- different types of **plots**\n",
    "  - line plots\n",
    "  - scatter plots\n",
    "  - etc."
   ]
  },
  {
   "attachments": {
    "L4_matplotlib_fig_map.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![L4_matplotlib_fig_map.png](attachment:L4_matplotlib_fig_map.png)\n",
    "(Source: [the Matplotlib homepage](http://matplotlib.org/faq/usage_faq.html#parts-of-a-figure))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Controlling the axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods for the figure object, or for individual axes objects include:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.title('Bell progress')\n",
    "plt.plot([0,2,3], [5,3,1], label='Tim')\n",
    "plt.plot([0,1,3], [2,3,5], label='Alice')\n",
    "plt.legend(title='User', loc='best')\n",
    "\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('bells')\n",
    "plt.xlim(right=3.5)\n",
    "plt.ylim([0., 5.5])\n",
    "plt.grid(True)\n",
    "\n",
    "plt.text( 2.5, 3., r'$\\Omega = \\sum_i \\frac{K_i}{2 \\cdot B_i}$', size=15 )\n",
    "plt.yticks(np.arange(6), ['', 'One', '**', 3, r'$\\Delta$', '>>>>>'])\n",
    "plt.tick_params(axis='x', direction='in',  color='r', labelcolor='g', \n",
    "                width=2, length=8, top=False)\n",
    "plt.savefig('my_plot.svg')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- There are many more  possibilities available to modify your plots\n",
    "- See the online material and the [\"gallery\" section on the the Matplotlib homepage](https://matplotlib.org/gallery/index.html) for more information.\n",
    "- **Note:** For text labels, you can use raw strings (`r\"...\"`) with LaTeX-syntax to display symbols etc. (See the simple example above.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Multiple axes\n",
    "\n",
    "You can combine plots with completely different scales in one direction into one plot (or subplot) \n",
    "by using `plt.twinx()` or `plt.twiny()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.plot([1, 2, 3, 4], [1, 2.5, 3.1, 4], label='Data 1')\n",
    "plt.ylabel('Data 1 [m]')\n",
    "plt.legend()\n",
    "\n",
    "plt.twinx()\n",
    "\n",
    "plt.scatter( [1, 2, 3, 4], [60, 48, 42, 30], label='Data 2' )\n",
    "plt.ylabel('Data 2 [kg]')\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('X')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Plot styling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Plot styling: Colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Colors, markers and linestyles can be specified using a Matlab-like notation for simple cases\n",
    "- `\"r*-\"` to give a red line with `*`-markers at the points.\n",
    "- To separately control color use the `color=` keyword-argument\n",
    "\n",
    "There are four color specifications:\n",
    "- By name (or the single letter version like above). All the 140 color names from the [HTML/CSS specification](https://www.w3schools.com/colors/colors_names.asp) are supported.\n",
    "- Using a [RGB hex string (as in HTML/CSS)](https://www.w3schools.com/colors/colors_hex.asp), e.g. `#0000FF` for blue etc.\n",
    "- By an RGB(A) tuple of floats `(r, g, b, alpha)` with values in $a,b,c,\\alpha \\in [0, 1]$. The last parameter $\\alpha$ is optional and controls the transparency.<br> e.g. red is (1.0, 0.0, 0.0), while (0.0, 0.0, 1.0, 0.5) gives transparent blue. \n",
    "- Setting gray level with a string containing a number between 0 and 1. For black use `\"0.0\"` and for white `\"1.0\"`\n",
    "\n",
    "(Note: Transparency can also be set by the `alpha=` key-word argument)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot([0, 1, 2], [1.2, 1.5, 1.0], color='OliveDrab')\n",
    "plt.plot([0, 1, 2], [0.8, 0.4, 0.2], color=(0.2, 0.8, 0.8, 0.5))\n",
    "plt.plot([0, 1, 2], [0.5, 0.8, 1.3], color=\"0.6\", alpha=0.5, linewidth=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Plot styling: Line styles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `-` : solid lines\n",
    "- `--` : dashed lines\n",
    "- `-.` : dot-dashed lines\n",
    "- `dashes=[dash_length, space_length, ...]` : arbitrary dashes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, num=10)\n",
    "a, b, c, d = np.cumsum(np.random.random((4, len(x))), axis=-1)\n",
    "plt.plot(x, a, '-', label='a')\n",
    "plt.plot(x, b, '--', label='b')\n",
    "plt.plot(x, c, '-.', label='c')\n",
    "plt.plot(x, d, dashes=[6, 1, 1, 1, 1, 1], label='d')\n",
    "plt.legend(loc='best'); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Plot styling: Markers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Markers are set in the `fmt` argument or the `marker=` keyword argument.\n",
    "\n",
    "marker     |  description  ||marker    |  description    ||marker  |  description  ||marker    |  description  \n",
    ":----------|:--------------||:---------|:----------------||:-------|:--------------||:---------|:--------------\n",
    "\".\"        |  point        ||\"+\"       |  plus           ||\",\"     |  pixel        ||\"x\"       |  cross\n",
    "\"o\"        |  circle       ||\"D\"       |  diamond        ||\"d\"     |  thin_diamond ||          |\n",
    "\"8\"        |  octagon      ||\"s\"       |  square         ||\"p\"     |  pentagon     ||\"\\*\"      |  star\n",
    "\"&#124;\"   |  vertical line||\"\\_\"      | horizontal line ||\"h\"     |  hexagon1     ||\"H\"       |  hexagon2\n",
    "0          |  tickleft     ||4         |  caretleft      ||\"<\"     | triangle_left ||\"3\"       |  tri_left\n",
    "1          |  tickright    ||5         |  caretright     ||\">\"     | triangle_right||\"4\"       |  tri_right\n",
    "2          |  tickup       ||6         |  caretup        ||\"^\"     | triangle_up   ||\"2\"       |  tri_up\n",
    "3          |  tickdown     ||7         |  caretdown      ||\"v\"     | triangle_down ||\"1\"       |  tri_down\n",
    "\"None\"     |  nothing      ||`None`    |  nothing        ||\" \"     |  nothing      ||\"\"        |  nothing\n",
    "\n",
    "It is also possible to construct new markers by giving a list of xy-coordinate tuples (relative to the center of the marker at `(0,0)`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "plt.plot([0, 1, 2], [1.2, 1.5, 1.0], 'kD-', markersize=10 )\n",
    "plt.plot([0, 1, 2], [0.5, 0.8, 1.3], color=\"green\", marker=\"8\", markersize=15 )\n",
    "plt.plot([0, 1, 2], [0.8, 0.4, 0.2], color='SlateBlue', alpha=0.75,\n",
    "         marker=[(-3, -5), (0, 3), (3, -5), (0, -3)], markersize=25)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plot functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a wide range of plot functions available in Matplotlib.\n",
    "- We have already used `plt.plot` and `plt.scatter`\n",
    "- Lets look at a fev more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `plt.plot`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `plt.plot()` is very flexible\n",
    "- `plt.plot(x, y)` will plot the values in `x` and `y`. `x`, `y` can be single values or iterable items (list, tuples, NumPy arrays etc.) of coordinates\n",
    "* `plot(x1, y1, x2, y2, ...)` will plot the sets of `x` and `y`:s at once in the same figure\n",
    "* `plot(y)` will plot *y* with *x* as integers starting from 0\n",
    "\n",
    "Common keyword arguments to `plt.plot` are\n",
    "- `color=`, `alpha=`, \n",
    "- `linestyle=`, `linewidth=`, `fillstyle=`,\n",
    "- `marker=`, `markersize=`, \n",
    "- `label=` (will be shown by `plt.legend`)\n",
    "\n",
    "Note: It is still possible to use Matlab-like colour/marker/linestyle specifications like `\"rx-.\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "coord = np.array( [[0.05, 0.05], [0.4, 0.3], [0.6, 0.5], [0.7, 0.55], [0.95, 0.61]] )\n",
    "print(coord)\n",
    "plt.plot(coord[:, 0], coord[:, 1], color='g', label='data', fillstyle='bottom', marker='D', markersize=10 )\n",
    "plt.plot(coord[:, 1], coord[:, 0], color='b', label='flipped data', linestyle='--', linewidth=4 )\n",
    "plt.legend(loc='lower right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Multi-dimensional `y` array example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, num=10)\n",
    "y = np.cumsum(np.random.random((len(x), 4)), axis=0)\n",
    "print(x.shape, y.shape)\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Logarithmic plots: `plt.semilogx`, `plt.semilogy`, `plt.loglog`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any axis can be scaled logarithmically by using\n",
    "- `plt.semilogx` : scale the x-axis logaritmically\n",
    "- `plt.semilogy` : the y-axis\n",
    "- `plt.loglog` : scale both axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 100, num=1000)\n",
    "plt.loglog(x, x**2, label=r'$x^2$')\n",
    "plt.loglog(x, x**3, label=r'$x^3$')\n",
    "plt.legend(loc='upper left'); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "plt.semilogy(x, x**2, label=r'$x^2$')\n",
    "plt.semilogy(x, x**3, label=r'$x^3$')\n",
    "plt.legend(loc='lower right'); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Error bars: `plt.errorbar`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For errorbars (or any other interval you want to show like an errorbar), use \n",
    "- `plt.errorbar(x, y, xerr=..., yerr=...)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, num=10)\n",
    "y = x*(x-1)*(x+1)\n",
    "xerror = np.random.normal(size=len(x), scale=0.1)\n",
    "yerr = np.random.normal(size=len(x), scale=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.errorbar(x, -y, xerr=xerror, yerr=yerr, ecolor='r');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "plt.errorbar(x, y, xerr=yerr, ecolor='g');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Filled plots `plt.fill_between`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- You can create plots with filled areas between lines\n",
    "- or between a line and the x-axis) using `plt.fill_between(x, y1, y2=)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(1e-10, 4*np.pi, num=1000)\n",
    "y1 = np.sin(x + np.pi*0.5)\n",
    "y2 = np.sin(x) / x\n",
    "\n",
    "plt.fill_between(x, y1, y2=y2, edgecolor='Purple', alpha=0.5, linewidth=4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.fill_between(x, y2, edgecolor='r', facecolor='SeaGreen', alpha=0.75);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Histograms `plt.hist`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Create histograms using `plt.hist(y, bins=10, normed=False, histtype= ...)`\n",
    "- See the built-in help or online documentation for more options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100 + 15 * np.random.randn(100000)\n",
    "plt.hist(x, bins=40, density=True, facecolor='g', alpha=0.75);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(x, bins=20, histtype='stepfilled', facecolor='PowderBlue', alpha=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Contour plots `plt.contour`, `plt.contourf`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create filled and non-filled contour plots using `plt.contourf` and `plt.contour` respectively.\n",
    "- To specify colour-map, use the `cmap=` keyword argument\n",
    "- For predefined color maps see [the Matplotlib documentation](https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-4*np.pi, 4*np.pi)\n",
    "X, Y = np.meshgrid(x, x)\n",
    "R = np.sqrt(X**2 + Y**2)\n",
    "Z = np.sin(R) / R\n",
    "\n",
    "plt.contour(X, Y, Z, 15, cmap=plt.cm.RdBu)\n",
    "plt.axis('image');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contourf(X, Y, Z, 15, cmap=plt.cm.summer); plt.axis('image');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Axes and subplots `plt.axis`, `plt.subplot`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In the previous examples we have not explicitly worked with the `axis` object in Matplotlib\n",
    "- For a single plot the axis is generated automatically when plotting data, using e.g. `plt.plot`\n",
    "- Working with more than one set of axes in a single figure sometimes requires explicit axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-1, 1, num=10)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(x, x**2)\n",
    "ax.set_xlabel('x');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- All functionality is reachable using methods of the `figure` and `axis` objects\n",
    "- This is the *object oriented* way of using Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Multiple subplots `plt.subplot`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `ax = plt.subplot(nrows, ncols, plot_number)` : call for all values of `plot_number`\n",
    "* `fig1, (ax1, ax2, ...) = plt.subplots(nrows, ncols)` : call once\n",
    "\n",
    "Both these gives a `nrows x ncols` grid of subplots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplot(1, 2, 1)\n",
    "plt.plot([0,2,3], [5,3,1])\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot([0,1,3], [2,4,3])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "ax1.plot([0,2,3], [5,3,1])\n",
    "ax2.plot([0,1,3], [2,4,3])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Subplot layouts\n",
    "\n",
    "How do we make a figure with \n",
    "- **one** subplot on the left and \n",
    "- **two** subplots on top of each other to the right?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Solution: \n",
    "1. \"Pretend\" to have a $1 \\times 2$ layout for the first subplot, and chose position 1 (the leftmost for it).\n",
    "2. For the two right plots, \"pretend\" to have a $2 \\times 2$ layout and chose positions 2 and 4 (the numbering goes from left to right from the top down)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y_L, y_R = [0,2,3], [5,3,1], [2,4,3]\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(x, y_L)\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(x, y_R)\n",
    "plt.subplot(2, 2, 4)\n",
    "plt.plot(x, y_R)\n",
    "\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tip: For more advanced subplot layouts use [the `GridSpec` class](http://matplotlib.org/users/gridspec.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 3D plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- To contruct 3D-plots with Matplotlib, you additional need to import an extra axes object\n",
    "  ```python\n",
    "  from mpl_toolkits.mplot3d import Axes3D\n",
    "  ```\n",
    "- setting the `projection='3d'` keyword argument when creating axes gives a 3D plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config InlineBackend.figure_formats = ['retina']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "theta = np.linspace(-4, 4, num=100)\n",
    "z = 0.5*theta; r = z**2 + 1\n",
    "x = r * np.sin(np.pi*theta)\n",
    "y = r * np.cos(np.pi*theta)\n",
    "\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "plt.figure(figsize=(12, 12))\n",
    "plt.subplot(1,1,1, projection='3d')\n",
    "plt.plot(x, y, z, label='parametric curve')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-4*np.pi, 4*np.pi, num=40)\n",
    "X, Y = np.meshgrid(x, x)\n",
    "R = np.sqrt(X**2 + Y**2)\n",
    "Z = np.sin(R) / R\n",
    "\n",
    "plt.figure(figsize=(12, 12))\n",
    "ax = plt.subplot(1,1,1, projection='3d')\n",
    "ax.plot_wireframe(X, Y, Z, alpha=0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-4*np.pi, 4*np.pi, num=100)\n",
    "X, Y = np.meshgrid(x, x)\n",
    "R = np.sqrt(X**2 + Y**2)\n",
    "Z = np.sin(R) / R\n",
    "\n",
    "plt.figure(figsize=(12, 12))\n",
    "ax = plt.subplot(1,1,1, projection='3d')\n",
    "ax.plot_surface(X, Y, Z, cmap=plt.cm.rainbow, rstride=1, cstride=1, alpha=.5, linewidth=0)\n",
    "ax.contour(X, Y, Z, zdir='y', offset=15)\n",
    "ax.contour(X, Y, Z, zdir='x', offset=-15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Matplotlib collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to plot a large number of elements it is somewhat inefficient to plot them one by one using the methods shown above.\n",
    "\n",
    "To remedy this Matplotlib have a **collections** submodule that helps in collecting many objects of the same type that can be used efficiently when drawing images.\n",
    "\n",
    "There are collection-types for polygons, lines, triangular meshes, paths and more.\n",
    "\n",
    "For example the **matplotlib.collections** **LineCollection(segments, ...)** gathers segments of lines for convinient plotting of many line-segments.\n",
    "* **segments** is a sequence of (line0, line1, line2), where:\n",
    "* **lineX** is a sequence of coordinates, i.e. lineX = (x0, y0), (x1, y1), ... (xm, ym)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Ny = 10\n",
    "x = np.arange(8)\n",
    "\n",
    "# Ny lines where y is randoms between 0 and 2 * Ny + 3\n",
    "from random import random\n",
    "lines = []\n",
    "for i in np.arange(Ny):\n",
    "    line = []\n",
    "    for xj in x:\n",
    "        y = random() * 3 + 2 * i\n",
    "        line.append( (xj, y) )\n",
    "        #print(line)\n",
    "    lines.append(line)\n",
    "    \n",
    "from matplotlib.collections import LineCollection\n",
    "line_segments = LineCollection(lines)\n",
    "\n",
    "fig = plt.figure(figsize=(15, 8))\n",
    "ax = fig.gca()\n",
    "ax.add_collection(line_segments)\n",
    "ax.set_ylim((0, 2*Ny+3))\n",
    "ax.set_xlim((0, np.amax(x)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More Matplotlib?\n",
    "\n",
    "Have a look at the [thumbnail gallery](https://matplotlib.org/gallery/index.html) and see if you **see** what you want to do."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 4: The End"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  }
 ],
 "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": 1
}