notebooks/4_ScientificProgramming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Scientific Programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Notebook settings \n",
    "\n",
    "# multiple lines of output per cell\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">### Today\n",
    ">\n",
    "> - Scientific programming\n",
    ">    - [NumPy](#NumPy)\n",
    ">    - [Matplotlib](#Matplotlib)\n",
    "> \n",
    ">\n",
    "> - Regular expressions (another notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Sample of Python Libraries for Scientific Programming\n",
    "\n",
    "In addition to the Standard Library, `python.org` offers an ever-growing collection of freely available components that are constantly upgraded, tested and updated. There are many modules, packages and programs available from [PyPI](https://pypi.python.org/pypi) - the Python Package Index. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These libraries are developed either to extend the functionalities of Python, or as more specialized/efficient version of existing modules (or both). In the remaining of this tutorial we will briefly introduce two fundamental packages for scientific computing with Python: **NumPy** and **matplotlib**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy\n",
    "\n",
    "The **Num**eric(al) **Py**thon package is the core library for scientific computing in Python. It enriches Python with high performance data structures, as well as with function to manipulate such data structures and for a whole range of numerical routines. \n",
    "\n",
    "**SciPy**, another core scientific package provides a wide inventory on functions that, by operating on NumPy arrays, can be used for a range of scientific applications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when imported, numpy is usually renamed as \"np\". \n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arrays\n",
    "\n",
    "**ndarrays** (i.e. *N*-dimensional arrays) are the main data structure on which NumPy is based. \n",
    "\n",
    "ndarrays are **multidimensional** **homogeneous** arrays composed by a **predetermined number** of items:\n",
    "\n",
    "\n",
    "- the dimensionality of an ndarray is defined by its **shape** (i.e., a tuple of integers specifying the size of each dimension, a.k.a. *axes*). The number of axes of an array is called its **rank**. \n",
    "\n",
    "\n",
    "- Sometimes \"dimension\" is used interchangeably for the shape and the rank of an array.\n",
    "\n",
    "\n",
    "- Ndarrays are composed by items of the same type. In NumPy arrays, types are defined by the object **dtype** (data-type), and each array is associated to one and only one dtype.\n",
    "\n",
    "\n",
    "- When a ndarray is created, its size is defined and cannot be changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy arrays can be created in many different ways, among which by passing a regular Python list or tuple to the `array()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# let's create a rank-1 array (i.e. a vector)\n",
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's verify that this is a numpy array\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this is a rank-1 array\n",
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# its only axis has shape [6]\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if not explicitly specified, array() automatically infers the dtype on the basis of the type of the \n",
    "# elements in the list\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 6\n"
     ]
    }
   ],
   "source": [
    "# indexing can be used to access values...\n",
    "print(a[0], a[2], a[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 9, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ... or to change them\n",
    "a[1] = 9\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 9],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the rank of an array can be changed, e.g. into  2-rank array with 3 rows and 2 columns\n",
    "# NB: row*col must be equal to no. of elements (6 here)\n",
    "a.reshape(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "2\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "# the same syntax can be used to create rank 2 arrays\n",
    "b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(b)\n",
    "print(b.ndim)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# but indexing is a bit more articulated\n",
    "print(b[0, 0])\n",
    "print(b[2, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `dtype` option can be used to specify to the `array()` function which type of elements are in the array (see the [NumPy documentation](https://docs.scipy.org/doc/numpy-1.10.1/user/basics.types.html) for the full list of supported data-types):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]\n",
      " [7. 8. 9.]]\n"
     ]
    }
   ],
   "source": [
    "c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype = \"float32\")\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays with some initial content can be created by using different functions, depending on the **initial value**..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# 2-rank array of zeros\n",
    "a = np.zeros((3, 4))\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# 2-rank array of ones\n",
    "b = np.ones((3, 4))\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]]\n"
     ]
    }
   ],
   "source": [
    "# 2-rank array with an user-selected initial value\n",
    "c = np.full((3, 4), 14.05)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... or on the **function** used to generate the initial values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[2.31408950e-01 8.06177419e-01 2.56474462e-01 2.34434294e-01]\n",
      "  [1.39882639e-01 2.92972254e-01 4.99175734e-01 7.31429103e-02]\n",
      "  [1.76339475e-01 6.58623271e-01 9.90004018e-01 6.38169184e-01]]\n",
      "\n",
      " [[9.66625653e-01 5.93205301e-01 2.60200661e-01 6.66516053e-01]\n",
      "  [7.08409281e-01 1.37263594e-01 1.01250050e-04 2.55632691e-02]\n",
      "  [6.12577716e-01 3.89314241e-01 6.66236771e-01 4.24172641e-01]]]\n"
     ]
    }
   ],
   "source": [
    "# 3-rank array with random values\n",
    "d = np.random.random((2, 3, 4))\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy display arrays according to the following rules:\n",
    "\n",
    "- the last axis is printed left to right\n",
    "\n",
    "- the second-to-last is printed top to bottom\n",
    "\n",
    "- the rest are printed top to bottom as well, but the slices are separated by empty lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array Indexing\n",
    "\n",
    "1-rank array indexing, slicing and iteration works much as for the normal Python lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[3 4 5]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "print(a[2])\n",
    "print(a[2:5])\n",
    "for v in a: print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When dealing with multidimensional arrays (i.e. rank > 1), it is necessary to specify an index or a slice **for each dimension**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [5 6]\n",
      " [8 9]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(a.shape)\n",
    "\n",
    "print(a), print(\"--------\")\n",
    "\n",
    "print(a[1, 1]), print(\"--------\")\n",
    "\n",
    "print(a[0:2]), print(\"--------\")\n",
    "\n",
    "print(a[:, 1:3]), print(\"--------\")\n",
    "\n",
    "print(a[0:2, 1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# unspecified indices works the same as with normal lists\n",
    "print(a[:2, :3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# missing indices are considered complete slices\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# negative indices can be used as well\n",
    "print (a[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The iteration over multidimensional arrays starts always with respect to the first axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6]\n",
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "for v in a: print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**boolean indexing** allows you to pick out all the array elements that satisfy a given condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True False]\n",
      " [ True False  True]\n",
      " [False  True False]]\n"
     ]
    }
   ],
   "source": [
    "# let's create a boolean array of the same shape as \"a\", where each slot tells us if \n",
    "# that element of \"a\" is an even number\n",
    "even_idx = ( a % 2 == 0 )\n",
    "print(even_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "# let's extract the even numbers in our array\n",
    "print(a[even_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic Math \n",
    "\n",
    "Basic mathematical functions apply element-wise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[15.05 15.05 15.05 15.05]\n",
      " [15.05 15.05 15.05 15.05]\n",
      " [15.05 15.05 15.05 15.05]]\n"
     ]
    }
   ],
   "source": [
    "# e.g. for the sum\n",
    "print(b + c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]]\n"
     ]
    }
   ],
   "source": [
    "# element-wise multiplication\n",
    "print(b * c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `dot()` can be used to calculate the inner product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n"
     ]
    }
   ],
   "source": [
    "# inner product of rank 1 matrices, or vectors (returns a number, i.e. a scalar)\n",
    "print(np.dot(np.array([9, 10]), np.array([11, 12])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -3]\n"
     ]
    }
   ],
   "source": [
    "# matrix-vector multiplication\n",
    "print(np.dot(np.array([[1, -1, 2],[0, -3, 1]]), np.array([2, 1, 0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0 -10]\n",
      " [ -3  -1]]\n"
     ]
    }
   ],
   "source": [
    "# matrix-matrix multiplication\n",
    "print(np.dot(np.array([[0, 4, -2], [-4, -3, 0]]), np.array([[0, 1], [1, -1], [2, 3]])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, Numpy functions allow to perform computation on arrays or to transform them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "--------\n",
      "12.0\n",
      "--------\n",
      "[3. 3. 3. 3.]\n",
      "--------\n",
      "[4. 4. 4.]\n"
     ]
    }
   ],
   "source": [
    "# compute the sum of all the elements along an axis\n",
    "print(b)\n",
    "print(\"--------\")\n",
    "print(np.sum(b)) # sum all element\n",
    "print(\"--------\")\n",
    "print(np.sum(b, axis=0)) # think: sum over and \"collapse\" axis 0 (= columns)\n",
    "print(\"--------\")\n",
    "print(np.sum(b, axis=1)) # think: sum over and \"collapse\" axis 1 (= rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "[[0 1 2]\n",
      " [3 4 5]]\n",
      "--------\n",
      "(3, 2)\n",
      "[[0 3]\n",
      " [1 4]\n",
      " [2 5]]\n"
     ]
    }
   ],
   "source": [
    "# transpose of a matrix\n",
    "f = np.arange(6).reshape(2,3)\n",
    "print(f.shape)\n",
    "print(f)\n",
    "print(\"--------\")\n",
    "f_transp = f.T\n",
    "print(f_transp.shape)\n",
    "print(f_transp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> 'regular' (rank 1) vector <<\n",
      "rank: 1\n",
      "shape: (5,)\n",
      "[0 1 2 3 4]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> column vector <<\n",
      "rank: 2\n",
      "shape: (5, 1)\n",
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> row vector <<\n",
      "rank: 2\n",
      "shape: (1, 5)\n",
      "[[0 1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "# 3 different types of vectors\n",
    "a_1 = np.arange(5)\n",
    "print(\">> 'regular' (rank 1) vector <<\")\n",
    "print(\"rank: \" + str(a_1.ndim))\n",
    "print(\"shape: \" + str(a_1.shape))\n",
    "print(a_1), print(\"--------\")\n",
    "\n",
    "a_2 = a_1.reshape(5,1)\n",
    "print(\">> column vector <<\")\n",
    "print(\"rank: \" + str(a_2.ndim))\n",
    "print(\"shape: \" + str(a_2.shape))\n",
    "\n",
    "print(a_2), print(\"--------\")\n",
    "\n",
    "a_3 = a_2.reshape(1,5)\n",
    "print(\">> row vector <<\")\n",
    "print(\"rank: \" + str(a_3.ndim))\n",
    "print(\"shape: \" + str(a_3.shape))\n",
    "print(a_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.linalg` provides access to linear algebra functions, e.g., solvers, eigenvalues/vectors, norms and decompositions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "True\n",
      "--------\n",
      "-2.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "# inverse of a matrix\n",
    "a = np.array([[1., 2.], [3., 4.]])\n",
    "print(a)\n",
    "print(np.linalg.inv(a))\n",
    "print(np.allclose(np.dot(a,np.linalg.inv(a)),np.eye(2)))\n",
    "print(\"--------\")\n",
    "print(np.linalg.det(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "matlotlib is a 2D **plotting library**. \n",
    " \n",
    "You can have an idea of the possibilities offered by this package by exploring the [examples](http://matplotlib.org/examples/index.html) section of the documentation\n",
    "\n",
    "The easiest way to drop plots with matplotlib it is by relying on the MATLAB-like interface provided by the `pyplot` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# to make plots in IPython using Matplotlib, you must first enable IPython's matplotlib mode\n",
    "# we may want to use the backend inline, that will embed plots inside the Notebook\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Line plots\n",
    "\n",
    "Line plots represents the relationship between *x*-values and *y*-values by means of a line. \n",
    "\n",
    "Graphs of this sort can be drawn by using the [`.plot()` function](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot), with its default settings "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make an array for the x-values and one array for the y-values\n",
    "x = np.arange(1, 150)\n",
    "y = np.log(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x114d48320>]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# let's create the plot\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# export the plot in a .pdf file\n",
    "plt.savefig(\"data/exemplar-lineplot.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# export the plot in a .png file\n",
    "plt.savefig(\"data/exemplar-lineplot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple calls of the `.plot()` function draw **multiple line plots** in the same figure \n",
    "\n",
    "(note that matplotlib will try to automatically manage many graphical parameters among which the axis size and the line colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x114ebe780>]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x114e943c8>]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x, y) # think of (x, y) as an array (of rank 2) being plotted\n",
    "plt.plot(x, y * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Scatterplots\n",
    "\n",
    "A scatterplot represents one or more groups of observations as points in a cartesian space. \n",
    "\n",
    "The [`scatter()` function](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot) implements a method to draw this kind of plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 100\n",
    "x = np.random.normal(0, 1, n)\n",
    "y = np.random.normal(0, 1, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x114f2cc18>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAYJElEQVR4nO3dfYwdV3nH8d/jzQXWgNhUWQnYxDhqqQNNIFZWUSr/0cakxG0QMYlQoRWlopJVCaQWIQunqSC0oLiyRFsVJGoJRCtZvAgHEzAoOEpo1KhJ2cUmL7WNIiLAG6QsIkuhXmC9fvrHvnhf5t47986ZmXNmvh/JUvbuZu6Z2dnnnnnOc84xdxcAIF1b6m4AAKAYAjkAJI5ADgCJI5ADQOII5ACQuMvqeNMrrrjCt2/fXsdbA0Cypqenf+Lu4xtfryWQb9++XVNTU3W8NQAky8x+kPU6qRUASByBHAASRyAHgMQRyAEgcQRyAEgcgRwAEldL+WHVjp2c0aEHzuq5uXm9emxU+2/dob07J+puFgAEUTiQm9lLJD0i6cXLx/uSu3+46HFDOXZyRnfd96TmFxYlSTNz87rrvicliWAOoBFCpFZ+JWm3u79R0vWS9pjZTQGOG8ShB86uBvEV8wuLOvTA2ZpaBABhFe6R+9LOFL9Y/rKz/C+a3Sqem5sf6HUASE2QwU4zGzGzU5Kel3TC3R8PcdwQXj02OtDrAJCaIIHc3Rfd/XpJV0q60cyu3fgzZrbPzKbMbGp2djbE2+ay/9YdGu2MrHtttDOi/bfuqKwNAFCmoOWH7j4n6VuS9mR877C7T7r75Pj4psW7SrN354TuveM6TYyNyiRNjI3q3juuY6ATQGOEqFoZl7Tg7nNmNirpFkn/ULhlAe3dOUHgBtBYIerIXyXp38xsREs9/C+6+9cCHBcAkEOIqpUnJO0M0BYAwBCYog8AiSOQA0DiCOQAkDgCOQAkjkAOAIkjkANA4gjkAJA4AjkAJK4VOwS1EbsiAe1BIG8gdkUC2oXUSgOxKxLQLgTyBmJXJKBdCOQNxK5IQLsQyBuIXZGAdmGws4FWBjSpWgHagUDeUOyKBLQHqRUASByBHAASR2oFSWLmKnAJgRzJYeYqsB6pFSSHmavAegRyJIeZq8B6pFYwsLrz068eG9VMRtBm5iraih45BrKSn56Zm5frUn762MmZytrAzFVgPQI5BhJDfnrvzgnde8d1mhgblUmaGBvVvXdcx0AnWqtwasXMrpL075JeKemipMPu/s9Fj4s4xZKfZuYqcEmIHvkFSR9w99dJuknSe83s9QGOiwixsiIQn8KB3N1/7O7fWf7vn0s6LYmuUkORnwbiE7Rqxcy2S9op6fGM7+2TtE+Stm3bFvJtUSFWVgTiY+4e5kBmL5P0H5I+5u739frZyclJn5qaCvK+ANAWZjbt7pMbXw9StWJmHUlHJR3pF8QBAGEVDuRmZpI+Lem0u3+8eJMAAIMIkSPfJeldkp40s1PLr/2Nu389wLHRInXPGAVSVTiQu/t/SrIAbUGLsaIhMDzWWkEUes0YbVIg56kDZSCQIwqxzBgtE08dKAtrrSTm2MkZ7Tr4kK4+cFy7Dj5U6WJVZWrDjNEY1qlBMxHIExLDyoNlacOM0WGfOpr64Y1wCOQJaXKPbu/OCd15w4RGbGncfMRMd97QrIWxhnnqaPKHN8IhkCekyXnkYydndHR6RovLM40X3XV0eqZRAWuYp44mf3gjHAJ5QpqcR25DwBpmHfUmf3gjHKpWErL/1h3rqh6kevLIZZTQtSVgDbqOOtvaIQ965AmJIY9cVs62zqeNmAcT2zAIjOII5AmJIY9cVgqkroAV+2Ai29ohD1IrCYlh9mNZKZC61jmP4Zr2w7Z26IdAnpAY8shl5mzrCFgxXFOgKFIrCYmhaqXMFEgdueoYrilQFIE8ITEMfJWVs60rVx3DNQWKIrWSkFj2yywjBVJXrjqWawoUQSBPTFMHvurMVTf1mqI9COSIQtsmvrAuOUIikCMKw85aTTEg1rEueYrXCfkx2IkoDDOIGvtknm6qXlcm1euE/OiRIxqD5qpTmMyTperxgFSvE/IjkCNZoQJi1WmHqscDmPTUfKRWGiDmRZ/KFGIyTx1ph6pr15n01HwE8sS1Of8ZIiDWsQ561QthMemp+ZJKrTDyvllb858r98L8wqJGzLTorokh7om60g5V1q4z6an5kgnkdZRspaCN+c+N98Ki+2oPc9B7oap8dd2dECY9NVuQ1IqZfcbMnjezp0IcL0sbtgIbRpH8Z6q59ZD3QhVphzanv1CNUDnyz0raE+hYmdrY88xj2ECUcnAJeS9Uka+mE4KyBUmtuPsjZrY9xLG6adsU7ryGzX+mnFsPfS+UnXagE4KyVZYjN7N9kvZJ0rZt2wb+/2PZeDhGwwSilINLavcCnRCUrbJA7u6HJR2WpMnJSR/0/69i5L3uAakybTy3V4x2NDe/sOnnQgaXsq5nalUYqX3wID3JVK1I5T4CN7kqJuvcOiOmzhbTwsVLn6khg0vZ1zOlKozUPniQnqQCeZlSzhn3k3VuC4uuy7d2tPVFl5USXJp8PYdR9gdPk58m0V+QQG5mn5P0+5KuMLNzkj7s7p8OceyqpJwz7qfbOcydX9DJD7258PGzgkiTr2ds8j79EOybK0j5obu/091f5e4dd78ytSAuNXs9ijLPrVsZ4ytGO6W9J9bLU96Ycrkp+mOtlWVNXo+izHPrFkTMlOs9U52UFJM8Tz/UsjcbOfJlqQ1IDfKYXOa59Urb/OMfX9/zPZs8wFylPOWNpLqajUC+RiqVEMMEwLLOrVcQ6feeDIiGkae8kVr2ZiO1kqCYHpOLpG3oJYZJLeVZZqDJqUPQI09SVs9KqicA5k3bZKWCYu4lVlHhETK11O/pJ7XUIQZDIE9Mrx7b2NbsSpGy9Qsi3QLWnTdM6Oj0THQzHqvK3ZedWsr6MHr0wO7Cx0V8SK0kplf6xAde+KAa3QLWw2dmK90pJ6+qUldlppYoN2wXeuSJ6fVH/rOMtVNi0CtgxTjAXFXuvszUEgPJ7UKPPDG9/shjyC1nSW2yVVXtLXMAkoHkdiGQJ2b/rTvUGbFNr3e2WO255W5Sq5ioqr1lbmqR2ocniiG1kpiVP/KPfPVpvXB+KZUyNtrRPW/9nYECQJXrbqRWMVFle8tKLbF0bruY1zBCNjk56VNTU5W/L5ZsrMqQlv7Ii/QGU1mQKZV2htCmc20LM5t298lNrxPI22fXwYcyB9kmxkaHKk8r44Mhz3sOGqRCtpMgOTiuWXHdAjmplRrUfUOHHgirukJi2DrvUO2se42Yuu+fYdR9zZqOwc6KxVDfG3ogrOoKiWHrvEO1s84lEmK4f4YR07ISTUQgX6OKJVVjuKG7VWXcfM34UOdfdYXEsAE5VDvrLO2L4f4ZBuWQ5Wp9IF8J3tsPHNf7v3Cq9J5ODDd0VtnbynT5Yc6/6vLCYQNyqHbWWdoXw/0zDMohy9XqQL72MVWSNg77ltHTieWG3rtzQo8e2K1nD96mRw/s1sNnZofu6ZVZD51l2IAcqp111sXHcv8MKrW5BKlp9WBn1mPqRqF7OrHW9xbt6VU51b5InXeIdtZZFx/r/dNPanMJUtPqQJ4nSIXu6cR6Q8e8pGyWutdoqev9Y71/8qj7d9ZkrQ7k3YLXirJ6OjHe0Kn29JqoX3lhjPcP6tXqHHlW3m5lFZNYllStStV5bmQ7dnJG+7/03XWDzvu/9N3oywtRr9bP7Bx2ckWKkzJixvVcsvPvvrm6hs5al2/t6OSH3lxDixATZnZ2McxjKrPUwuJ6XpIVxHu9DkiBUitmtsfMzprZM2Z2IMQxY1ZkUkYVk46KqrqNqU5yAWJRuEduZiOSPinpDySdk/RtM7vf3f+n6LFjNWypXgo9zzramOoklzKMdrZofuFi5utANyHujhslPePu33f3X0v6vKTbAxw3WsNOykih51lHG1Od5FKGl2wYfO/3ekxSeNpsqhCBfELSj9Z8fW75tcYadpZaCj3POtp48zXj2rjnUVtLH+e65MK7vR6LVBfzaooQgXzzvmObZ7vLzPaZ2ZSZTc3OzgZ42/oMW6qXQs+z6jYeOzmjo9Mz624Yk3TnDe2slU7hHsmSwtNmk4UI5OckXbXm6yslPbfxh9z9sLtPuvvk+Ph4gLet18a1SvIEnRTWm6i6jVkBwCU9fCbtD/thpXCPZEnhabPJQpQfflvSa83sakkzkt4h6U8CHLdxUphe3auNZdR6EwDWS+EeyZLaEg9NE2RCkJn9kaR/kjQi6TPu/rFePx/ThKC82jhhZe05j23t6Be/vKCFi5fulxDbuYXedg71qGO7vzbqNiEoSE2Tu3/d3X/b3X+zXxBPURsHcjae8wvnF9YFcSlMDjTVVALWY4mHerV+ZmceVe9JGYM8S/xKxVMgqaYSsBmLedWHQJ5DG/O4ec8tRA6UAAAUQyDPoY0DOf2W+JVIgQyijWMsqA7zfnNoYx4365w7I6ax0Q450AENO8bCTEnkRY88hzbmcWM755R7tMOMsaSwLg/i0fr1yBG/rNI2k/SnN23TR/deV1/Dcrr6wPHNU521dA7PHrwt8/+hLBNZSi0/BMrUbfbnkcd+mES6YZhp920cYMfwCOQN0PRcarfg5VISa3kMM8aS6porqAc58iHFkrMtK5cay/lJvStoUuihDjPeUHQz7Jh+fyj/90GOfAgxTUfulksdG+3opS++bKgbJ6bzW2nP+79wKjPP3OSccZH9ZIv+/vggCCfk31O3HDmBfAgxDUR1G0jbaJAbp9v5Xb61o60vGu7Doai/Pfakjjz2w03L3bqWrjuB5pKi92evwCPFU8mUipDxgs2XA6prICqrl5Rn4o402JIC3c7jhfMLq5sAd0vhlNWT++je6zT5mt/QoQfOamZufjWI92pLWxW9P7uVS37kq0/rlwsXaymJTPkJoYp4wWBnF70GEOsYiOo2qeTma8Y3DaR1E3ra/cZFs8peXGxlDfiJsdFNTyFsYnBJ0fuz1wd5HZtHpL5oXRXxgkCeod+NU8dMz269pIfPzG5ade7yrZ3MY+S9cbLOr5u1f/RV7RJDaV5vRe/PQQNM2dc99d2HqogXpFYy9JuJV8esx17Ba+OiU91ynHlvnKzz+79fXdDc/OZ9I9f+0VcVYNu49s0git6f3SpmXnzZlr73QBlS/+CuIl4QyDPkuXGqXrFvkOAV4sbZeIxXjHbUGTEtLK7fWGLth0NVAbZoaV4bFLk/u90/kmq57k344C47XhDIM8R44wwavPLcOL0GkDb26ufmF9TZYrp8a0dz5xcyPxyqCrCxrQPTRL3un6qvOx/c/VF+mCG2Ouq17Qr1R9TvHIctmUq5umAQbTnPbqo+/7Zf7xXUkQ+o6TdOv0Ddb6Gnpl+fXmL9oK9K28+/TtSRD6jpu9b0GwfolV5q+xKrbdz6b622n3+MKD9sqX61rb1KplIvBysq9SqKotp+/jEikLdUv9rWXruit/0Pue0rE7b9/GNEaqWl9u6c0NQPfqrPPf4jLbprxEx33rA+ndQtvRRjVU+V2l5F0fbzjxE98pY6dnJGR6dntLg82L3orqPTM7mmPbdxD9O1ej2ttEHbzz9GVK20VIgV8mKsWom1XUAIpVStmNnbJd0j6XWSbnR3onMiiua5Y6zqaXs1DdqraI78KUl3SPrXAG1Bydb2VreYraZV1ko5zz1IWVyRnnuZvX6eKDCMQoHc3U9LkpmFaQ1Ks7G3mhXEU89z533KKNJzL7PXzxMFhlXZYKeZ7TOzKTObmp2dreptsSyrtypJI2aNGbDKWxZXpA6+zBr6ttfnY3h9e+Rm9qCkV2Z86253/0reN3L3w5IOS0uDnblbiCC69VYvuuvZg7dV3Jpy5C2LKzI+UGYNfdvr8zG8voHc3W+poiEoVxtqv/OuiljkWpR5HdvwO0I5qCNvidRqv3tttdfLynZwzx68TY8e2J2ZKipyLcq8jqn9jhCPouWHb5P0L5LGJR03s1PufmuQliGomNfw3lipcfM14zo6PVPaoF+Ra1HmdYz5d4S4MSEItcpaErWbvJOVgKbqNiGI1Apq1a2aJguDfkA2AjlqNUhwZtAPyEYgR63yBmcG/YDuCOSoVValxkZNmKwElIn1yFGrleB8z/1Pa25+Yd332AcSyIdAjtqtrKTIglFLuA4YFIEcQRUJQjEujVs1Fs7CMAjkWKfo8q4EoWLYoR7DYLATq1YC8czcvFyXAnHe6fGs3lccC2dhGPTIsapbIL7n/qdz9dIJQsXFsnAWefq00CPHqm4Bd25+IVcvPe964OguhoWzij6ZoXoEcqzKG3C7pUtiCEKpi2GHelJk6SG1glVZGzN0k9V7Z/W+MOqu3iFFlh4COVZlBeLzv76gF84vbPrZbr33uoMQioslT4/8CORYZ2MgzlpmlnRJs+XdMg/xIJCjJ9Il7cPvPD1sLAEAiWBjCQBoKAI5ACSOQA4AiSOQA0DiCOQAkDgCOQAkjkAOAIljQlBFWBYUQFkK9cjN7JCZnTGzJ8zsy2Y2FqphTcKyoADKVDS1ckLSte7+Bknfk3RX8SY1D8uCAihToUDu7t909wvLXz4m6criTWoelgUFUKaQg53vkfSNbt80s31mNmVmU7OzswHfNn7snAOgTH0DuZk9aGZPZfy7fc3P3C3pgqQj3Y7j7ofdfdLdJ8fHx8O0PhHsnAOgTH2rVtz9ll7fN7N3S3qLpDd5HUspJoBlQetFxRCarlD5oZntkfRBSb/n7ufDNKmZ2DmnHhs3xlipGJLE7wONUTRH/glJL5d0wsxOmdmnArQJCIaKIbRBoR65u/9WqIYAZaBiCG3AFH00GhVDaAMCORqNiiG0AWutoNGoGEIbEMjReFQMoelIrQBA4gjkAJA4AjkAJI5ADgCJI5ADQOII5ACQOAI5ACSOQA4AiWNCENZh7W4gPQRyrGLtbiBNpFawirW7gTQRyLGKtbuBNBHIsYq1u4E0Ecixqs1rdx87OaNdBx/S1QeOa9fBh3Ts5EzdTQJyY7ATq9q6djeDvEgdgRzrtHHt7l6DvG27FkgTqRW0HoO8SB2BHK3HIC9SRyBH67V5kBfNQI4crdfWQV40R6FAbmZ/L+l2SRclPS/pz939uRANA6rUxkFeNEfR1Mohd3+Du18v6WuSPhSgTQCAARQK5O7+v2u+fKkkL9YcAMCgCufIzexjkv5M0s8k3Vy4RQCAgfTtkZvZg2b2VMa/2yXJ3e9296skHZH0vh7H2WdmU2Y2NTs7G+4MAKDlzD1MNsTMXiPpuLtf2+9nJycnfWpqKsj7AkBbmNm0u09ufL1QjtzMXrvmy7dKOlPkeACAwRXqkZvZUUk7tFR++ANJf+nufZeNM7PZ5Z+PyRWSflJ3I0rS1HNr6nlJnFuKqjiv17j7+MYXg6VWUmdmU1mPLE3Q1HNr6nlJnFuK6jwvpugDQOII5ACQOAL5JYfrbkCJmnpuTT0viXNLUW3nRY4cABJHjxwAEkcgB4DEEcjXMLNDZnbGzJ4wsy+b2VjdbQrBzN5uZk+b2UUza0TZl5ntMbOzZvaMmR2ouz2hmNlnzOx5M3uq7raEZGZXmdnDZnZ6+V78q7rbFIqZvcTM/tvMvrt8bh+pug0E8vVOSLrW3d8g6XuS7qq5PaE8JekOSY/U3ZAQzGxE0icl/aGk10t6p5m9vt5WBfNZSXvqbkQJLkj6gLu/TtJNkt7boN/ZryTtdvc3Srpe0h4zu6nKBhDI13D3b7r7heUvH5N0ZZ3tCcXdT7v72brbEdCNkp5x9++7+68lfV5LG5wkz90fkfTTutsRmrv/2N2/s/zfP5d0WlIjdvLwJb9Y/rKz/K/SKhICeXfvkfSNuhuBTBOSfrTm63NqSFBoAzPbLmmnpMfrbUk4ZjZiZqe0tFPaCXev9Nxat2enmT0o6ZUZ37rb3b+y/DN3a+lR8EiVbSsiz3k1iGW8Rh1tAszsZZKOSvrrDRvTJM3dFyVdvzyu9mUzu9bdKxvnaF0gd/dben3fzN4t6S2S3uQJFdn3O6+GOSfpqjVfXymJvWIjZ2YdLQXxI+5+X93tKYO7z5nZt7Q0zlFZICe1soaZ7ZH0QUlvdffzdbcHXX1b0mvN7Goze5Gkd0i6v+Y2oQczM0mflnTa3T9ed3tCMrPxlQo3MxuVdIsqXtKbQL7eJyS9XNIJMztlZp+qu0EhmNnbzOycpN+VdNzMHqi7TUUsD0i/T9IDWho0+6K7P11vq8Iws89J+i9JO8zsnJn9Rd1tCmSXpHdJ2r38t3XKzP6o7kYF8ipJD5vZE1rqZJxw969V2QCm6ANA4uiRA0DiCOQAkDgCOQAkjkAOAIkjkANA4gjkAJA4AjkAJO7/ASxGZS8qm141AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use different marker settings for `plot()` (marker type, size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11500de80>]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x, y, \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Color-coding (the default behavior of both `scatter()` and `plot()` allows you to plot different groups of data points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x1150cb6d8>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x1150cbac8>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.scatter(x, y)\n",
    "plt.scatter(x * 2 , y * 2) # what's happening here? (hint: array-like input to scatter...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Manipulating the appearance of a plot\n",
    "\n",
    "Matplotlib allows you to manipulate almost every property of a plot: figure size and resolution, line appearance, axis and grid properties, textual elements ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(1, 150)\n",
    "y = np.log(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You to change the appearance of the **line**\n",
    "\n",
    "(NOTE: See the [matplotlib documentation](https://matplotlib.org/users/colors.html) for a quick introduction on how a color can be specified by the user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1151b7128>]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11518c588>]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1151b7278>]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1151b79e8>]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x, y * 2.5, color = \"r\")  # you can change the line color \n",
    "plt.plot(x, y * 2, linewidth = 0.75)  # you can change the line width\n",
    "plt.plot(x, y * 1.5, linestyle = '--')  # you can change the line style\n",
    "plt.plot(x, y, marker = '*')  # you can change the marker style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can manually choose the **axis limits**, the **axis titles**, the **axis ticks** and **their text** (and plot a grid, if you like):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1152ec0f0>]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(0, 7)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(-5, 155)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'log (x)')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.XTick at 0x115254be0>,\n",
       "  <matplotlib.axis.XTick at 0x115267438>,\n",
       "  <matplotlib.axis.XTick at 0x1152673c8>,\n",
       "  <matplotlib.axis.XTick at 0x1152ec828>],\n",
       " <a list of 4 Text xticklabel objects>)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x, y)\n",
    "\n",
    "# set the axis limits\n",
    "plt.ylim(0, 7)  \n",
    "plt.xlim(-5, 155)  # set the x-axes limits\n",
    "\n",
    "# let's set the y-axis text\n",
    "plt.ylabel(\"log (x)\")\n",
    "\n",
    "# let's set the x-axis ticks and their text (in an awful way...)\n",
    "plt.xticks(range(0, 151, 50), [\"zero\", \"fifty\", \"one hundred\", \"one hundred and fifty\"], size='small')\n",
    "\n",
    "# fancy a grid?\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can give the plot a **main title** and add a **legend**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1153556d8>]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x115328c50>]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x115355b00>]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Logarithms Comparison')"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1153d8240>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x, np.log10(x))\n",
    "plt.plot(x, np.log(x))\n",
    "plt.plot(x, np.log2(x))\n",
    "\n",
    "# create the main title\n",
    "plt.title('Logarithms Comparison')\n",
    "\n",
    "# add a legend\n",
    "plt.legend(['base 10', 'natural', 'base 2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also **annotate** some points that may be of any interest (see [this tutorial](https://matplotlib.org/users/annotations_intro.html))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1154c44e0>]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(35, 2, \"that's log(20) !\")"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot(x, y)\n",
    "plt.annotate(\"that's log(20) !\", xy = (20, np.log(20)), xytext = (35, 2), \n",
    "             arrowprops=dict(facecolor='r', edgecolor='None', shrink=0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Bar plots\n",
    "\n",
    "Unfortunately, humans are quite bad at comparing angles, so a better way to compare the frequencies of categorical data is to use bar plots. In these graphs:\n",
    "\n",
    "- every bar is associated with a given value\n",
    "\n",
    "\n",
    "- the height of each bar is proportional to the frequency of a given value\n",
    "\n",
    "\n",
    "- all the bars have the same width\n",
    "\n",
    "These plots can be drawn by using the [`bar()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.bar) or the [`barh()](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.barh) functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "n = 12\n",
    "x = np.arange(n)\n",
    "y = np.random.uniform(0.5, 1.0, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 12 artists>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.XTick at 0x1156dfcc0>,\n",
       "  <matplotlib.axis.XTick at 0x1156df668>,\n",
       "  <matplotlib.axis.XTick at 0x1156df358>,\n",
       "  <matplotlib.axis.XTick at 0x115779c88>,\n",
       "  <matplotlib.axis.XTick at 0x11578b470>,\n",
       "  <matplotlib.axis.XTick at 0x11578b978>,\n",
       "  <matplotlib.axis.XTick at 0x11578b4a8>,\n",
       "  <matplotlib.axis.XTick at 0x1157911d0>,\n",
       "  <matplotlib.axis.XTick at 0x115791748>,\n",
       "  <matplotlib.axis.XTick at 0x115791cc0>,\n",
       "  <matplotlib.axis.XTick at 0x115799278>,\n",
       "  <matplotlib.axis.XTick at 0x1157997f0>],\n",
       " <a list of 12 Text xticklabel objects>)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# vertical barplot\n",
    "plt.bar(x, y)\n",
    "plt.xticks(x, list(string.ascii_uppercase[:12]), size='small') # let's use some random letters for each value of a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 12 artists>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.YTick at 0x1157c7e48>,\n",
       "  <matplotlib.axis.YTick at 0x1157c79e8>,\n",
       "  <matplotlib.axis.YTick at 0x1157b3cc0>,\n",
       "  <matplotlib.axis.YTick at 0x11581c3c8>,\n",
       "  <matplotlib.axis.YTick at 0x11581c860>,\n",
       "  <matplotlib.axis.YTick at 0x11581cdd8>,\n",
       "  <matplotlib.axis.YTick at 0x115825160>,\n",
       "  <matplotlib.axis.YTick at 0x115825668>,\n",
       "  <matplotlib.axis.YTick at 0x115825be0>,\n",
       "  <matplotlib.axis.YTick at 0x11582d278>,\n",
       "  <matplotlib.axis.YTick at 0x11582d710>,\n",
       "  <matplotlib.axis.YTick at 0x11582dc50>],\n",
       " <a list of 12 Text yticklabel objects>)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# horizontal barplot\n",
    "plt.barh(x, y)\n",
    "plt.yticks(x, list(string.ascii_uppercase[:12]), size='small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "##### Histograms\n",
    "\n",
    "Roughly speaking, histogram are for continuous (a.k.a. numerical) variables what barplots are for categorical variables. Also in this kind of plot, indeed, values are represented by means of bars. However:\n",
    "\n",
    "\n",
    "- each bar is associated with a bin (i.e. an interval of values)\n",
    "\n",
    "\n",
    "- the area inside the bars (rather than their height) is proportional to the frequency of a value or of a set of values\n",
    "\n",
    "\n",
    "- the width of each bar is proportional to the bin size.\n",
    "\n",
    "\n",
    "\n",
    "The [`hist()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hist) function implements most of the functionalities you'll need to plot histograms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.random.normal(-1, 1, 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAATQUlEQVR4nO3df6zd9X3f8edrF0yqRO1ouRPMP7CTulPcJoPp1lTqmk4NJM6K7HQiqtN1crVUHhPWMrFqQKmgM8pUEi2pNLkLrrBWZWUuDa16RR1R1iTtqorEl4SEGurl4gZ8bVjcmC6bkgI27/1xv2kOl2Ofr32v77n+9PmQjvz9fL6fz/m+j+G+7tffXydVhSSpXX9n3AVIki4sg16SGmfQS1LjDHpJapxBL0mNu2TcBSx0xRVX1Pr168ddhiRdVB5//PG/rKrJYetWXNCvX7+emZmZcZchSReVJM+eaZ2HbiSpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEr7s5YaZSr1qzjhWNHx7LtiVVv4PTLf73s271y9Vqen3tu2berNhj0uui8cOwoV9/28Fi2/ey9N45l28/ee+Oyb1Pt6HXoJsmWJIeTzCa5fcj6m5M8meSJJH+SZFPXvz7Jt7r+J5J8fKk/gCTp7Ebu0SeZAPYANwBzwMEk01X11MCwB6rq4934rcBHgS3dumeq6pqlLVuS1FefPfrNwGxVHamql4H9wLbBAVX1jYHmGwG/cVySVog+Qb8aGDzzNdf1vUaSW5I8A3wY+DcDqzYk+WKSP0ryY8M2kGRnkpkkMydOnDiH8iVJo/QJ+gzpe90ee1Xtqaq3ALcBv9R1Pw+sq6prgVuBB5J895C5e6tqqqqmJieHPjdfknSe+gT9HLB2oL0GOH6W8fuB9wJU1UtV9fVu+XHgGeAHzq9USdL56BP0B4GNSTYkWQVsB6YHByTZOND8SeArXf9kdzKXJG8GNgJHlqJwSVI/I6+6qapTSXYBjwATwL6qOpRkNzBTVdPAriTXA68ALwI7uunvAHYnOQWcBm6uqpMX4oNIkobrdcNUVR0ADizou2tg+YNnmPcQ8NBiCpQkLY7PupGkxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuN6BX2SLUkOJ5lNcvuQ9TcneTLJE0n+JMmmgXV3dPMOJ3n3UhYvSRptZNAnmQD2AO8BNgHvHwzyzgNV9baqugb4MPDRbu4mYDvwg8AW4Ne695MkLZM+e/SbgdmqOlJVLwP7gW2DA6rqGwPNNwLVLW8D9lfVS1X1F8Bs936SpGVySY8xq4GjA+054LqFg5LcAtwKrAJ+YmDuYwvmrh4ydyewE2DdunV96pYk9dRnjz5D+up1HVV7quotwG3AL53j3L1VNVVVU5OTkz1KkiT11Sfo54C1A+01wPGzjN8PvPc850qSllifoD8IbEyyIckq5k+uTg8OSLJxoPmTwFe65Wlge5LLkmwANgKfX3zZkqS+Rh6jr6pTSXYBjwATwL6qOpRkNzBTVdPAriTXA68ALwI7urmHkjwIPAWcAm6pqtMX6LNIkoboczKWqjoAHFjQd9fA8gfPMvdDwIfOt0BJ0uJ4Z6wkNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhrXK+iTbElyOMlsktuHrL81yVNJvpzkD5NcPbDudJInutf0UhYvSRrtklEDkkwAe4AbgDngYJLpqnpqYNgXgamq+maSfw18GPjpbt23quqaJa5bktRTnz36zcBsVR2pqpeB/cC2wQFV9Zmq+mbXfAxYs7RlSpLOV5+gXw0cHWjPdX1n8gHgUwPtNySZSfJYkvcOm5BkZzdm5sSJEz1KkiT1NfLQDZAhfTV0YPKzwBTw4wPd66rqeJI3A59O8mRVPfOaN6vaC+wFmJqaGvrekqTz02ePfg5YO9BeAxxfOCjJ9cCdwNaqeunb/VV1vPvzCPBZ4NpF1CtJOkd9gv4gsDHJhiSrgO3Aa66eSXItcB/zIf+1gf7Lk1zWLV8B/CgweBJXknSBjTx0U1WnkuwCHgEmgH1VdSjJbmCmqqaBjwBvAn47CcBzVbUVeCtwX5JXmf+l8isLrtaRJF1gfY7RU1UHgAML+u4aWL7+DPP+FHjbYgqUJC2Od8ZKUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxvW6vFLSmE1cSnePyrK7cvVanp97bizb1tIw6KWLwelXuPq2h8ey6WfvvXEs29XS8dCNJDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUuF5Bn2RLksNJZpPcPmT9rUmeSvLlJH+Y5OqBdTuSfKV77VjK4iVJo40M+iQTwB7gPcAm4P1JNi0Y9kVgqqreDnwS+HA393uBu4HrgM3A3UkuX7ryJUmj9Nmj3wzMVtWRqnoZ2A9sGxxQVZ+pqm92zceANd3yu4FHq+pkVb0IPApsWZrSJUl99An61cDRgfZc13cmHwA+dZ5zJUlLrM/z6Id920ENHZj8LDAF/Pi5zE2yE9gJsG7duh4lSZL66rNHPwesHWivAY4vHJTkeuBOYGtVvXQuc6tqb1VNVdXU5ORk39o1ZletWUeSZX9JOjd99ugPAhuTbACOAduBnxkckORa4D5gS1V9bWDVI8B/HDgB+y7gjkVXrRXhhWNHx/KtR37jkXRuRgZ9VZ1Ksov50J4A9lXVoSS7gZmqmgY+ArwJ+O1uj+u5qtpaVSeT3MP8LwuA3VV18oJ8EknSUL2+M7aqDgAHFvTdNbB8/Vnm7gP2nW+BkqTF8c5YSWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1rlfQJ9mS5HCS2SS3D1n/jiRfSHIqyU0L1p1O8kT3ml6qwiVJ/VwyakCSCWAPcAMwBxxMMl1VTw0Mew74OeAXhrzFt6rqmiWoVZJ0HkYGPbAZmK2qIwBJ9gPbgL8J+qr6arfu1QtQoyRpEfoculkNHB1oz3V9fb0hyUySx5K8d9iAJDu7MTMnTpw4h7eWJI3SJ+gzpK/OYRvrqmoK+BngV5O85XVvVrW3qqaqampycvIc3lqSNEqfoJ8D1g601wDH+26gqo53fx4BPgtcew71SZIWqU/QHwQ2JtmQZBWwHeh19UySy5Nc1i1fAfwoA8f2JUkX3sigr6pTwC7gEeBp4MGqOpRkd5KtAEl+OMkc8D7gviSHuulvBWaSfAn4DPArC67WkSRdYH2uuqGqDgAHFvTdNbB8kPlDOgvn/SnwtkXWKElaBO+MlaTGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS43oFfZItSQ4nmU1y+5D170jyhSSnkty0YN2OJF/pXjuWqnBJUj8jgz7JBLAHeA+wCXh/kk0Lhj0H/BzwwIK53wvcDVwHbAbuTnL54suWJPXVZ49+MzBbVUeq6mVgP7BtcEBVfbWqvgy8umDuu4FHq+pkVb0IPApsWYK6JUk99Qn61cDRgfZc19dHr7lJdiaZSTJz4sSJnm8tSeqjT9BnSF/1fP9ec6tqb1VNVdXU5ORkz7eWJPXRJ+jngLUD7TXA8Z7vv5i5kqQl0CfoDwIbk2xIsgrYDkz3fP9HgHclubw7Cfuurk+StExGBn1VnQJ2MR/QTwMPVtWhJLuTbAVI8sNJ5oD3AfclOdTNPQncw/wvi4PA7q5PkrRMLukzqKoOAAcW9N01sHyQ+cMyw+buA/YtokZJ0iJ4Z6wkNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxvV6BIKkv8UmLiUZ9sTxC+vK1Wt5fu65Zd9uiwx6SWd3+hWuvu3hZd/ss/feuOzbbJWHbiSpcQa9JDXOoJekxnmMvgFXrVnHC8eOjh4o6W8lg74BLxw76skySWfkoRtJapxBL0mNM+glqXG9gj7JliSHk8wmuX3I+suS/Fa3/nNJ1nf965N8K8kT3evjS1u+JGmUkSdjk0wAe4AbgDngYJLpqnpqYNgHgBer6vuTbAfuBX66W/dMVV2zxHVLknrqs0e/GZitqiNV9TKwH9i2YMw24De65U8C78w4Ho4hSXqdPkG/Ghi8SHuu6xs6pqpOAf8H+L5u3YYkX0zyR0l+bNgGkuxMMpNk5sSJE+f0ASRJZ9cn6IftmVfPMc8D66rqWuBW4IEk3/26gVV7q2qqqqYmJyd7lCRJ6qtP0M8Bawfaa4DjZxqT5BLge4CTVfVSVX0doKoeB54BfmCxRUuS+usT9AeBjUk2JFkFbAemF4yZBnZ0yzcBn66qSjLZncwlyZuBjcCRpSldktTHyKtuqupUkl3AI8AEsK+qDiXZDcxU1TRwP/CJJLPASeZ/GQC8A9id5BRwGri5qk5eiA8iSRqu17NuquoAcGBB310Dy38NvG/IvIeAhxZZoyRpEbwzVpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1rtdjiiVp2U1cSjLsW0ovvCtXr+X5uefGsu0LwaBfIletWccLx46OHiipn9OvcPVtD49l08/ee+NYtnuhGPRL5IVjR/2fUtKK5DF6SWqcQS9JjTPoJalxvYI+yZYkh5PMJrl9yPrLkvxWt/5zSdYPrLuj6z+c5N1LV7okqY+RQZ9kAtgDvAfYBLw/yaYFwz4AvFhV3w98DLi3m7sJ2A78ILAF+LXu/SRJy6TPHv1mYLaqjlTVy8B+YNuCMduA3+iWPwm8M/MXwG4D9lfVS1X1F8Bs934XzFVr1pFk2V+SGtJdw7/cr6vWrLsgHydVdfYByU3Alqr6+a79L4DrqmrXwJg/68bMde1ngOuAXwYeq6r/1vXfD3yqqj65YBs7gZ1d8x8Ah3vUfgXwlz3GjYv1LY71nb+VXBtY32Kdqb6rq2py2IQ+19EP211d+NvhTGP6zKWq9gJ7e9TynQ0mM1U1dS5zlpP1LY71nb+VXBtY32KdT319Dt3MAWsH2muA42cak+QS4HuAkz3nSpIuoD5BfxDYmGRDklXMn1ydXjBmGtjRLd8EfLrmjwlNA9u7q3I2ABuBzy9N6ZKkPkYeuqmqU0l2AY8AE8C+qjqUZDcwU1XTwP3AJ5LMMr8nv72beyjJg8BTwCnglqo6vUS1n9OhnjGwvsWxvvO3kmsD61usc65v5MlYSdLFzTtjJalxBr0kNe6iDvokv5zkWJInutc/HXdNwyT5hSSV5Ipx1/JtSe5J8uXu7+0Pkvz9cdc0KMlHkvx5V+PvJvm7465pUJL3JTmU5NUkK+ZSvFGPKxmnJPuSfK2772bFSbI2yWeSPN39t/3guGsalOQNST6f5Etdff+h79yLOug7H6uqa7rXgXEXs1CStcANwEr7upqPVNXbq+oa4GHgrnEXtMCjwA9V1duB/wXcMeZ6Fvoz4J8BfzzuQr4t/R5XMk7/lflHoaxUp4B/V1VvBX4EuGWF/f29BPxEVf1D4BpgS5If6TOxhaBf6T4G/HuG3Cg2TlX1jYHmG1l59f1BVZ3qmo8xfw/GilFVT1dVnzu4l1Ofx5WMTVX9MfNX5a1IVfV8VX2hW/6/wNPA6vFW9R017/91zUu7V6+f2xaCflf3z/t9SS4fdzGDkmwFjlXVl8ZdyzBJPpTkKPDPWXl79IP+JfCpcRdxEVgNDH6f5RwrKKguJpl/Au+1wOfGW8lrJZlI8gTwNeDRqupV34r/KsEk/wO4csiqO4H/AtzD/G+1e4D/xHwoLJsR9f0i8K7lrGfQ2Wqrqt+rqjuBO5PcAewC7l5J9XVj7mT+n9S/uZy1ddseWd8K0+uRIzq7JG8CHgL+7YJ/+Y5ddx/SNd05q99N8kNVNfKcx4oP+qq6vs+4JL/O/LHmZXWm+pK8DdgAfKl7uuUa4AtJNlfVC+OsbYgHgN9nmYN+VH1JdgA3Au+sMdzwcQ5/fyuFjxxZpCSXMh/yv1lVvzPues6kqv4qyWeZP+cxMugv6kM3Sa4aaP4UPT7wcqmqJ6vq71XV+qpaz/wP4T9arpAfJcnGgeZW4M/HVcswSbYAtwFbq+qb467nItHncSU6g8zvkd0PPF1VHx13PQslmfz21WdJvgu4np4/txf1nbFJPsH82ecCvgr8q6p6fqxFnUGSrwJTVbUiHn+a5CHmHwn9KvAscHNVHRtvVd/RPU7jMuDrXddjVXXzGEt6jSQ/BfxnYBL4K+CJqhr7N6h1lxj/Kt95XMmHxlzS30jy34F/wvxjdv83cHdV3T/WogYk+cfA/wSeZP7nAuAXV8rVfEnezvz3fkwwv5P+YFXt7jX3Yg56SdJoF/WhG0nSaAa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatz/Bx75un96CxsGAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = plt.hist(data, density = True, edgecolor='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the `bins` argument allows us to specify in how many bins we want to organize our values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.00065583, 0.00065583, 0.        , 0.00131165, 0.00327913,\n",
       "        0.0052466 , 0.00655825, 0.01180485, 0.01836311, 0.02557719,\n",
       "        0.02754466, 0.05115437, 0.06099175, 0.07738738, 0.10427622,\n",
       "        0.13116505, 0.16002137, 0.20724079, 0.21183156, 0.28003739,\n",
       "        0.30823788, 0.34561992, 0.3607039 , 0.39283934, 0.38890439,\n",
       "        0.40202089, 0.38890439, 0.35480147, 0.34168497, 0.30692623,\n",
       "        0.29971215, 0.27938157, 0.20855244, 0.19281263, 0.15936554,\n",
       "        0.10821117, 0.08263398, 0.07214078, 0.05902427, 0.03738204,\n",
       "        0.03344709, 0.01967476, 0.01442816, 0.00918155, 0.00131165,\n",
       "        0.00131165, 0.00196748, 0.00131165, 0.        , 0.00065583]),\n",
       " array([-4.85369382, -4.70121419, -4.54873455, -4.39625491, -4.24377527,\n",
       "        -4.09129563, -3.938816  , -3.78633636, -3.63385672, -3.48137708,\n",
       "        -3.32889744, -3.17641781, -3.02393817, -2.87145853, -2.71897889,\n",
       "        -2.56649925, -2.41401962, -2.26153998, -2.10906034, -1.9565807 ,\n",
       "        -1.80410106, -1.65162143, -1.49914179, -1.34666215, -1.19418251,\n",
       "        -1.04170287, -0.88922324, -0.7367436 , -0.58426396, -0.43178432,\n",
       "        -0.27930468, -0.12682504,  0.02565459,  0.17813423,  0.33061387,\n",
       "         0.48309351,  0.63557315,  0.78805278,  0.94053242,  1.09301206,\n",
       "         1.2454917 ,  1.39797134,  1.55045097,  1.70293061,  1.85541025,\n",
       "         2.00788989,  2.16036953,  2.31284916,  2.4653288 ,  2.61780844,\n",
       "         2.77028808]),\n",
       " <a list of 50 Patch objects>)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.hist(data, bins = 50, density = True, edgecolor='black')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.00196748, 0.        , 0.        , 0.00196748, 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "        0.00196748, 0.00196748, 0.        , 0.00196748, 0.0078699 ,\n",
       "        0.0078699 , 0.00590243, 0.00196748, 0.00983738, 0.0078699 ,\n",
       "        0.00196748, 0.00983738, 0.0078699 , 0.01770728, 0.01770728,\n",
       "        0.01377233, 0.02360971, 0.01770728, 0.02164223, 0.03738204,\n",
       "        0.02557719, 0.03344709, 0.02360971, 0.05312185, 0.04328447,\n",
       "        0.0570568 , 0.05312185, 0.07869903, 0.05115437, 0.0649267 ,\n",
       "        0.08460146, 0.08263398, 0.10624369, 0.09050389, 0.11608107,\n",
       "        0.13182088, 0.12395098, 0.13772331, 0.13575583, 0.17510535,\n",
       "        0.16920292, 0.19871506, 0.19674758, 0.22625972, 0.20265001,\n",
       "        0.20461748, 0.22822719, 0.24986943, 0.31479613, 0.27544661,\n",
       "        0.29512137, 0.30299128, 0.32660099, 0.36004807, 0.32660099,\n",
       "        0.35021069, 0.34824322, 0.38169031, 0.35217817, 0.44268206,\n",
       "        0.36398303, 0.37185293, 0.39546264, 0.38956021, 0.38169031,\n",
       "        0.35217817, 0.40923497, 0.44464953, 0.41120245, 0.40726749,\n",
       "        0.34824322, 0.3738204 , 0.36201555, 0.32856846, 0.32463351,\n",
       "        0.36791798, 0.33250341, 0.3010238 , 0.32660099, 0.2931539 ,\n",
       "        0.33840584, 0.25380438, 0.30692623, 0.32463351, 0.25970681,\n",
       "        0.25380438, 0.2360971 , 0.19084515, 0.19871506, 0.21838982,\n",
       "        0.1711704 , 0.18887768, 0.16526797, 0.15936554, 0.15346311,\n",
       "        0.14165826, 0.09050389, 0.09247136, 0.09443884, 0.08460146,\n",
       "        0.06886165, 0.08460146, 0.07279661, 0.05902427, 0.0649267 ,\n",
       "        0.05508932, 0.0570568 , 0.03541456, 0.04131699, 0.03541456,\n",
       "        0.02557719, 0.04131699, 0.03344709, 0.02360971, 0.01573981,\n",
       "        0.01967476, 0.01770728, 0.01180485, 0.01377233, 0.01377233,\n",
       "        0.01180485, 0.00196748, 0.00196748, 0.        , 0.00196748,\n",
       "        0.00196748, 0.        , 0.00196748, 0.00196748, 0.00196748,\n",
       "        0.00196748, 0.00196748, 0.        , 0.00196748, 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.00196748]),\n",
       " array([-4.85369382, -4.80286728, -4.75204073, -4.70121419, -4.65038764,\n",
       "        -4.59956109, -4.54873455, -4.497908  , -4.44708146, -4.39625491,\n",
       "        -4.34542836, -4.29460182, -4.24377527, -4.19294873, -4.14212218,\n",
       "        -4.09129563, -4.04046909, -3.98964254, -3.938816  , -3.88798945,\n",
       "        -3.8371629 , -3.78633636, -3.73550981, -3.68468327, -3.63385672,\n",
       "        -3.58303017, -3.53220363, -3.48137708, -3.43055054, -3.37972399,\n",
       "        -3.32889744, -3.2780709 , -3.22724435, -3.17641781, -3.12559126,\n",
       "        -3.07476471, -3.02393817, -2.97311162, -2.92228508, -2.87145853,\n",
       "        -2.82063198, -2.76980544, -2.71897889, -2.66815235, -2.6173258 ,\n",
       "        -2.56649925, -2.51567271, -2.46484616, -2.41401962, -2.36319307,\n",
       "        -2.31236652, -2.26153998, -2.21071343, -2.15988689, -2.10906034,\n",
       "        -2.05823379, -2.00740725, -1.9565807 , -1.90575416, -1.85492761,\n",
       "        -1.80410106, -1.75327452, -1.70244797, -1.65162143, -1.60079488,\n",
       "        -1.54996833, -1.49914179, -1.44831524, -1.3974887 , -1.34666215,\n",
       "        -1.2958356 , -1.24500906, -1.19418251, -1.14335597, -1.09252942,\n",
       "        -1.04170287, -0.99087633, -0.94004978, -0.88922324, -0.83839669,\n",
       "        -0.78757014, -0.7367436 , -0.68591705, -0.6350905 , -0.58426396,\n",
       "        -0.53343741, -0.48261087, -0.43178432, -0.38095777, -0.33013123,\n",
       "        -0.27930468, -0.22847814, -0.17765159, -0.12682504, -0.0759985 ,\n",
       "        -0.02517195,  0.02565459,  0.07648114,  0.12730769,  0.17813423,\n",
       "         0.22896078,  0.27978732,  0.33061387,  0.38144042,  0.43226696,\n",
       "         0.48309351,  0.53392005,  0.5847466 ,  0.63557315,  0.68639969,\n",
       "         0.73722624,  0.78805278,  0.83887933,  0.88970588,  0.94053242,\n",
       "         0.99135897,  1.04218551,  1.09301206,  1.14383861,  1.19466515,\n",
       "         1.2454917 ,  1.29631824,  1.34714479,  1.39797134,  1.44879788,\n",
       "         1.49962443,  1.55045097,  1.60127752,  1.65210407,  1.70293061,\n",
       "         1.75375716,  1.8045837 ,  1.85541025,  1.9062368 ,  1.95706334,\n",
       "         2.00788989,  2.05871643,  2.10954298,  2.16036953,  2.21119607,\n",
       "         2.26202262,  2.31284916,  2.36367571,  2.41450226,  2.4653288 ,\n",
       "         2.51615535,  2.56698189,  2.61780844,  2.66863499,  2.71946153,\n",
       "         2.77028808]),\n",
       " <a list of 150 Patch objects>)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# we won't draw the edge of each bar\n",
    "plt.hist(data, bins = 150, density = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We set `density = True` in order to plot the **frequency density** of a bin (i.e. the relative frequency of a bin divided by its width), rather than its relative (or absolute) frequency (as it is in the graph bar). \n",
    "\n",
    "When the bins are equally spaced, the relative (or absolute) frequency and the frequency density are proportional. However, this proportionality is lost when the histograms plots the density of **unequally spaced** bins (i.e. when the value of the argument `bins` is a sequence)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "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": [
    "n, bins, patches = plt.hist(data, bins = 999, density = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "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": [
    "# equal bins ('density' doesn't matter for overall 'shape')\n",
    "n, bins, patches = plt.hist(data, bins = 9, density = False,  edgecolor='black')\n",
    "patches[4].set_fc(\"r\")\n",
    "patches[5].set_fc(\"r\")\n",
    "patches[6].set_fc(\"r\")\n",
    "patches[7].set_fc(\"r\")\n",
    "patches[8].set_fc(\"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "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": [
    "# unequal bins. density = False (relative frequency)\n",
    "n, bins, patches = plt.hist(data, bins = np.array([min(data), -3, -2, -1, max(data)]), density = False,  edgecolor='black')\n",
    "patches[3].set_fc(\"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAStElEQVR4nO3df6zd913f8edrNk6nVrCA71jmH7ELZqqhnTNdXCSgIJqk7ojsMrXC1ZCMVsnLFGtMGVpSghLmqBJpRTtpMmuMaoEqggnt0K46VyGjLQyhtL5p3QYneL0xSXzjpjV1oEMtCTd574/7LT25Pdfn63uv77n+7PmQjvz9fn58z/te+77u199fJ1WFJKld/2DcBUiSriyDXpIaZ9BLUuMMeklqnEEvSY1bP+4CFtq4cWNt27Zt3GVI0lXl0Ucf/cuqmhjWt+aCftu2bUxPT4+7DEm6qiR5erG+XodukuxJcibJTJI7h/TfmuSxJKeS/EmSnV37tiTf6NpPJfng0r8MSdJSjNyjT7IOOALcBMwCJ5NMVdXjA8MeqKoPduP3Au8H9nR9T1bVrpUtW5LUV589+t3ATFWdraoXgePAvsEBVfW1gdVXA95uK0lrRJ+g3wScG1if7dpeIcltSZ4E3gv8+4Gu7Uk+l+SPkvz4sDdIcjDJdJLpCxcuXEb5kqRR+gR9hrR92x57VR2pqu8D7gB+uWv+ErC1qm4AbgceSPKdQ+YerarJqpqcmBh60liStER9gn4W2DKwvhk4f4nxx4G3AVTVC1X11W75UeBJ4AeWVqokaSn6BP1JYEeS7Uk2APuBqcEBSXYMrP408MWufaI7mUuS1wI7gLMrUbgkqZ+RV91U1VySQ8BDwDrgWFWdTnIYmK6qKeBQkhuBvwOeBw50098EHE4yB7wE3FpVF6/EFyJJGi5r7Xn0k5OT5Q1TknR5kjxaVZPD+nzWjdak6zZvJcmafV23eeu4v0VSb2vuEQgSwHPPnuP6Oz427jIW9fR9t4y7BKk39+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxvUK+iR7kpxJMpPkziH9tyZ5LMmpJH+SZOdA37u7eWeSvGUli5ckjTYy6JOsA44AbwV2Au8cDPLOA1X1+qraBbwXeH83dyewH/hBYA/w6932JEmrpM8e/W5gpqrOVtWLwHFg3+CAqvrawOqrgeqW9wHHq+qFqvoLYKbbniRplazvMWYTcG5gfRZ448JBSW4Dbgc2AD81MPeRBXM3DZl7EDgIsHXr1j51S5J66rNHnyFt9W0NVUeq6vuAO4Bfvsy5R6tqsqomJyYmepQkSeqrT9DPAlsG1jcD5y8x/jjwtiXOlSStsD5BfxLYkWR7kg3Mn1ydGhyQZMfA6k8DX+yWp4D9Sa5Jsh3YAXxm+WVLkvoaeYy+quaSHAIeAtYBx6rqdJLDwHRVTQGHktwI/B3wPHCgm3s6yYPA48AccFtVvXSFvhZJ0hB9TsZSVSeAEwva7h5Y/oVLzH0P8J6lFihJWh7vjJWkxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY3rFfRJ9iQ5k2QmyZ1D+m9P8niSLyT5wyTXD/S9lORU95payeIlSaOtHzUgyTrgCHATMAucTDJVVY8PDPscMFlVX0/y74D3Aj/b9X2jqnatcN2SpJ767NHvBmaq6mxVvQgcB/YNDqiqT1bV17vVR4DNK1umJGmp+gT9JuDcwPps17aYdwEfH1h/VZLpJI8keduwCUkOdmOmL1y40KMkSVJfIw/dABnSVkMHJj8HTAI/MdC8tarOJ3kt8Ikkj1XVk6/YWNVR4CjA5OTk0G1Lkpamzx79LLBlYH0zcH7hoCQ3AncBe6vqhW+2V9X57s+zwKeAG5ZRryTpMvUJ+pPAjiTbk2wA9gOvuHomyQ3A/cyH/FcG2q9Nck23vBH4UWDwJK4k6QobeeimquaSHAIeAtYBx6rqdJLDwHRVTQHvA14D/F4SgGeqai/wOuD+JC8z/0vlVxdcrSNJusL6HKOnqk4AJxa03T2wfOMi8/4UeP1yCpQkLY93xkpS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1rlfQJ9mT5EySmSR3Dum/PcnjSb6Q5A+TXD/QdyDJF7vXgZUsXpI02sigT7IOOAK8FdgJvDPJzgXDPgdMVtUbgI8A7+3mfjdwD/BGYDdwT5JrV658SdIoffbodwMzVXW2ql4EjgP7BgdU1Ser6uvd6iPA5m75LcDDVXWxqp4HHgb2rEzpkqQ++gT9JuDcwPps17aYdwEfv5y5SQ4mmU4yfeHChR4lSZL66hP0GdJWQwcmPwdMAu+7nLlVdbSqJqtqcmJiokdJkqS++gT9LLBlYH0zcH7hoCQ3AncBe6vqhcuZK0m6cvoE/UlgR5LtSTYA+4GpwQFJbgDuZz7kvzLQ9RBwc5Jru5OwN3dtkqRVsn7UgKqaS3KI+YBeBxyrqtNJDgPTVTXF/KGa1wC/lwTgmaraW1UXk9zL/C8LgMNVdfGKfCWSpKFGBj1AVZ0ATixou3tg+cZLzD0GHFtqgZKk5fHOWElqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TG9Qr6JHuSnEkyk+TOIf1vSvLZJHNJ3r6g76Ukp7rX1EoVLknqZ/2oAUnWAUeAm4BZ4GSSqap6fGDYM8DPA784ZBPfqKpdK1CrJGkJRgY9sBuYqaqzAEmOA/uAvw/6qnqq63v5CtQoSVqGPoduNgHnBtZnu7a+XpVkOskjSd52WdVJkpatzx59hrTVZbzH1qo6n+S1wCeSPFZVT77iDZKDwEGArVu3XsamJUmj9NmjnwW2DKxvBs73fYOqOt/9eRb4FHDDkDFHq2qyqiYnJib6blqS1EOfoD8J7EiyPckGYD/Q6+qZJNcmuaZb3gj8KAPH9iVJV97IoK+qOeAQ8BDwBPBgVZ1OcjjJXoAkP5xkFngHcH+S09301wHTST4PfBL41QVX60iSrrA+x+ipqhPAiQVtdw8sn2T+kM7CeX8KvH6ZNUqSlsE7YyWpcQa9JDXOoJekxhn0ktS4Xidj1Z7rNm/luWfPjR4o6apn0P9/6rlnz3H9HR8bdxmLevq+W8ZdwiVdAyTDbhqXlu767/1ennruuRXfrkEvLcELXN5zQKQ+8uUvX5Hteoxekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxvUK+iR7kpxJMpPkziH9b0ry2SRzSd6+oO9Aki92rwMrVbgkqZ+RQZ9kHXAEeCuwE3hnkp0Lhj0D/DzwwIK53w3cA7wR2A3ck+Ta5ZctSeqrzx79bmCmqs5W1YvAcWDf4ICqeqqqvgC8vGDuW4CHq+piVT0PPAzsWYG6JUk99Qn6TcDgp0jPdm199Jqb5GCS6STTFy5c6LlpSVIffYJ+2Ccg9/24zF5zq+poVU1W1eTExETPTUuS+ugT9LPAloH1zcD5nttfzlxJ0groE/QngR1JtifZAOwHpnpu/yHg5iTXdidhb+7aJEmrZGTQV9UccIj5gH4CeLCqTic5nGQvQJIfTjILvAO4P8npbu5F4F7mf1mcBA53bZKkVbK+z6CqOgGcWNB298DySeYPywybeww4towaJUnL4J2xktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY3rFfRJ9iQ5k2QmyZ1D+q9J8rtd/6eTbOvatyX5RpJT3euDK1u+JGmU9aMGJFkHHAFuAmaBk0mmqurxgWHvAp6vqu9Psh+4D/jZru/Jqtq1wnVLknrqs0e/G5ipqrNV9SJwHNi3YMw+4Le65Y8Ab06SlStTkrRUfYJ+E3BuYH22axs6pqrmgL8Gvqfr257kc0n+KMmPD3uDJAeTTCeZvnDhwmV9AZKkS+sT9MP2zKvnmC8BW6vqBuB24IEk3/ltA6uOVtVkVU1OTEz0KEmS1FefoJ8FtgysbwbOLzYmyXrgu4CLVfVCVX0VoKoeBZ4EfmC5RUuS+usT9CeBHUm2J9kA7AemFoyZAg50y28HPlFVlWSiO5lLktcCO4CzK1O6JKmPkVfdVNVckkPAQ8A64FhVnU5yGJiuqingQ8CHk8wAF5n/ZQDwJuBwkjngJeDWqrp4Jb4QSdJwI4MeoKpOACcWtN09sPy3wDuGzPso8NFl1ihJWgbvjJWkxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TG9fqEqavJdZu38tyz58ZdhiStGc0F/XPPnuP6Oz427jLWvKfvu2XcJUhaJR66kaTGGfSS1DiDXpIa1yvok+xJcibJTJI7h/Rfk+R3u/5PJ9k20Pfurv1MkresXOmSpD5GBn2SdcAR4K3ATuCdSXYuGPYu4Pmq+n7gA8B93dydwH7gB4E9wK9325MkrZI+e/S7gZmqOltVLwLHgX0LxuwDfqtb/gjw5iTp2o9X1QtV9RfATLc9SdIq6XN55SZg8ML0WeCNi42pqrkkfw18T9f+yIK5mxa+QZKDwMFu9W+SnOlR10bgL4d1rJFLBxetb43Y+PR9t1jf0m3M2v37XfP/9rC+Rc3vI1/SYvVdv9iEPkE/7F2r55g+c6mqo8DRHrV86w2T6aqavJw5q8n6lsf6lm4t1wbWt1xLqa/PoZtZYMvA+mbg/GJjkqwHvgu42HOuJOkK6hP0J4EdSbYn2cD8ydWpBWOmgAPd8tuBT1RVde37u6tytgM7gM+sTOmSpD5GHrrpjrkfAh4C1gHHqup0ksPAdFVNAR8CPpxkhvk9+f3d3NNJHgQeB+aA26rqpRWq/bIO9YyB9S2P9S3dWq4NrG+5Lru+zO94S5Ja5Z2xktQ4g16SGndVB32SX0nybJJT3etfjrumYZL8YpJKsnHctXxTknuTfKH7vv1Bkn867poGJXlfkj/vavz9JP9o3DUNSvKOJKeTvJxkzVyKN+pxJeOU5FiSryT5s3HXMkySLUk+meSJ7u/2F8Zd06Akr0rymSSf7+r7z33nXtVB3/lAVe3qXifGXcxCSbYANwHPjLuWBd5XVW+oql3Ax4C7x13QAg8DP1RVbwD+D/DuMdez0J8B/wr443EX8k09H1cyTr/J/KNQ1qo54D9W1euAHwFuW2PfvxeAn6qqfw7sAvYk+ZE+E1sI+rXuA8B/YsiNYuNUVV8bWH01a6++P6iquW71EebvwVgzquqJqupzB/dq6vO4krGpqj9m/qq8NamqvlRVn+2W/y/wBEPu5B+Xmvc33ep3dK9eP7ctBP2h7r/3x5JcO+5iBiXZCzxbVZ8fdy3DJHlPknPAv2bt7dEP+jfAx8ddxFVg2ONK1kxQXU26J/DeAHx6vJW8UpJ1SU4BXwEerqpe9a35jxJM8r+AfzKk6y7gvwH3Mv9b7V7g15gPhVUzor5fAm5ezXoGXaq2qvofVXUXcFeSdwOHgHvWUn3dmLuY/y/1b69mbd17j6xvjen1yBFdWpLXAB8F/sOC//mOXXcf0q7unNXvJ/mhqhp5zmPNB31V3dhnXJLfYP5Y86parL4krwe2A5/vHlK0Gfhskt1V9dw4axviAeB/sspBP6q+JAeAW4A31xhu+LiM799a4SNHlinJdzAf8r9dVf993PUspqr+KsmnmD/nMTLor+pDN0muG1j9GXp8waulqh6rqn9cVduqahvzP4T/YrVCfpQkOwZW9wJ/Pq5ahkmyB7gD2FtVXx93PVeJPo8r0SK6R6t/CHiiqt4/7noWSjLxzavPkvxD4EZ6/txe1XfGJvkw82efC3gK+LdV9aWxFrWIJE8Bk1W1Jh7PmuSjwD8DXgaeBm6tqmfHW9W3dI/TuAb4atf0SFXdOsaSXiHJzwD/FZgA/go4VVVj/wS17hLj/8K3HlfynjGX9PeS/A7wk8w/ZvfLwD1V9aGxFjUgyY8B/xt4jPmfC4BfWitX8yV5A/Of+7GO+Z30B6vqcK+5V3PQS5JGu6oP3UiSRjPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuP+H/R8iPejwLKnAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# unequal bins. density = True (frequency density)\n",
    "n, bins, patches = plt.hist(data, bins = np.array([min(data), -3, -2, -1, max(data)]), density = True, edgecolor='black')\n",
    "patches[3].set_fc(\"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Drawing several plots per canvas\n",
    "\n",
    "Multiple plots per canvas can be drawn by using the function `subplot()` to setup a grid and activate one plot per time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: MacOSX\n"
     ]
    }
   ],
   "source": [
    "%matplotlib auto\n",
    "\n",
    "x = np.arange(1, 150)\n",
    "y_base10_log = np.log10(x)\n",
    "y_natural_log = np.log(x)\n",
    "y_base2_log = np.log2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1166898d0>"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1166a87f0>]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Base 10 Log')"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set up a 2 x 2 grid, set the first plot as active and draw the first curve\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(x, y_base10_log)\n",
    "plt.title('Base 10 Log')\n",
    "\n",
    "# uncomment to compare subplots with the same y-axis limits\n",
    "# plt.ylim(0,8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11652a128>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11652a160>]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Natural Log')"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# activate the second subplot and draw the second curve\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(x, y_natural_log)\n",
    "plt.title('Natural Log')\n",
    "\n",
    "# uncomment to compare subplots with the same y-axis limits\n",
    "# plt.ylim(0,8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1164df080>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1164df0b8>]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Base 2 Log')"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# activate the third subplot and draw the third curve\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.plot(x, y_base2_log)\n",
    "plt.title('Base 2 Log')\n",
    "\n",
    "# uncomment to compare subplots with the same y-axis limits\n",
    "# plt.ylim(0,8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.tight_layout()  # adjust spacing between subplots to minimize the overlaps.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Further Reading:**\n",
    ">\n",
    "> Tutorial introductions to the Python scientific computing libraries (including other libraries that we'll briefly use in this class, such as \"SciPy\", \"Pandas\" and \"scikit-learn\") can be found in:\n",
    ">\n",
    "> - the [SciPy Lecture Notes](http://www.scipy-lectures.org/) ( the [pdf version](http://www.scipy-lectures.org/_downloads/ScipyLectures-simple.pdf)).\n",
    ">\n",
    ">\n",
    "> - The `python-course.eu` section dedicated to [Numerical Python](https://www.python-course.eu/numerical_programming.php).\n",
    ">\n",
    ">\n",
    "> - For a gentle introduction to the main matplotlib modules, have a look at the [beginner's guide](https://matplotlib.org/users/beginner.html) available on `matplotlib.org`.\n",
    ">\n",
    ">\n",
    "> - An excellent plotting package built on top of matplotlib is called [`Seaborn`](https://seaborn.pydata.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.\n",
    "\n",
    "Plot the sine and the cosine waves in the same graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.\n",
    "\n",
    "Read the file data/adams-hhgttg.txt and:\n",
    "\n",
    "\n",
    "- count the occurrences of each word.\n",
    "\n",
    "\n",
    "- Create a graph plotting word frequencies (on the **y-axis**) by words sorted by frequency (that is, you list the corpus words from the most frequency to the least frequent words **x-axis**). For clarity, please do not report the words in the x-axis label.\n",
    "\n",
    "\n",
    "- In a similar graph, plot the frequencies of the top-frequent 25 words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}