chap03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programmation Python  pour les mathématiques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Julien Guillod**, [Sorbonne Université](http://www.sorbonne-universite.fr/),\n",
    "Licence <a href=\"https://creativecommons.org/licenses/by-nc-nd/4.0/\">CC BY-NC-ND</a>\n",
    "\n",
    "L'entier des chapitres est disponible au format\n",
    "[HTML](https://python.guillod.org/) et [PDF](https://python.guillod.org/python.pdf).\n",
    "Ce notebook peut également être exécuté sur [GESIS](https://notebooks.gesis.org/binder/v2/gh/guillod/python/master?urlpath=lab/tree/chap03.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Structures homogènes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ch:numpy\"></div>\n",
    "\n",
    "Les structures de données par défaut de Python permettent de gérer des données hétérogènes (par exemple des entiers et des chaînes de caractères). Cette particularité fait que les structures de données Python sont extrêmement flexibles, au détriment de la performance. En effet vu que des données hétérogènes doivent pouvoir être supportées, il n'est pas possible d'allouer une plage de mémoire fixe pour une structure de données, ce qui ralentit son utilisation.  Particulièrement en mathématiques, il apparaît très régulièrement des ensembles de données homogènes de tailles fixes (liste d'entiers, vecteurs réels ou complexes, matrices...). Le module Numpy définit le type `ndarray` qui est optimisé pour de telles structures de données homogènes de tailles fixes. La documentation de Numpy est disponible [ici](https://numpy.org/doc/stable/).\n",
    "\n",
    "Pour charger le module Numpy, il est d'usage de procéder ainsi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Concepts abordés:**\n",
    "\n",
    "* tableau de données homogènes\n",
    "\n",
    "* slicing\n",
    "\n",
    "* opérations vectorielles\n",
    "\n",
    "* indexage et sélection\n",
    "\n",
    "* représentations graphiques\n",
    "\n",
    "* optimisation par parallélisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercice 3.1: Introduction à Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Création.**\n",
    "La taille et le type des éléments d'un tableau Numpy doivent être connus à l'avance. La première façon de créer un tableau Numpy est de construire un tableau rempli de zéros en spécifiant la taille et le type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array0 = np.zeros(3, dtype=int) # vecteur de 3 entiers\n",
    "array1 = np.zeros((2,4), dtype=float) # tableau de flottants de taille 2x4\n",
    "array2 = np.zeros((2,2), dtype=complex) # matrice carrée complexe de taille 2x2\n",
    "array3 = np.zeros((5,6,4)) # tableau tridimensionnel de flottants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La seconde façon est de passer directement les données:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array4 = np.array([1,4,5]) # vecteur d'entiers (1,4,5)\n",
    "array5 = np.array([[1.1,2.2,3.3,4.4],[1,2,3,4]]) # matrice de taille 2x4 de flottants\n",
    "array6 = np.array([[1+1j,0.4],[3,1.5]]) # matrice complexe de taille 2x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy va alors déterminer lui-même le type et la taille du tableau. À noter qu'il est possible de forcer le type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array0 = np.array([1,4,5], dtype=complex) # vecteur de complexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le type des éléments du tableau Numpy `array1` peut être déterminé par `array1.dtype`. La taille de ce tableau est donnée par `array1.shape`.\n",
    "Les commandes suivantes permettent d'accéder aux éléments des tableaux :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array4[1] # retourne 4\n",
    "array5[1,3] # retourne 4.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À noter que les indices commencent à 0 et non pas à 1.\n",
    "Les tableaux Numpy sont mutables dans le sens où les données peuvent être modifiées mais en conservant le même type et la même taille:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array0[1] = 4\n",
    "array1[1,3] = 3.3\n",
    "array3[3,4,2] = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Slicing.**\n",
    "Le slicing permet d'accéder à certaines parties d'un tableau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array4[2:3] # retourne les éléments d'indices compris entre 2 et 3\n",
    "array1[0,:] # retourne la première ligne de array1\n",
    "array1[:,-1] # retourne la dernière colonne de array1\n",
    "array3[3,3:5,1:4] # retourne la sous-matrice correspondante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Itération.**\n",
    "Il est possible d'itérer un tableau sur sa première dimension, par exemple pour retourner la somme des lignes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for i in array5:\n",
    "    print(np.sum(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**a)**\n",
    "Étudier la documentation de la fonction `arange` et utiliser cette fonction pour générer les vecteurs (5,6,7,8,9) et (3,5,7,9).\n",
    "\n",
    "**Indication:**\n",
    "La documentation de la fonction `arange` est disponible [ici](https://numpy.org/doc/stable/reference/generated/numpy.arange.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)**\n",
    "Étudier la documentation de la fonction `linspace` et l'utiliser pour générer 10 points équidistribués dans l'intervalle $[2,5]$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c)**\n",
    "Lire la documentation de la fonction `reshape` et effectuer successivement les transformations suivantes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "(1,2,3,4,5,6)\\to\\begin{pmatrix}1 & 2\\\\ \n",
    "3 & 4\\\\ \n",
    "5 & 6\n",
    "\\end{pmatrix}\\to\\begin{pmatrix}1 & 2 & 3\\\\ \n",
    "4 & 5 & 6\n",
    "\\end{pmatrix}\\to\\begin{pmatrix}1 & 4\\\\ \n",
    "2 & 5\\\\ \n",
    "3 & 6\n",
    "\\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercice 3.2: Opérations sur les tableaux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les opérations arithmétiques de base sur les tableaux Numpy sont effectuées éléments par éléments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mat1 = np.array([[1,2.5,3],[5,6.1,8],[3,2,5]])\n",
    "mat2 = np.array([[1,0.5,0],[0,0.9,8],[2,0,0]])\n",
    "mat1 + mat2 # retourne la somme élément par élément\n",
    "mat1 * mat2 # retourne le produit élément par élément (pas le produit matriciel)\n",
    "10*mat1**2 # retourne 10 fois le carré des éléments de mat1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La plupart des fonctions mathématiques définies par Numpy (voir [ici](https://numpy.org/doc/stable/reference/routines.math.html)) sont aussi effectuées éléments par éléments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.cos(mat1) # retourne le cosinus élément par élément de mat1\n",
    "np.exp(mat1) # retourne l'exponentielle élément par élément de mat1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le produit matriciel peut être effectué d'une des trois façons suivantes, mais la dernière méthode est recommandée pour sa lisibilité (surtout quand plusieurs produits matriciels sont effectués):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.dot(mat1,mat2)\n",
    "mat1.dot(mat2)\n",
    "mat1 @ mat2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**a)**\n",
    "Donné un vecteur $(v_0,v_1,\\dots,v_{n-1})\\in\\mathbb{R}^n$ la dérivée discrète de ce vecteur est définie par le vecteur $(d_0,d_1,\\dots,d_{n-2})\\in\\mathbb{R}^{n-1}$ donné par $d_i = v_{i+1}-v_{i}$ pour $i=0,1,\\dots,n-2$.\n",
    "\n",
    "Écrire une fonction `diff_list` qui calcule la dérivée discrète d'une liste et une fonction `diff_np` qui fait la même opération mais sur des vecteurs Numpy en utilisant le slicing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)**\n",
    "Soit `a_list` et `a_np` respectivement une liste et un tableau de 1 000 éléments tirés au hasard dans l'intervalle [0,1]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a_list = [np.random.random() for _ in range(1000)]\n",
    "a_np = np.random.random(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparer le temps d'exécution de `diff_list(a_list)` et de `diff_np(a_np)`.\n",
    "\n",
    "**Indication:**\n",
    "Dans Jupyter Lab, il est très facile de déterminer le temps pris par une cellule pour s'évaluer, il suffit de commencer la cellule par `%%time`, par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "result = diff_list(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour évaluer la cellule à de multiples reprises et faire une moyenne sur le temps d'exécution afin d'obtenir un résultat plus précis, remplacer `%%time` par `%%timeit`. La documentation est disponible [ici](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-timeit).\n",
    "\n",
    "**Réponse:**\n",
    "Le temps d'exécution avec les tableaux Numpy devrait être approximativement 50 à 100 fois plus rapide qu'avec les listes !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercice 3.3: Représentations graphiques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module `matplotlib` permet de faire des représentations graphiques très variées. Pour l'utiliser, il est d'usage de l'importer ainsi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A noter que la première ligne permet de représenter les graphiques directement dans Jupyter Lab, mais n'est pas indispensable.\n",
    "\n",
    "Par exemple la fonction `plot` peut être utilisée pour représenter la fonction $x^2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0,1,50)\n",
    "y = x**2\n",
    "plt.plot(x,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afin de définir une jolie figure pouvant être exportée, la syntaxe est la suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(8,5)) # taille de la figure (en inches)\n",
    "plt.title(r'Graphique de $x^2$') # titre de la figure (du code LaTeX peut être inclus)\n",
    "plt.xlabel(r'$x$') # titre de l'axe horizontal\n",
    "plt.ylabel(r'$y$') # titre de l'axe vertical\n",
    "plt.plot(x, y, marker='o', label=r\"$x^2$\") # légende\n",
    "plt.legend() # affiche la légende\n",
    "plt.savefig(\"test.pdf\") # exporte la figure en PDF\n",
    "plt.savefig(\"test.png\", dpi=100) # exporte la figure en PNG\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><img src=\"https://python.guillod.org/fig/matplotlib-x2.png\" style=\"width:90%;max-width:800px;\"></center>\n",
    "\n",
    "La documentation de Matplotlib est disponible [ici](https://matplotlib.org/users/index.html).\n",
    "\n",
    "**a)**\n",
    "Représenter graphiquement sur la même figure les fonctions $\\sin(kx)$ et $\\cos(kx)$ pour $k=1,2,3$ pour $x\\in[0,2\\pi]$. Faire en sorte que les graduations sur l'axe horizontal soient tous les $\\frac{\\pi}{2}$:\n",
    "\n",
    "<center><img src=\"https://python.guillod.org/fig/matplotlib-sincos.png\" style=\"width:90%;max-width:800px;\"></center>\n",
    "\n",
    "**Indication:**\n",
    "Utiliser la fonction `xticks` ou les fonctions `set_xticks` et `set_xticklabels` décrites [ici](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.xticks.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)**\n",
    "Regarder l'aide de la fonction `imshow` et l'utiliser pour représenter graphiquement une matrice de nombres aléatoires dans $[0,1]$ de taille $10\\times10$:\n",
    "\n",
    "<center><img src=\"https://python.guillod.org/fig/matplotlib-imshow.png\" style=\"width:90%;max-width:400px;\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c)**\n",
    "<span style=\"color:red\">!</span> Représenter graphiquement la fonction $f(x,y) = \\frac{-y}{5} + e^{-x^2-y^2}$ pour $x\\in[-3,3]$ et $y\\in[-3,3]$ en densité et avec des courbes de niveau:\n",
    "\n",
    "<center><img src=\"https://python.guillod.org/fig/matplotlib-2d.png\" style=\"width:90%;max-width:900px;\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**d)**\n",
    "<span style=\"color:red\">!!</span> Regarder les exemples disponibles [ici](https://matplotlib.org/tutorials/introductory/sample_plots.html) et en choisir deux à comprendre et à modifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercice 3.4: <span style=\"color:red\">!</span> Indexage de tableaux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le slicing permet de sélectionner des blocs dans un tableau, mais il est également possible de sélectionner des éléments disparates en utilisant un tableau comme indexage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.arange(12)**2 # tableau des carrés parfaits\n",
    "i = np.array([1,3,8,5]) # tableau d'indices\n",
    "a[i] # tableau des éléments de a aux places i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À noter qu'il est également possible d'indexer par un tableau de dimension supérieure. Le résultat est alors un tableau de la même forme que l'index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "j = np.array([[3,4],[9,7]]) # tableau bidimensionnel d'indices\n",
    "a[j] # sélectionne les éléments de a avec les indices j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour un tableau à plusieurs dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = np.array([[0,1,2,3],[4,5,6,7],[8,9,10,11]])\n",
    "i = np.array([0,1,2,2]) # tableau des premiers indices\n",
    "j = np.array([1,0,3,1]) # tableau des seconds indices\n",
    "b[i,j] # sélectionne les éléments d'indices ij"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin il est possible d'indexer un tableau pour un tableau de booléens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = np.array([[0,1,2,3],[4,5,6,7],[8,9,10,11]])\n",
    "cond = (c >= 5) # tableau de booléens valant True si >= 5 et False sinon\n",
    "c[cond] = 5 # assigne la valeur 5 à toutes les entrées de c plus grandes que 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour la suite, on considère les nombres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[0.9602, -0.99, 0.2837, 0.9602, 0.7539, -0.1455, -0.99, -0.9111, 0.9602, -0.1455, -0.99, 0.5403, -0.99, 0.9602, 0.2837, -0.99, 0.2837, 0.9602]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "comme étant les résultats d'une mesure effectuée toutes les 0.1 seconde aux temps compris entre 2 et 3.7 secondes.\n",
    "\n",
    "**a)**\n",
    "Les mesures étant censées être positives, modifier les données pour mettre 0 lorsque les valeurs sont négatives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)**\n",
    "Calculer les temps pour lesquels les mesures précédentes sont maximales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c)**\n",
    "Pour chaque mesure maximale retourner la mesure précédente, la mesure maximale et la mesure suivante. Si la mesure précédente ou la suivante n'existent pas, les remplacer par `np.nan`."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}