{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy and  Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "\n",
    "NumPy is a linear algebra library in Python, with computationally expensive methods written in FORTRAN for speed. \n",
    "\n",
    "* The reference manual is at <https://numpy.org/doc/stable/>. \n",
    "* A nice tutorial can be found at <https://numpy.org/doc/stable/user/quickstart.html>\n",
    "* or: <https://cs231n.github.io/python-numpy-tutorial/>\n",
    "* If you already know Matlab, a comparison is at <https://numpy.org/doc/stable/user/numpy-for-matlab-users.html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing libraries\n",
    "\n",
    "To import a library in Python, you only need to use the keyword `import` at the beginning of your script / notebook (or more exactly, before you use it).\n",
    "\n",
    "```python\n",
    "import numpy\n",
    "```\n",
    "\n",
    "Think of it as the equivalent of `#include <numpy.h>` in C/C++ (if you know Java, you will not be shocked). You can then use the functions and objects provided by the library using the namespace of the library:\n",
    "\n",
    "```python\n",
    "x = numpy.array([1, 2, 3])\n",
    "```\n",
    "\n",
    "If you do not want to type `numpy.` everytime, and if you are not afraid that numpy redefines any important function, you can also simply import every definition declared by the library in your current namespace with:\n",
    "\n",
    "```python\n",
    "from numpy import *\n",
    "```\n",
    "\n",
    "and use the objects directly:\n",
    "\n",
    "```python\n",
    "x = array([1, 2, 3])\n",
    "```\n",
    "\n",
    "However, it is good practice to give an alias to the library when its name is too long (numpy is still okay, but think of matplotlib...):\n",
    "\n",
    "```python\n",
    "import numpy as np \n",
    "```\n",
    "\n",
    "You can then use the objects like this:\n",
    "\n",
    "```python\n",
    "x = np.array([1, 2, 3])\n",
    "```\n",
    "\n",
    "Remember that you can get help on any NumPy function:\n",
    "\n",
    "```python\n",
    "help(np.array)\n",
    "help(np.ndarray.transpose)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectors and matrices\n",
    "\n",
    "The basic object in NumPy is an **array** with d-dimensions (1D = vector, 2D = matrix, 3D or more = tensor). They can store either integers or floats, using various precisions.\n",
    "\n",
    "In order to create a vector of three floats, you simply have to build an `array()` object by providing a list of floats as input:\n",
    "\n",
    "```python\n",
    "A = np.array( [ 1., 2., 3.] )\n",
    "```\n",
    "\n",
    "Matrices should be initialized with a list of lists.  For a 3x4 matrix of 8 bits unsigned integers, it is:\n",
    "\n",
    "```python\n",
    "B = np.array( [ \n",
    "    [ 1, 2, 3, 4],\n",
    "    [ 5, 6, 7, 8],\n",
    "    [ 4, 3, 2, 1] \n",
    "  ] , dtype=np.uint8)\n",
    "```\n",
    "\n",
    "Most of the time, you won't care about the type (the default floating-point precision is what you want for machine learning), but if you need it, you can always specify it with the parameter `dtype={int32, uint16, float64, ...}`. Note that even if you pass integers to the array (`np.array( [ 1, 2, 3] )`), they will be converted to floats by default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following attributes of an array can be accessed:\n",
    "\n",
    "- `A.shape` : returns the shape of the vector `(n,)` or matrix `(m, n)`.\n",
    "\n",
    "- `A.size` : returns the total number of elements in the array.\n",
    "\n",
    "- `A.ndim` : returns the number of dimensions of the array (vector: 1, matrix:2).\n",
    "\n",
    "- `A.dtype.name` : returns the type of data stored in the array (int32, uint16, float64...)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Define the two arrays $A$ and $B$ from above and print those attributes. Modify the arrays (number of elements, type) and observe how they change. \n",
    "\n",
    "*Hint:* you can print an array just like any other Python object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n",
      "Shape of A is : (3,)\n",
      "Size of A is : 3\n",
      "Number of dimensions of A is : 1\n",
      "Type of elements in A is : float64\n",
      "[[1 2 3 4]\n",
      " [5 6 7 8]\n",
      " [4 3 2 1]]\n",
      "Shape of B is : (3, 4)\n",
      "Size of B is : 12\n",
      "Number of dimensions of B is : 2\n",
      "Type of elements in B is : uint8\n"
     ]
    }
   ],
   "source": [
    "A = np.array( [ 1., 2., 3.] )\n",
    "\n",
    "print(A)\n",
    "print('Shape of A is :', A.shape)\n",
    "print('Size of A is :', A.size)\n",
    "print('Number of dimensions of A is :', A.ndim)\n",
    "print('Type of elements in A is :', A.dtype.name)\n",
    "\n",
    "B = np.array( [ \n",
    "    [ 1, 2, 3, 4],\n",
    "    [ 5, 6, 7, 8],\n",
    "    [ 4, 3, 2, 1] \n",
    "] , dtype=np.uint8)\n",
    "\n",
    "print(B)\n",
    "print('Shape of B is :', B.shape)\n",
    "print('Size of B is :', B.size)\n",
    "print('Number of dimensions of B is :', B.ndim)\n",
    "print('Type of elements in B is :', B.dtype.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Internally, the values are stored sequentially as a vector, even if your array has more than one dimension. The apparent shape is just used for mathematical operations. You can **reshape** a matrix very easily with the `reshape()` method:\n",
    "\n",
    "```python\n",
    "B = np.array( [ \n",
    "    [ 1, 2, 3, 4],\n",
    "    [ 5, 6, 7, 8],\n",
    "    [ 4, 3, 2, 1] \n",
    "]) # B has 3 rows, 4 columns\n",
    "\n",
    "C = B.reshape((6, 2)) # C has 6 rows, 2 columns\n",
    "```\n",
    "\n",
    "The only thing to respect is that the total number of elements must be the same. Beware also of the order in which the elements will be put.\n",
    "\n",
    "**Q:** Create a vector with 8 elements and reshape it into a 2x4 matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "B = np.array( [1, 2, 3, 4, 5, 6, 7, 8])\n",
    "\n",
    "C = B.reshape((2, 4))\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization of an array\n",
    "\n",
    "Providing a list of values to `array()` would be tedious for large arrays. Numpy offers constructors that allow to construct simply most vectors or matrices.\n",
    "\n",
    "`np.zeros(shape)` creates an array of shape `shape` filled with zeros. Note: if you give a single integer for the shape, it will be interpreted as a vector of shape `(d,)`. \n",
    "\n",
    "`np.ones(shape)` creates an array of shape `shape` filled with ones. \n",
    "\n",
    "`np.full(shape, val)` creates an array of shape `shape` filled with `val`. \n",
    "\n",
    "`np.eye(n)` creates a diagonal matrix of shape `(n, n)`.\n",
    "\n",
    "`np.arange(a, b)` creates a vector of integers whose value linearly increase from `a` to `b` (excluded).\n",
    "\n",
    "`np.linspace(a, b, n)` creates a vector of `n` values evenly distributed between `a` and `b` (included).\n",
    "\n",
    "\n",
    "**Q:** Create and print:\n",
    "\n",
    "* a 2x3 matrix filled with zeros.\n",
    "* a vector of 12 elements initialized to 3.14.\n",
    "* a vector of 11 elements whose value linearly increases from 0.0 to 10.0.\n",
    "* a vector of 11 elements whose value linearly increases from 10 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.zeros((2,3))  \n",
    "B = np.full(12, 3.14)  # 3.14 * np.ones(12) would also work\n",
    "C = np.linspace(0.0, 10.0, 11) \n",
    "D = np.arange(10, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random distributions\n",
    "\n",
    "In many cases, it is useful to initialize a vector or matrix with random values. **Random number generators** (rng) allows to draw numbers from any probability distribution (uniform, normal, etc.) using pseudo-random methods. \n",
    "\n",
    "In numpy versions before 1.16, the `numpy.random` module had direct methods allowing to initialize arrays:\n",
    "\n",
    "```python\n",
    "A = np.random.uniform(-1.0, 1.0, (10, 10)) # a 10x10 matrix with values uniformly taken between -1 and 1\n",
    "```\n",
    "\n",
    "Since numpy 1.16, this method has been deprecated in favor of a more explicit initialization of the underlying rng:\n",
    "\n",
    "```python\n",
    "rng = np.random.default_rng()\n",
    "A = rng.uniform(-1.0, 1.0, (10, 10))\n",
    "```\n",
    "\n",
    "The advantages of this new method (reproducibility, parallel seeds) will not matter for these exercises, but let's take good habits already.\n",
    "\n",
    "The generator has many built-in methods, covering virtually any useful probability distribution. Read the documentation of the random generator:\n",
    "\n",
    "<https://numpy.org/doc/stable/reference/random/generator.html>\n",
    "\n",
    "**Q:** Create:\n",
    "\n",
    "* A vector of 20 elements following a normal distribution with mean 2.0 and standard devation 3.0.\n",
    "* A 10x10 matrix whose elements come from the exponential distribution with $\\beta = 2$.\n",
    "* A vector of 10 integers randomly chosen between 1 and 100 (hint: involves `arange` and `rng.choice`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.default_rng()\n",
    "A = rng.normal(2.0, 3.0, 20)\n",
    "B = rng.exponential(2.0, (10, 10))\n",
    "C = rng.choice(np.arange(1, 101), 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulation of matrices: indices, slices\n",
    "\n",
    "To access a particular element of a matrix, you can use the usual Python list style (the first element has a rank of 0), once per dimension:\n",
    "\n",
    "```python\n",
    "A = np.array(\n",
    "    [ \n",
    "        [ 1,  2,  3,  4],\n",
    "        [ 5,  6,  7,  8],\n",
    "        [ 9, 10, 11, 12]\n",
    "    ]\n",
    ")\n",
    "\n",
    "x = A[0, 2] # The element on the first row and third column\n",
    "```\n",
    "\n",
    "For matrices, the first index represents the rows, the second the columns. [0, 2] represents the element at the first row, third column.\n",
    "\n",
    "**Q:** Define this matrix and replace the element `12` by a zero using indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11  0]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array(\n",
    "    [ \n",
    "        [ 1,  2,  3,  4],\n",
    "        [ 5,  6,  7,  8],\n",
    "        [ 9, 10, 11, 12]\n",
    "    ]\n",
    ")\n",
    "\n",
    "A[2, 3] = 0.\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to access complete row or columns of a matrix using **slices**. The `:` symbol is a shortcut for \"everything\":\n",
    "\n",
    "```python\n",
    "b = A[:, 2] # third column\n",
    "c = A[0, :] # first row\n",
    "```\n",
    "\n",
    "**Q:** Set the fourth column of A to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  1]\n",
      " [ 5  6  7  1]\n",
      " [ 9 10 11  1]]\n"
     ]
    }
   ],
   "source": [
    "A[:, 3] = 1.\n",
    "\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for python lists, you can specify a range `start:stop` to get only a subset of a row/column (beware, stop is excluded):\n",
    "\n",
    "```python\n",
    "d = A[0, 1:3] # second and third elements of the first row\n",
    "e = A[1, :2] # first and second elements of the second row\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use boolean arrays to retrieve indices:\n",
    "\n",
    "```python\n",
    "A = np.array( \n",
    "    [ [ -2,  2,  1, -4],\n",
    "      [  3, -1, -5, -3] ])\n",
    "\n",
    "negatives = A < 0 # Boolean array where each element is True when the condition is met.\n",
    "A[negatives] = 0 # All negative elements of A (where the boolean matrix is True) will be set to 0\n",
    "```\n",
    "\n",
    "A simpler way to write it is:\n",
    "\n",
    "```python\n",
    "A[A < 0] = 0\n",
    "```\n",
    "\n",
    "**Q:** print A, negatives and A again after the assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True False False  True]\n",
      " [False  True  True  True]]\n",
      "[[0 2 1 0]\n",
      " [3 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array( \n",
    "    [ [ -2,  2,  1, -4],\n",
    "      [  3, -1, -5, -3] ])\n",
    "negatives = A < 0\n",
    "A[negatives] = 0\n",
    "\n",
    "print(negatives)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic linear algebra \n",
    "\n",
    "Let's first define some matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array( [ [ 1, 2, 3, 4],\n",
    "                [ 5, 6, 7, 8] ])\n",
    "\n",
    "B = np.array( [ [ 1, 2],\n",
    "                [ 3, 4],\n",
    "                [ 5, 6],\n",
    "                [ 7, 8] ])\n",
    "\n",
    "C = np.array( [ [  1,  2,  3,  4],\n",
    "                [  5,  6,  7,  8],\n",
    "                [  9,  0,  1,  1],\n",
    "                [ 13,  7,  2,  6] ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Transpose a matrix \n",
    "\n",
    "A matrix can be transposed with the `transpose()` method or the `.T` shortcut:\n",
    "\n",
    "```python\n",
    "D = A.transpose() \n",
    "E = A.T # equivalent\n",
    "```\n",
    "\n",
    "**Q:** Try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "[[1 5]\n",
      " [2 6]\n",
      " [3 7]\n",
      " [4 8]]\n"
     ]
    }
   ],
   "source": [
    "D = A.transpose() \n",
    "E = A.T\n",
    "\n",
    "print(A)\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`transpose()` does not change `A`, it only returns a transposed copy. To transpose `A` definitely, you have to use the assigment `A = A.T`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiply two matrices \n",
    "\n",
    "There are two manners to multiply matrices:\n",
    "\n",
    "- element-wise: Two arrays of **exactly** the same shape can be multiplied *element-wise* by using the `*` operator:\n",
    "\n",
    "```python\n",
    "D = A * B\n",
    "```\n",
    "\n",
    "- algebrically: To perform a **matrix multiplication**, you have to use the `dot()` method. Beware: the dimensions must match! `(m, n) * (n, p) = (m, p)`\n",
    "\n",
    "```python\n",
    "E = np.dot(A,  B)\n",
    "```\n",
    "\n",
    "**Q:** Use the matrices `A` and `B` previously defined and multiply them element-wise and algebrically. You may have to transpose one of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  6 15 28]\n",
      " [10 24 42 64]]\n",
      "[[ 1 10]\n",
      " [ 6 24]\n",
      " [15 42]\n",
      " [28 64]]\n",
      "[[ 50  60]\n",
      " [114 140]]\n",
      "[[11 14 17 20]\n",
      " [23 30 37 44]\n",
      " [35 46 57 68]\n",
      " [47 62 77 92]]\n"
     ]
    }
   ],
   "source": [
    "D = A * B.T\n",
    "E = A.T * B\n",
    "\n",
    "print(D)\n",
    "print(E)\n",
    "\n",
    "F = np.dot(A, B)\n",
    "G = np.dot(B, A)\n",
    "\n",
    "print(F)\n",
    "print(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiplying a matrix with a vector\n",
    "\n",
    "`*` and `np.dot` also apply on matrix-vector multiplications $\\mathbf{y} = A \\times \\mathbf{x}$ or vector-vector multiplications.\n",
    "\n",
    "**Q:** Define a vector $\\mathbf{x}$ with four elements and multiply it with the matrix $A$ using `*` and `np.dot`. What do you obtain? Try the same by multiplying the vector $\\mathbf{x}$ and itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30 70]\n",
      "[[ 1  4  9 16]\n",
      " [ 5 12 21 32]]\n",
      "[ 1  4  9 16]\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3, 4])\n",
    "\n",
    "y = np.dot(A, x)\n",
    "z = A*x\n",
    "\n",
    "p = x*x\n",
    "q = np.dot(x, x)\n",
    "\n",
    "print(y)\n",
    "print(z)\n",
    "print(p)\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** the element-wise multiplies each column of the matrix by the corresponding element of the vector. `np.dot` works as expected. The same happens for vector-vector multiplications: element-wise for `*`, dot-product for `np.dot` (hence the name of the method)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverting a matrix\n",
    "\n",
    "Inverting a Matrix (when possible) can be done using the `inv()` method whitch is defined in the `linalg` submodule of NumPy.\n",
    "\n",
    "```python\n",
    "inv_C = np.linalg.inv(C)\n",
    "```\n",
    "\n",
    "**Q:**\n",
    "\n",
    "1. Invert `C` and print the result.\n",
    "2. Multiply `C` with its inverse and print the result. What do observe? Why is Numpy called a *numerical computation* library?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.0467033   0.00274725  0.0989011   0.01098901]\n",
      " [-0.62362637  0.27197802 -0.20879121  0.08791209]\n",
      " [-0.61263736  0.4478022   0.12087912 -0.20879121]\n",
      " [ 1.03296703 -0.47252747 -0.01098901  0.10989011]]\n",
      "[[ 1.00000000e+00  0.00000000e+00 -8.32667268e-17  5.55111512e-17]\n",
      " [ 0.00000000e+00  1.00000000e+00 -2.77555756e-17 -1.11022302e-16]\n",
      " [ 2.22044605e-16 -1.11022302e-16  1.00000000e+00 -8.32667268e-17]\n",
      " [ 0.00000000e+00 -2.22044605e-16  1.11022302e-16  1.00000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "inv_C = np.linalg.inv(C)\n",
    "\n",
    "print(inv_C)\n",
    "print(np.dot(C,inv_C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A:** Some elements which should be 0 have a very small value. This is due to numerical precision issues. Numpy does not make symbolic computations like Mathematica or sympy, it deals with numbers up to a certain precision."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summing elements \n",
    "\n",
    "One can sum the elements of a matrix globally, row-wise or column-wise:\n",
    "\n",
    "```python\n",
    "# Globally\n",
    "S1 = np.sum(A)\n",
    "\n",
    "# Per column\n",
    "S2 = np.sum(A, axis=0) \n",
    "\n",
    "# Per row\n",
    "S3 = np.sum(A, axis=1) \n",
    "```\n",
    "\n",
    "**Q:** Try them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "36\n",
      "[ 6  8 10 12]\n",
      "[10 26]\n"
     ]
    }
   ],
   "source": [
    "# Globally\n",
    "S1 = np.sum(A)\n",
    "\n",
    "# Per column\n",
    "S2 = np.sum(A, axis=0) \n",
    "\n",
    "# Per row\n",
    "S3 = np.sum(A, axis=1) \n",
    "\n",
    "print(A)\n",
    "print(S1)\n",
    "print(S2)\n",
    "print(S3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You also have access to the minimum (`np.min()`), maximum (`np.max()`), mean (`np.mean()`) of an array, also per row/column. \n",
    "\n",
    "**Q:** Try them out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n",
      "4.5\n",
      "[1 2 3 4]\n",
      "[5 6 7 8]\n",
      "[3. 4. 5. 6.]\n",
      "[1 5]\n",
      "[4 8]\n",
      "[2.5 6.5]\n"
     ]
    }
   ],
   "source": [
    "print(np.min(A))\n",
    "print(np.max(A))\n",
    "print(np.mean(A))\n",
    "\n",
    "print(np.min(A, axis=0))\n",
    "print(np.max(A, axis=0))\n",
    "print(np.mean(A, axis=0))\n",
    "\n",
    "print(np.min(A, axis=1))\n",
    "print(np.max(A, axis=1))\n",
    "print(np.mean(A, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematical operations \n",
    "\n",
    "You can apply any usual mathematical operations (cos, sin, exp, etc...) on each element of a matrix (element-wise):\n",
    "\n",
    "```python\n",
    "D = np.exp(A)\n",
    "E = np.cos(A)\n",
    "F = np.log(A)\n",
    "G = (A+3) * np.cos(A-2)\n",
    "```\n",
    "\n",
    "**Q:** Try it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01]\n",
      " [1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03]]\n",
      "[[ 0.54030231 -0.41614684 -0.9899925  -0.65364362]\n",
      " [ 0.28366219  0.96017029  0.75390225 -0.14550003]]\n",
      "[[0.         0.69314718 1.09861229 1.38629436]\n",
      " [1.60943791 1.79175947 1.94591015 2.07944154]]\n",
      "[[ 2.16120922  5.          3.24181384 -2.91302786]\n",
      " [-7.91993997 -5.88279259  2.83662185 10.56187315]]\n"
     ]
    }
   ],
   "source": [
    "D = np.exp(A)\n",
    "E = np.cos(A)\n",
    "F = np.log(A)\n",
    "G = (A+3) * np.cos(A-2)\n",
    "\n",
    "print(D)\n",
    "print(E)\n",
    "print(F)\n",
    "print(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "Matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms.\n",
    "\n",
    "* Reference: <http://matplotlib.org>\n",
    "* Tutorial by N. Rougier: <http://www.labri.fr/perso/nrougier/teaching/matplotlib>\n",
    "\n",
    "This is the default historical visualization library in Python, which anybody should know, but not the nicest. If you are interested in having better visualizations, have a look at:\n",
    "\n",
    "* `seaborn` <https://seaborn.pydata.org/>\n",
    "* `ggplot2` <https://ggplot2.tidyverse.org/>\n",
    "* `bokeh` <https://docs.bokeh.org/>\n",
    "* `plotly` <https://plotly.com/python/>\n",
    "\n",
    "We will nevertheless stick to matplotlib in these exercises.\n",
    "\n",
    "The `pyplot` module is the most famous, as it has a similar interface to Matlab. It is customary to use the `plt` namescape for it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `plt.plot()`\n",
    "\n",
    "The `plt.plot()` command allows to make simple line drawings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`plot()` takes two vectors `x` and `y` as inputs (they must have the same size) and plots them against each other. It is standard to define the x-axis with `np.linspace()` if you just want to plot a function. 100 points is usually a good choice, but you can experiments with less points.\n",
    "\n",
    "The call to `plt.show()` is obligatory at the end to display the window when using a script (very common mistake to forget it!). It is not needed in Jupyter notebooks as it is implicitly called, but let's take the habit anyway. \n",
    "\n",
    "The call to `plt.figure()` is also optional, as a new figure is created when you call `plt.plot()` for the first time.\n",
    "\n",
    "**Q:** Create a third vector `z` (e.g. `z = -x**2 + 2`) and plot it against `x` right after `y` (i.e. between `plt.plot(x, y)` and `plt.show()`). What happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "z = -x**2 + 2.\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, y)\n",
    "plt.plot(x, z)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Now call `plt.figure()` again between the two plots. What happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "z = -x**2 + 2.\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, y)\n",
    "plt.figure()\n",
    "plt.plot(x, z)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the plot is quite empty. This is fine when experimenting in a notebook, but not when incorporating the figures in your thesis. You can make a plot look better by adding a title, labels on the axes, etc. \n",
    "\n",
    "```python\n",
    "plt.title('My title')\n",
    "plt.xlabel('x-axis')\n",
    "plt.ylabel('y-axis')\n",
    "```\n",
    "\n",
    "**Q:** Make the previous plots nicer by adding legends and axes.\n",
    "\n",
    "*Hint:* if you know LateX equations, you can insert simple formulas in the title or axes by using two dollar signs `$$`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "z = -x**2 + 2.\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, y)\n",
    "plt.title(\"Function $x^2 + 1$\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, z)\n",
    "plt.title(\"Function $-x^2 + 2$\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you make multiple plots on the same figure by calling `plt.plot()` multiple times, you can add a label to each plot to create a legend with `plt.legend()`:\n",
    "\n",
    "```python\n",
    "plt.plot(x, y, label='y')\n",
    "plt.plot(x, z, label='z')\n",
    "plt.legend()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "z = -x**2 + 2.\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, y, label=\"$x^2 + 1$\")\n",
    "plt.plot(x, z, label=\"$-x^2 + 2$\")\n",
    "plt.title(\"Functions $x^2 + 1$ and $-x^2 + 2$\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another advantage of declaring a figure is that you can modify its size (which is very small in a notebook by default) with the `figsize` argument in inches:\n",
    "\n",
    "```python\n",
    "plt.figure(figsize=(16, 10))\n",
    "```\n",
    "\n",
    "**Q:** Experiment with figure sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "z = -x**2 + 2.\n",
    "\n",
    "plt.figure(figsize=(12, 10))\n",
    "plt.plot(x, y, label=\"$x^2 + 1$\")\n",
    "plt.plot(x, z, label=\"$-x^2 + 2$\")\n",
    "plt.title(\"Functions $x^2 + 1$ and $-x^2 + 2$\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Side-by-side plots\n",
    "\n",
    "To make separate plots in the same figure, you can use `plt.subplot(abc)`.\n",
    "\n",
    "The function takes three digits a, b, c as input (e.g. 221 or 122) where:\n",
    "\n",
    "- a is the number of rows.\n",
    "- b is the number of columns.\n",
    "- c is the index (starting at 1) of the current subplot.\n",
    "\n",
    "Here is a dummy example of a 2x2 grid of plots:\n",
    "\n",
    "```python\n",
    "plt.subplot(221)\n",
    "plt.plot(x, y)\n",
    "\n",
    "plt.subplot(222)\n",
    "plt.plot(x, z)\n",
    "\n",
    "plt.subplot(223)\n",
    "plt.plot(y, x)\n",
    "\n",
    "plt.subplot(224)\n",
    "plt.plot(z, x)\n",
    "```\n",
    "\n",
    "**Q:** Try it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0., 10., 100)\n",
    "y = x**2 + 1.\n",
    "z = -x**2 + 2.\n",
    "\n",
    "plt.figure(figsize=(12, 10))\n",
    "plt.subplot(221)\n",
    "plt.plot(x, y)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "\n",
    "plt.subplot(222)\n",
    "plt.plot(x, z)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('z')\n",
    "\n",
    "plt.subplot(223)\n",
    "plt.plot(y, x)\n",
    "plt.xlabel('y')\n",
    "plt.ylabel('x')\n",
    "\n",
    "plt.subplot(224)\n",
    "plt.plot(z, x)\n",
    "plt.xlabel('z')\n",
    "plt.ylabel('x')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `plt.imshow()`\n",
    "\n",
    "Matrices can be displayed using `plt.imshow()`. You can choose the color code with the `cmap` argument (e.g. `gray` or `hot`).\n",
    "\n",
    "```python\n",
    "plt.imshow(A, cmap=plt.cm.hot, interpolation='nearest')\n",
    "plt.colorbar()\n",
    "```\n",
    "\n",
    "`plt.colorbar()` allows to show a vertical bar indicating the color code. \n",
    "\n",
    "The interpolation method can also be selected for small matrices (`'nearest` by default, but you can choose `interpolation=\"bicubic\"` for a smoother display).\n",
    "\n",
    "(0, 0) is at the top-left of the image, the first axis is vertical. Change it with the `origin` parameter.\n",
    "\n",
    "**Q:** Create a 10x10 matrix (e.g. randomly) and plot it. Try different color maps (<https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html> and interpolation methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "A = rng.uniform(0., 1., (10, 10))\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(A, cmap=plt.cm.hot, interpolation='nearest')\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `plt.scatter()`\n",
    "\n",
    "If you want to display dots instead of of lines or pixels, `plt.scatter` takes two vectors of same size and plots them against each other:\n",
    "\n",
    "```python\n",
    "plt.scatter(x, y)\n",
    "```\n",
    "\n",
    "**Q:** Create two vectors with 100 elements and make a scatter plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = rng.uniform(0., 1., 100)\n",
    "y = rng.uniform(0., 1., 100)\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `plt.hist()`\n",
    "\n",
    "Histograms can be useful to visualize the distribution of some data. If `z` is a vector of values, the histogram is simply:\n",
    "\n",
    "```python\n",
    "plt.hist(z, bins=20)\n",
    "```\n",
    "\n",
    "The number of bins is 10 by default, but you can of course change it.\n",
    "\n",
    "**Q:** Draw 1000 values from a normal distribution of your choice and make an histogram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "z = rng.normal(10., 2.0, 1000)\n",
    "\n",
    "plt.figure()\n",
    "plt.hist(z, bins=20)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "3d24234067c217f49dc985cbc60012ce72928059d528f330ba9cb23ce737906d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}