03-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:#FFF; background:#07D; padding:12px; font-size:20px; font-style:italic; text-align:center\">\n",
    "<span style=\"width:49%; display:inline-block; text-align:left\">Christophe Schlick</span>\n",
    "<span style=\"width:49%; display:inline-block; text-align:right\">schlick[at]u-bordeaux.fr</span>\n",
    "<span style=\"font-size:48px; font-style:normal\"><b>NUMPY</b></span><br>\n",
    "<span style=\"width:49%; display:inline-block; text-align:left\">Version 2022-09</span>\n",
    "<span style=\"width:49%; display:inline-block; text-align:right\">Licence CC-BY-NC-ND</span></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le package [**numpy**](https://numpy.org) (contraction de ***Numerical Python***) fournit à Python des outils flexibles et efficaces pour le stockage et la manipulation de données homogènes ordonnées. La documentation complète du package se trouve sur le site officiel [**numpy.org**](https://numpy.org/doc/smatrice/), mais une copie locale est directement disponible dans le menu **`Help`** de JupyterLab, sous le titre ***NumPy Reference***.. Ce notebook a pour objet de faire un tour d'horizon rapide des fonctionnalités les plus utiles de **numpy** dans le cadre d'une utilisation en imagerie numérique. \n",
    "\n",
    "L'apport principal du package **numpy** au langage Python consiste en un nouveau conteneur ordonné, appelé **`array`**, qui permet de stocker efficacement des ***données homogènes ordonnées selon plusieurs dimensions***. Le terme \"**array**\" peut se traduire en français de plusieurs manières : *panoplie, palette, éventail, gamme, collection, table*, mais aucun de ces termes n'inclut la notion de multi-dimensionalité présente dans la nature du conteneur. La traduction la plus proche serait **table**, mais ce terme a une sémantique très forte dans le domaine des bases de données, ce qui risque d'engendrer une confusion. Au final, la traduction par **matrice multi-dimensionnelle** ou **matrice nD** semble la plus cohérente, et c'est celle qui sera utilisée dans ce cours. Pour les matrices de dimension 1, on pourra également employer le terme usuel de **vecteur**.\n",
    "\n",
    "Le terme \"**données homogènes**\" signifie que tous les éléments stockés dans un conteneur **`array`** doivent être du même type, ce qui implique que chaque élément occupe exactement le même espace dans la mémoire de l'ordinateur. Par conséquent, en stockant les éléments de manière juxtaposée en mémoire, il est possible d'accéder de manière très efficace à chacun d'eux, par simple décalage par rapport à l'adresse de base de la matrice. A l'inverse, le conteneur **`list`** disponible dans le noyau du langage Python, est une structure destinée à stocker des ***données hétérogènes*** (chaque élément d'une liste peut avoir son type propre) ce qui interdit un stockage compact et un accès efficace aux données individuelles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "On importe habituellement le package **numpy** par le biais d'un alias court, avec la commande suivante :\n",
    "\n",
    "> **`import numpy as np`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # import du package 'numpy' avec alias 'np'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce notebook, on va également utiliser très fréquemment la fonction **`show`**, qui permet de simplifier grandement certaines explications. Comme il ne s'agit pas d'une fonction standard de Python, il faut commencer par l'importer du module **`tools`** se trouvant dans le dossier **SRC** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from SRC.tools import show # import de la fonction 'show' du module 'tools' dans le dossier SRC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A la différence de la fonction **`print`** qui n'affiche que la valeur des expressions données en paramètres, la fonction **`show`** permet d'***afficher à la fois l'expression initiale et la valeur de cette expression***, à condition de mettre l'expression entre guillemets. Plusieurs expressions peuvent être évaluées en séquence, en les séparant par des **points virgule**, chacune de ces expressions s'affichera alors sur une ligne séparée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 2 + 3 + 4 ━► 10\n",
      "\n",
      "a ━► 0\n",
      "b ━► ♠ ♣ ♥ ♦\n",
      "c ━► [1, 2, 3]\n",
      "d ━► {'a': 1, 'b': 2, 'c': 3}\n",
      "\n",
      "12**345 ━►\n",
      "2077446682327378559843444695582704973572786912705232236931705903179519704325276892191015329301807037794598378537132233994613616420526484930777273718077112370160566492728059713895917217042738578562985773221381211423961068296308572143393854703167926779929682604844469621152130457090778409728703018428147734622401526422774317612081074841839507864189781700150115308454681772032\n"
     ]
    }
   ],
   "source": [
    "a, b, c, d = 0, '♠ ♣ ♥ ♦', [1, 2, 3], dict(a=1, b=2, c=3)\n",
    "show(\"1 + 2 + 3 + 4;; a; b; c; d;; 12**345#\")\n",
    "# chaque caractère ';' génère un retour à la ligne (et donc un ';;' va créer un saut de ligne)\n",
    "# lorsqu'une valeur est trop longue pour tenir sur une ligne, on peut améliorer la lisibilité en rajoutant\n",
    "# un suffixe '#' qui va insérer un retour à la ligne entre l'expression et sa valeur "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"padding:16px; color:#FFF; background:#07D\">A - Création de matrices</h2>\n",
    "\n",
    "### 1 - Création de matrices à partir de listes Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création d'une matrice 1D (= vecteur) à partir d'une liste Python\n",
    "a = np.array([1,-2,3,-4,-5,6,-7,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2,  3, -4, -5,  6, -7,  8])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a # affichage par défaut (le préfixe 'array' indique une matrice numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -2  3 -4 -5  6 -7  8]\n"
     ]
    }
   ],
   "source": [
    "print(a) # affichage plus compact et plus lisible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ━► [ 1 -2  3 -4 -5  6 -7  8]\n"
     ]
    }
   ],
   "source": [
    "show(\"a\") # idem avec la fonction 'show'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En plus des données brutes stockées dans la matrice, le type **`array`** possède un certain nombre de propriétés, accessibles par la notation pointée :\n",
    "\n",
    "- **`.ndim`** = nombre de dimensions de la matrice\n",
    "- **`.shape`** = nombre d'éléments pour chacune des dimensions\n",
    "- **`.size`** = nombre total d'éléments de la matrice\n",
    "- **`.itemsize`** = nombre d'octets par élément\n",
    "- **`.nbytes`** = nombre d'octets pour la matrice\n",
    "- **`.dtype`** = type de donnée des éléments de la matrice (selon la nomenclature **numpy**)\n",
    "\n",
    "La liste des types de données utilisables avec numpy se trouve sur **[cette page](https://numpy.org/doc/stable/reference/arrays.dtypes.html)** du manuel de référence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ━► [ 1 -2  3 -4 -5  6 -7  8]\n",
      "a.ndim ━► 1\n",
      "a.shape ━► (8,)\n",
      "a.size ━► 8\n",
      "a.itemsize ━► 4\n",
      "a.nbytes ━► 32\n",
      "a.dtype ━► int32\n"
     ]
    }
   ],
   "source": [
    "show(\"a; a.ndim; a.shape; a.size; a.itemsize; a.nbytes; a.dtype\") # propriétés de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b ━► [ 1. -2.  3. -4. -5.  6. -7.  8.]\n",
      "b.ndim ━► 1\n",
      "b.shape ━► (8,)\n",
      "b.size ━► 8\n",
      "b.itemsize ━► 8\n",
      "b.nbytes ━► 64\n",
      "b.dtype ━► float64\n",
      "\n",
      "c ━► [ 1. -2.  3. -4. -5.  6. -7.  8.]\n",
      "c.ndim ━► 1\n",
      "c.shape ━► (8,)\n",
      "c.size ━► 8\n",
      "c.itemsize ━► 4\n",
      "c.nbytes ━► 32\n",
      "c.dtype ━► float32\n",
      "\n",
      "d ━► [ 1 -2  3 -4 -5  6 -7  8]\n",
      "d.ndim ━► 1\n",
      "d.shape ━► (8,)\n",
      "d.size ━► 8\n",
      "d.itemsize ━► 2\n",
      "d.nbytes ━► 16\n",
      "d.dtype ━► int16\n"
     ]
    }
   ],
   "source": [
    "# création d'une matrice 1D en forçant le type des éléments\n",
    "b = np.array([1,-2,3,-4,-5,6,-7,8], dtype=float) # on peut utiliser un type standard\n",
    "show(\"b; b.ndim; b.shape; b.size; b.itemsize; b.nbytes; b.dtype;\")\n",
    "c = np.array([1,-2,3,-4,-5,6,-7,8], dtype=np.float32) # ou un type spécifique numpy\n",
    "show(\"c; c.ndim; c.shape; c.size; c.itemsize; c.nbytes; c.dtype;\")\n",
    "d = np.array([1,-2,3,-4,-5,6,-7,8], dtype='i2') # ou une chaîne avec la notation courte\n",
    "show(\"d; d.ndim; d.shape; d.size; d.itemsize; d.nbytes; d.dtype\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ━►\n",
      "[[ 1 -2  3 -4]\n",
      " [-5  6 -7  8]]\n",
      "a.ndim ━► 2\n",
      "a.shape ━► (2, 4)\n",
      "a.size ━► 8\n",
      "a.itemsize ━► 4\n",
      "a.nbytes ━► 32\n",
      "a.dtype ━► int32\n"
     ]
    }
   ],
   "source": [
    "# création d'une matrice 2D à partir d'une liste de listes\n",
    "a = np.array([[1,-2,3,-4], [-5,6,-7,8]])\n",
    "show(\"a#; a.ndim; a.shape; a.size; a.itemsize; a.nbytes; a.dtype\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b ━►\n",
      "[['1' '-2' '3' '-4']\n",
      " ['-5' '6' '-7' '8']]\n",
      "b.ndim ━► 2\n",
      "b.shape ━► (2, 4)\n",
      "b.size ━► 8\n",
      "b.itemsize ━► 8\n",
      "b.nbytes ━► 64\n",
      "b.dtype ━► <U2\n",
      "\n",
      "c ━►\n",
      "[['1' '-2' '3' '-4']\n",
      " ['-5' '6' '-7' '8']]\n",
      "c.ndim ━► 2\n",
      "c.shape ━► (2, 4)\n",
      "c.size ━► 8\n",
      "c.itemsize ━► 24\n",
      "c.nbytes ━► 192\n",
      "c.dtype ━► <U6\n"
     ]
    }
   ],
   "source": [
    "# création d'une matrice 2D en forçant le type des éléments\n",
    "b = np.array([[1,-2,3,-4], [-5,6,-7,8]], dtype=str) # on peut utiliser le type standard 'str'\n",
    "# dans ce cas, la taille commune aux éléments de la matrice est calculée automatiquement\n",
    "show(\"b#; b.ndim; b.shape; b.size; b.itemsize; b.nbytes; b.dtype;\")\n",
    "c = np.array([[1,-2,3,-4], [-5,6,-7,8]], dtype='U6') # on peut utiliser le type 'U' (unicode)\n",
    "# dans ce cas, on définit explicitement une taille fixe pour les éléments de la matrice\n",
    "show(\"c#; c.ndim; c.shape; c.size; c.itemsize; c.nbytes; c.dtype\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 2 - Création de matrices à l'aide de fonctions génératrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros((3,5))) # création d'une matrice initialisée à 0 (type 'float' par défaut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros((3,5), dtype=int)) # idem en forçant le type à 'int'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros_like(a)) # création d'une matrice de 0 à partir d'une matrice existante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "print(np.ones((2,3,6))) # création d'une matrice initialisée à 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 1]\n",
      " [1 1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "print(np.ones_like(a)) # création d'une matrice de 1 à partir d'une matrice existante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[['x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x']\n",
      "  ['x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x']]\n",
      "\n",
      " [['x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x']\n",
      "  ['x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x']]\n",
      "\n",
      " [['x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x']\n",
      "  ['x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x' 'x']]]\n"
     ]
    }
   ],
   "source": [
    "print(np.full((3,2,12), 'x')) # création d'une matrice initialisée à une valeur donnée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[999 999 999 999]\n",
      " [999 999 999 999]]\n"
     ]
    }
   ],
   "source": [
    "print(np.full_like(a, 999)) # création d'une matrice initialisée à partir d'une matrice existante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.eye(3)) # création d'une matrice identité de taille 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0.]\n",
      " [1. 1. 0. 0. 0.]\n",
      " [1. 1. 1. 0. 0.]\n",
      " [1. 1. 1. 1. 0.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.tri(5)) # création d'une matrice triangulaire sur base carrée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 1. 1. 0. 0. 0. 0. 0.]\n",
      " [1. 1. 1. 1. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.tri(4,8)) # création d'une matrice triangulaire sur base rectangulaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 1. 1. 1. 0. 0. 0. 0. 0.]\n",
      " [1. 1. 1. 1. 1. 0. 0. 0. 0.]\n",
      " [1. 1. 1. 1. 1. 1. 0. 0. 0.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 0. 0.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.tri(6,9,2)) # création d'une matrice triangulaire avec décalage de diagonale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99 88 77 66 55 44 33 22 11]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(99,0,-11)) # création d'une matrice à partir d'un itérateur à pas entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n"
     ]
    }
   ],
   "source": [
    "print(np.linspace(0,1,11)) # idem avec un itérateur à pas linéaires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 5 4 1 4 4 6 6 1 6 6 3 2 5 2 6 3 3 4 3 1 1 5 4 5 4 3 5 1 6 6 3]\n",
      " [1 5 4 6 3 3 3 5 4 2 2 3 6 6 2 2 1 3 5 2 3 3 1 6 4 3 3 1 5 4 2 2]\n",
      " [5 4 5 3 4 1 1 5 3 4 5 5 5 3 5 3 5 4 3 5 2 1 2 1 5 2 6 6 5 3 2 5]\n",
      " [1 5 1 2 3 4 6 3 2 1 3 4 5 4 5 1 3 3 5 2 1 6 2 5 5 4 1 2 4 2 6 1]]\n"
     ]
    }
   ],
   "source": [
    "# création d'une matrice de valeurs aléatoires entières sur {1..6}\n",
    "print(np.random.randint(1, 7, (4,32))) # intervalle de valeurs, fermé à gauche, ouvert à droite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['A' 'A' 'B' 'B' 'B' 'A' 'A' 'C' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'B']\n",
      " ['B' 'C' 'A' 'B' 'B' 'B' 'A' 'A' 'B' 'A' 'A' 'B' 'B' 'B' 'A' 'B']\n",
      " ['B' 'B' 'B' 'B' 'A' 'A' 'B' 'A' 'B' 'B' 'C' 'B' 'A' 'A' 'A' 'B']\n",
      " ['B' 'A' 'B' 'A' 'A' 'B' 'A' 'A' 'A' 'B' 'A' 'B' 'B' 'A' 'A' 'B']\n",
      " ['A' 'C' 'B' 'A' 'A' 'B' 'B' 'A' 'C' 'A' 'B' 'B' 'B' 'A' 'B' 'B']\n",
      " ['C' 'A' 'B' 'A' 'B' 'B' 'B' 'A' 'A' 'A' 'B' 'A' 'B' 'A' 'B' 'A']]\n"
     ]
    }
   ],
   "source": [
    "# création d'une matrice obtenue par tirage aléatoire dans un ensemble\n",
    "print(np.random.choice(list('ABC'), (6,16), p=(0.6,0.3,0.1))) # p = probas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.15250585 0.58490779 0.15827285 0.68710984 0.55992038 0.76469127]\n",
      " [0.51060624 0.28193362 0.3912831  0.58732494 0.0119501  0.75593452]\n",
      " [0.67576893 0.15454372 0.54505352 0.15021239 0.90047813 0.78412939]\n",
      " [0.75668822 0.32000223 0.92657264 0.487417   0.11852543 0.51114689]]\n"
     ]
    }
   ],
   "source": [
    "# création d'une matrice de valeurs aléatoires réelles, distribution uniforme sur [0,1)\n",
    "print(np.random.rand(4,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.37420553 -1.32261555  1.25014999  2.09490746 -0.58471258 -0.04419177]\n",
      " [ 0.15737824 -0.00512635 -0.61940848 -0.14713127  0.44788934  0.06879132]\n",
      " [ 0.42367233  0.3296895  -0.24800177 -1.27784235  0.24949394  0.81331335]\n",
      " [ 0.62202164 -0.40214788 -2.79468013  1.90690854 -2.01049581  1.72304731]]\n"
     ]
    }
   ],
   "source": [
    "# idem avec distribution normale (avec moyenne = 0 et écart-type = 1)\n",
    "print(np.random.normal(0, 1, (4,6)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"padding:16px; color:#FFF; background:#07D\">B - Transformation de matrices</h2>\n",
    "\n",
    "### 1 - Modification de forme ou de dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,-2,3,-4], [-5,6,-7,8], [9, -10, 11, -12]]) # création d'une matrice de test\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -5   9]\n",
      " [ -2   6 -10]\n",
      " [  3  -7  11]\n",
      " [ -4   8 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a.T) # transposition de la matrice (= inversion de l'ordre des dimensions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1  -2   3  -4  -5   6  -7   8   9 -10  11 -12]\n"
     ]
    }
   ],
   "source": [
    "print(a.ravel()) # aplatissement de la matrice (= conversion en vecteur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1  -5   9  -2   6 -10   3  -7  11  -4   8 -12]\n"
     ]
    }
   ],
   "source": [
    "print(a.T.ravel()) # idem avec inversion de l'ordre des dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   1   1  -2  -2  -2   3   3   3  -4  -4  -4  -5  -5  -5   6   6   6\n",
      "  -7  -7  -7   8   8   8   9   9   9 -10 -10 -10  11  11  11 -12 -12 -12]\n"
     ]
    }
   ],
   "source": [
    "print(a.repeat(3)) # aplatissement avec répétition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   1   1  -5  -5  -5   9   9   9  -2  -2  -2   6   6   6 -10 -10 -10\n",
      "   3   3   3  -7  -7  -7  11  11  11  -4  -4  -4   8   8   8 -12 -12 -12]\n"
     ]
    }
   ],
   "source": [
    "print(a.T.repeat(3)) # idem avec inversion de l'ordre des dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4  -5   6  -7   8   9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a.reshape((1,12))) # modification de la forme d'une matrice (1 ligne, 12 colonnes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1]\n",
      " [ -2]\n",
      " [  3]\n",
      " [ -4]\n",
      " [ -5]\n",
      " [  6]\n",
      " [ -7]\n",
      " [  8]\n",
      " [  9]\n",
      " [-10]\n",
      " [ 11]\n",
      " [-12]]\n"
     ]
    }
   ],
   "source": [
    "print(a.reshape((12,1))) # idem (12 lignes, 1 colonne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4  -5   6]\n",
      " [ -7   8   9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a.reshape((2,6))) # idem (2 lignes, 6 colonnes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1  -2   3]\n",
      "  [ -4  -5   6]]\n",
      "\n",
      " [[ -7   8   9]\n",
      "  [-10  11 -12]]]\n"
     ]
    }
   ],
   "source": [
    "print(a.reshape((2,2,3))) # idem (2 plans, 2 lignes, 3 colonnes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1  -2]\n",
      "  [  3  -4]\n",
      "  [ -5   6]]\n",
      "\n",
      " [[ -7   8]\n",
      "  [  9 -10]\n",
      "  [ 11 -12]]]\n"
     ]
    }
   ],
   "source": [
    "# si on met -1 pour une dimension, sa taille sera calculée automatiquement\n",
    "print(a.reshape((2,-1,2))) # idem (2 plans, 3 lignes, 2 colonnes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1  -2   3  -4]\n",
      "  [ -5   6  -7   8]\n",
      "  [  9 -10  11 -12]]]\n"
     ]
    }
   ],
   "source": [
    "print(a[None, :, :]) # ajout d'une dimension en tête\n",
    "# a[None, ...] # version alternative : '...' représente toutes les dimensions restantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1  -2   3  -4]]\n",
      "\n",
      " [[ -5   6  -7   8]]\n",
      "\n",
      " [[  9 -10  11 -12]]]\n"
     ]
    }
   ],
   "source": [
    "print(a[:, None, :]) # ajout d'une dimension au centre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1]\n",
      "  [ -2]\n",
      "  [  3]\n",
      "  [ -4]]\n",
      "\n",
      " [[ -5]\n",
      "  [  6]\n",
      "  [ -7]\n",
      "  [  8]]\n",
      "\n",
      " [[  9]\n",
      "  [-10]\n",
      "  [ 11]\n",
      "  [-12]]]\n"
     ]
    }
   ],
   "source": [
    "print(a[:, :, None]) # ajout d'une dimension en queue\n",
    "# a[..., None]) # version alternative : '...' représente toutes les dimensions restantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 2 - Transformations particulières pour matrice 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -4   3  -2   1]\n",
      " [  8  -7   6  -5]\n",
      " [-12  11 -10   9]]\n"
     ]
    }
   ],
   "source": [
    "print(np.fliplr(a)) # transposition left <-> right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  9 -10  11 -12]\n",
      " [ -5   6  -7   8]\n",
      " [  1  -2   3  -4]]\n"
     ]
    }
   ],
   "source": [
    "print(np.flipud(a)) # transposition up <-> down"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -4   8 -12]\n",
      " [  3  -7  11]\n",
      " [ -2   6 -10]\n",
      " [  1  -5   9]]\n"
     ]
    }
   ],
   "source": [
    "print(np.rot90(a)) # rotation 90° (sens trigonométrique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-12  11 -10   9]\n",
      " [  8  -7   6  -5]\n",
      " [ -4   3  -2   1]]\n"
     ]
    }
   ],
   "source": [
    "print(np.rot90(a,2)) # rotation 180°"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  9  -5   1]\n",
      " [-10   6  -2]\n",
      " [ 11  -7   3]\n",
      " [-12   8  -4]]\n"
     ]
    }
   ],
   "source": [
    "print(np.rot90(a,3)) # rotation 270°"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3 - Répétition, assemblage et découpage de matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4   1  -2   3  -4   1  -2   3  -4]\n",
      " [ -5   6  -7   8  -5   6  -7   8  -5   6  -7   8]\n",
      " [  9 -10  11 -12   9 -10  11 -12   9 -10  11 -12]\n",
      " [  1  -2   3  -4   1  -2   3  -4   1  -2   3  -4]\n",
      " [ -5   6  -7   8  -5   6  -7   8  -5   6  -7   8]\n",
      " [  9 -10  11 -12   9 -10  11 -12   9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(np.tile(a,[2,3])) # répétition de la matrice (2x en vertical, 3x en horizontal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]\n",
      " [ -1   2  -3   4]\n",
      " [  5  -6   7  -8]\n",
      " [ -9  10 -11  12]\n",
      " [  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(np.vstack([a,-a,a])) # assemblage verticale (= en hauteur)\n",
    "# version alternative : np.concatenate([a,-a,a], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4  -1   2  -3   4   1  -2   3  -4]\n",
      " [ -5   6  -7   8   5  -6   7  -8  -5   6  -7   8]\n",
      " [  9 -10  11 -12  -9  10 -11  12   9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(np.hstack([a,-a,a])) # assemblage horizontale (= en largeur)\n",
    "# version alternative : np.concatenate([a,-a,a], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1  -2   3  -4]\n",
      "  [ -5   6  -7   8]\n",
      "  [  9 -10  11 -12]]\n",
      "\n",
      " [[ -1   2  -3   4]\n",
      "  [  5  -6   7  -8]\n",
      "  [ -9  10 -11  12]]\n",
      "\n",
      " [[  1  -2   3  -4]\n",
      "  [ -5   6  -7   8]\n",
      "  [  9 -10  11 -12]]]\n"
     ]
    }
   ],
   "source": [
    "print(np.stack([a,-a,a])) # assemblage sur un nouvel axe (= en profondeur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1  -1   1]\n",
      "  [ -2   2  -2]\n",
      "  [  3  -3   3]\n",
      "  [ -4   4  -4]]\n",
      "\n",
      " [[ -5   5  -5]\n",
      "  [  6  -6   6]\n",
      "  [ -7   7  -7]\n",
      "  [  8  -8   8]]\n",
      "\n",
      " [[  9  -9   9]\n",
      "  [-10  10 -10]\n",
      "  [ 11 -11  11]\n",
      "  [-12  12 -12]]]\n"
     ]
    }
   ],
   "source": [
    "print(np.dstack([a,-a,a])) # assemblage par position d'élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b ━►\n",
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]\n",
      " [ -1   2  -3   4]\n",
      " [  5  -6   7  -8]\n",
      " [ -9  10 -11  12]]\n",
      "c ━►\n",
      "[[ 1 -2  3 -4]\n",
      " [-5  6 -7  8]]\n",
      "d ━►\n",
      "[[  9 -10  11 -12]\n",
      " [ -1   2  -3   4]]\n",
      "e ━►\n",
      "[[  5  -6   7  -8]\n",
      " [ -9  10 -11  12]]\n"
     ]
    }
   ],
   "source": [
    "b = np.vstack([a,-a]); c, d, e = np.vsplit(b, 3) # découpage vertical (en parties équitables)\n",
    "show(\"b#; c#; d#; e#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b ━►\n",
      "[[  1  -2   3  -4  -1   2  -3   4   1  -2   3  -4]\n",
      " [ -5   6  -7   8   5  -6   7  -8  -5   6  -7   8]\n",
      " [  9 -10  11 -12  -9  10 -11  12   9 -10  11 -12]]\n",
      "c ━►\n",
      "[[  1  -2   3]\n",
      " [ -5   6  -7]\n",
      " [  9 -10  11]]\n",
      "d ━►\n",
      "[[ -4  -1   2  -3   4   1  -2]\n",
      " [  8   5  -6   7  -8  -5   6]\n",
      " [-12  -9  10 -11  12   9 -10]]\n",
      "e ━►\n",
      "[[  3  -4]\n",
      " [ -7   8]\n",
      " [ 11 -12]]\n"
     ]
    }
   ],
   "source": [
    "b = np.hstack([a,-a,a]); c, d, e = np.hsplit(b, [3,10]) # découpage horizontal (en parties ajustables)\n",
    "show(\"b#; c#; d#; e#\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"padding:16px; color:#FFF; background:#07D\">C - Accès aux éléments d'une matrice</h2>\n",
    "\n",
    "### 1 - Accès aux éléments par indices, par tranches et par énumérations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[0,0] ━► 1\n",
      "a[0,-1] ━► -4\n",
      "a[2,2] ━► 11\n",
      "a[-1,-1] ━► -12\n",
      "\n",
      "a[0,(3,1,2,0)] ━► [-4 -2  3  1]\n",
      "a[5*(0,1,2),-1] ━► [ -4   8 -12  -4   8 -12  -4   8 -12  -4   8 -12  -4   8 -12]\n",
      "a[(0,1,1,2),(3,1,2,0)] ━► [-4  6 -7  9]\n",
      "\n",
      "a[1,:] ━► [-5  6 -7  8]\n",
      "a[:,-1] ━► [ -4   8 -12]\n",
      "\n",
      "a[:,(3,1,2,0)] ━►\n",
      "[[ -4  -2   3   1]\n",
      " [  8   6  -7  -5]\n",
      " [-12 -10  11   9]]\n",
      "\n",
      "a[(0,1,1,2),:] ━►\n",
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n",
      "\n",
      "a[1:3,1:-1] ━►\n",
      "[[  6  -7]\n",
      " [-10  11]]\n",
      "\n",
      "a[::-1,::-1] ━►\n",
      "[[-12  11 -10   9]\n",
      " [  8  -7   6  -5]\n",
      " [ -4   3  -2   1]]\n"
     ]
    }
   ],
   "source": [
    "show(\"a[0,0]; a[0,-1]; a[2,2]; a[-1,-1];; a[0,(3,1,2,0)]; a[5*(0,1,2),-1]; a[(0,1,1,2),(3,1,2,0)];\")\n",
    "show(\"a[1,:]; a[:,-1];; a[:,(3,1,2,0)]#;; a[(0,1,1,2),:]#;; a[1:3,1:-1]#;; a[::-1,::-1]#\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 2 - Accès aux éléments par prédicats et méthodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[a > 0] ━► [ 1  3  6  8  9 11]\n",
      "a[abs(a) > 5] ━► [  6  -7   8   9 -10  11 -12]\n",
      "a[(a > 0) & (a < 7)] ━► [1 3 6]\n",
      "a[(a%2 == 0) | (a%3 == 0)] ━► [ -2   3  -4   6   8   9 -10 -12]\n"
     ]
    }
   ],
   "source": [
    "show(\"a[a > 0]; a[abs(a) > 5]; a[(a > 0) & (a < 7)]; a[(a%2 == 0) | (a%3 == 0)]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b ━►\n",
      "[[ 1  0  3  0]\n",
      " [ 0  6  0  8]\n",
      " [ 9  0 11  0]]\n",
      "\n",
      "c ━►\n",
      "[[  2  -2   6  -4]\n",
      " [-10   6 -14   8]\n",
      " [ 18 -10  22 -12]]\n"
     ]
    }
   ],
   "source": [
    "b, c = a.copy(), a.copy() # création de deux copies de la matrice 'a'\n",
    "b[b < 0] = 0 # mettre à 0 tous les éléments strictement négatifs\n",
    "c[c % 2 != 0] *= 2 # multiplier par 2 tous les éléments impairs\n",
    "show(\"b#;; c#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.where(a < 0, 0, a) ━►\n",
      "[[ 1  0  3  0]\n",
      " [ 0  6  0  8]\n",
      " [ 9  0 11  0]]\n",
      "\n",
      "np.where(a % 2 != 0, 2*a, a) ━►\n",
      "[[  2  -2   6  -4]\n",
      " [-10   6 -14   8]\n",
      " [ 18 -10  22 -12]]\n"
     ]
    }
   ],
   "source": [
    "show(\"np.where(a < 0, 0, a)#;; np.where(a % 2 != 0, 2*a, a)#\") # idem avec création à la volée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3 - Itération sur les éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value = [ 1 -2  3 -4]\n",
      "value = [-5  6 -7  8]\n",
      "value = [  9 -10  11 -12]\n"
     ]
    }
   ],
   "source": [
    "for value in a: # iteration sur l'axe majeur (= lignes pour matrice 2D)\n",
    "  print(f\"value = {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value = [ 1 -5  9]\n",
      "value = [ -2   6 -10]\n",
      "value = [ 3 -7 11]\n",
      "value = [ -4   8 -12]\n"
     ]
    }
   ],
   "source": [
    "for value in a.T: # iteration sur l'axe mineur (= colonnes pour matrice 2D)\n",
    "  print(f\"value = {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value = 1\n",
      "value = -2\n",
      "value = 3\n",
      "value = -4\n",
      "value = -5\n",
      "value = 6\n",
      "value = -7\n",
      "value = 8\n",
      "value = 9\n",
      "value = -10\n",
      "value = 11\n",
      "value = -12\n"
     ]
    }
   ],
   "source": [
    "for value in a.flat: # iteration avec aplatissement de la matrice\n",
    "  print(f\"value = {value}\")\n",
    "# on peut également itérer sur a.T.flat pour un parcours par colonnes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index = 0 ● value = 1\n",
      "index = 1 ● value = -2\n",
      "index = 2 ● value = 3\n",
      "index = 3 ● value = -4\n",
      "index = 4 ● value = -5\n",
      "index = 5 ● value = 6\n",
      "index = 6 ● value = -7\n",
      "index = 7 ● value = 8\n",
      "index = 8 ● value = 9\n",
      "index = 9 ● value = -10\n",
      "index = 10 ● value = 11\n",
      "index = 11 ● value = -12\n"
     ]
    }
   ],
   "source": [
    "for index, value in enumerate(a.flat): # iteration avec index 1D\n",
    "  print(f\"index = {index} ● value = {value}\") # access with a.flat[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index = (0, 0) ● value = 1\n",
      "index = (0, 1) ● value = -2\n",
      "index = (0, 2) ● value = 3\n",
      "index = (0, 3) ● value = -4\n",
      "index = (1, 0) ● value = -5\n",
      "index = (1, 1) ● value = 6\n",
      "index = (1, 2) ● value = -7\n",
      "index = (1, 3) ● value = 8\n",
      "index = (2, 0) ● value = 9\n",
      "index = (2, 1) ● value = -10\n",
      "index = (2, 2) ● value = 11\n",
      "index = (2, 3) ● value = -12\n"
     ]
    }
   ],
   "source": [
    "for index, value in np.ndenumerate(a): # iteration avec index nD\n",
    "  print(f\"index = {index} ● value = {value}\") # access with a[index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"padding:16px; color:#FFF; background:#07D\">D - Opérations sur les matrices</h2>\n",
    "\n",
    "### 1 - Manipulation par opérateurs\n",
    "\n",
    "Les opérateurs arithmétiques standards **`+  -  *  /  //  %  ** `** sont utilisables sur les matrices multidimensionnelles de type **`array`**. Ces opérateurs s'appliquent toujours ***élément par élément***, sur les deux matrices utilisées comme opérandes. A ces opérateurs standards, s'ajoute également l'opérateur **`@`** qui permet d'effectuer un ***produit matriciel*** entre deux matrices.\n",
    "\n",
    "Lors de l'application de l'opérateur, l'interpréteur va vérifier le paramètre **`shape`** (nombre d'éléments dans chaque dimension) des deux matrices pour savoir si l'opération choisie est possible. Si les valeurs de **`shape`** sont identiques pour les deux matrices, l'opérations va s'effectuer élément par élément, sans difficulté. Si les valeurs de **`shape`** sont différentes, mais que pour chaque dimension, le nombre d'éléments est soit le même pour les deux matrices, soit égal à 0 ou 1 pour l'une des matrices, l'opération est également possible grâce au principe du ***broadcasting*** mis en oeuvre par **`numpy`**. Cela consiste à répéter les données automatiquement les données existantes pour obtenir autant d'éléments sur chaque dimension que l'autre opérande. Le principe du broadcasting est assez intuitif, mais des explications détaillées sont disponibles sur [**cette page**](https://numpy.org/doc/stable/user/basics.broadcasting.html) du manuel d'utilisation de **`numpy`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + a ━►\n",
      "[[  2  -4   6  -8]\n",
      " [-10  12 -14  16]\n",
      " [ 18 -20  22 -24]]\n",
      "\n",
      "a * a ━►\n",
      "[[  1   4   9  16]\n",
      " [ 25  36  49  64]\n",
      " [ 81 100 121 144]]\n",
      "\n",
      "a % 4 ━►\n",
      "[[1 2 3 0]\n",
      " [3 2 1 0]\n",
      " [1 2 3 0]]\n",
      "\n",
      "a ** 4 ━►\n",
      "[[    1    16    81   256]\n",
      " [  625  1296  2401  4096]\n",
      " [ 6561 10000 14641 20736]]\n",
      "\n",
      "4 - 3*a + 2*a*a ━►\n",
      "[[  3  18  13  48]\n",
      " [ 69  58 123 108]\n",
      " [139 234 213 328]]\n"
     ]
    }
   ],
   "source": [
    "show(\"a + a#;; a * a#;; a % 4#;; a ** 4#;; 4 - 3*a + 2*a*a#\") # opérateurs avec ou sans broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a @ a.T ━►\n",
      "[[  30  -70  110]\n",
      " [ -70  174 -278]\n",
      " [ 110 -278  446]]\n",
      "\n",
      "a.T @ a ━►\n",
      "[[ 107 -122  137 -152]\n",
      " [-122  140 -158  176]\n",
      " [ 137 -158  179 -200]\n",
      " [-152  176 -200  224]]\n"
     ]
    }
   ],
   "source": [
    "show(\"a @ a.T#;; a.T @ a#\") # produit matriciel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Chacun des opérateurs arithmétiques **`+  -  *  /  //  %  **  @`** possède son équivalent sous forme de fonction : **`np.add, np.subtract, np.multiply, np.divide, np.floor_divide, np.mod, np.power, np.matmul`** . L'intérêt principal d'avoir cette double syntaxe est de pouvoir utiliser les opérateurs en tant que paramètre d'une fonction (ce qui peut s'avérer utile de temps en temps) mais également d'utiliser des paramètres optionnels permettant d'obtenir des modes supplémentaires pour les calculs. Par exemple, on peut utiliser le mode **`outer`** (mode externe, plus communément appelé, ***mode cartésien***) pour les opérations sur les vecteurs et les matrices, au lieu du mode **`inner`** (mode interne, autrement dit, ***élément par élément***) mis en oeuvre par défaut :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.add(a, a) ━►\n",
      "[[  2  -4   6  -8]\n",
      " [-10  12 -14  16]\n",
      " [ 18 -20  22 -24]]\n",
      "\n",
      "np.mod(a, 4) ━►\n",
      "[[1 2 3 0]\n",
      " [3 2 1 0]\n",
      " [1 2 3 0]]\n",
      "\n",
      "np.matmul(a, a.T) ━►\n",
      "[[  30  -70  110]\n",
      " [ -70  174 -278]\n",
      " [ 110 -278  446]]\n"
     ]
    }
   ],
   "source": [
    "show(\"np.add(a, a)#;; np.mod(a, 4)#;; np.matmul(a, a.T)#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z ━► [ 0  1  2  3  4  5  6  7  8  9 10]\n",
      "\n",
      "np.add.outer(z, z) ━►\n",
      "[[ 0  1  2  3  4  5  6  7  8  9 10]\n",
      " [ 1  2  3  4  5  6  7  8  9 10 11]\n",
      " [ 2  3  4  5  6  7  8  9 10 11 12]\n",
      " [ 3  4  5  6  7  8  9 10 11 12 13]\n",
      " [ 4  5  6  7  8  9 10 11 12 13 14]\n",
      " [ 5  6  7  8  9 10 11 12 13 14 15]\n",
      " [ 6  7  8  9 10 11 12 13 14 15 16]\n",
      " [ 7  8  9 10 11 12 13 14 15 16 17]\n",
      " [ 8  9 10 11 12 13 14 15 16 17 18]\n",
      " [ 9 10 11 12 13 14 15 16 17 18 19]\n",
      " [10 11 12 13 14 15 16 17 18 19 20]]\n",
      "\n",
      "np.multiply.outer(z[1:], z[1:]) ━►\n",
      "[[  1   2   3   4   5   6   7   8   9  10]\n",
      " [  2   4   6   8  10  12  14  16  18  20]\n",
      " [  3   6   9  12  15  18  21  24  27  30]\n",
      " [  4   8  12  16  20  24  28  32  36  40]\n",
      " [  5  10  15  20  25  30  35  40  45  50]\n",
      " [  6  12  18  24  30  36  42  48  54  60]\n",
      " [  7  14  21  28  35  42  49  56  63  70]\n",
      " [  8  16  24  32  40  48  56  64  72  80]\n",
      " [  9  18  27  36  45  54  63  72  81  90]\n",
      " [ 10  20  30  40  50  60  70  80  90 100]]\n"
     ]
    }
   ],
   "source": [
    "z = np.arange(11) # création d'un vecteur de test\n",
    "show(\"z;; np.add.outer(z, z)#;; np.multiply.outer(z[1:], z[1:])#\") # utilisation du mode cartésien"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Les opérateurs de comparaison **`==  !=  >  >=  <  <=`** peuvent également être utilisées sur les données de type **`array`** et renvoient une matrice de booléens, en effectuant la comparaison élément par élément. Comme pour les opérateurs arithmétiques, chaque opérateur de comparaison possède son équivalent sous forme de fonction : **`np.equal, np.not_equal, np.greater, np.greater_equal, np.less, np.less_equal`**. Les expressions booléennes résultant des comparaisons peuvent se combiner avec les opérateurs booléens classiques **`!  &  |  ^`**, qui eux-même possèdent leur équivalent fonctionnel : **`np.logical_not, np.logical_or, np.logical_and, np.logical_xor`** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a > 0 ━►\n",
      "[[ True False  True False]\n",
      " [False  True False  True]\n",
      " [ True False  True False]]\n",
      "\n",
      "np.less_equal(a, 0) ━►\n",
      "[[False  True False  True]\n",
      " [ True False  True False]\n",
      " [False  True False  True]]\n",
      "\n",
      "(a <= -8) | (a >= 2) ━►\n",
      "[[False False  True False]\n",
      " [False  True False  True]\n",
      " [ True  True  True  True]]\n",
      "\n",
      "np.logical_and(np.greater(a,-8), np.less(a,2)) ━►\n",
      "[[ True  True False  True]\n",
      " [ True False  True False]\n",
      " [False False False False]]\n",
      "\n",
      "np.less.outer(a.flat, z) ━►\n",
      "[[False False  True  True  True  True  True  True  True  True  True]\n",
      " [ True  True  True  True  True  True  True  True  True  True  True]\n",
      " [False False False False  True  True  True  True  True  True  True]\n",
      " [ True  True  True  True  True  True  True  True  True  True  True]\n",
      " [ True  True  True  True  True  True  True  True  True  True  True]\n",
      " [False False False False False False False  True  True  True  True]\n",
      " [ True  True  True  True  True  True  True  True  True  True  True]\n",
      " [False False False False False False False False False  True  True]\n",
      " [False False False False False False False False False False  True]\n",
      " [ True  True  True  True  True  True  True  True  True  True  True]\n",
      " [False False False False False False False False False False False]\n",
      " [ True  True  True  True  True  True  True  True  True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "show(\"a > 0#;; np.less_equal(a, 0)#;\")\n",
    "show(\"(a <= -8) | (a >= 2)#;; np.logical_and(np.greater(a,-8), np.less(a,2))#;\")\n",
    "show(\"np.less.outer(a.flat, z)#\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 2 - Manipulation par fonctions universelles\n",
    "\n",
    "En plus du conteneur **`array`** particulièrement flexible et efficace, l'autre apport majeur du package **`numpy`** consiste en une nouvelle famille de fonctions **`ufunc`**, appelées ***fonctions universelles***. La propriété commune de ces fonctions est qu'elles peuvent s'appliquer directement à des vecteurs ou des matrices multi-dimensionnelles, et qu'elles vont automatiquement générer une boucle permettant d'appliquer la fonction, élément par élément, sur l'ensemble de la structure. Ce processus, appelé **vectorisation**, permet non seulement d'écrire un code plus compact (proche de la notation algébrique utilisée en mathématiques) mais surtout beaucoup plus rapide qu'un code en Python pur (entre 20x et 30x plus rapide, en moyenne).\n",
    "\n",
    "Parmi les fonctions universelles fournies par **`numpy`**, on trouve notament les versions universelles des fonctions mathématiques figurant dans le module **`math`** standard de Python :\n",
    "\n",
    "**`abs`** ● **`sign`** ● **`floor`** ● **`ceil`** ● **`round`** ● **`deg2rad`** ● **`rad2deg`** ● **`real`** ● **`imag`** ● **`hypot`** ● **`angle`** ● **`sqrt`** ● **`exp`** ● **`log`** ● **`log2`** ● **`log10`** ● **`cos`** ● **`sin`** ● **`tan`** ● **`arccos`** ● **`arcsin`** ● **`arctan`** ● **`arctan2`** ● **`cosh`** ● **`sinh`** ● **`tanh`** ● **`arccosh`** ● **`arcsinh`** ● **`arctanh`** ● **`nonzero`** ● **`isclose`** ● **`isfinite`** ● **`isinf`** ● **`isnan`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.abs(a) ━►\n",
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "np.sign(a) ━►\n",
      "[[ 1 -1  1 -1]\n",
      " [-1  1 -1  1]\n",
      " [ 1 -1  1 -1]]\n",
      "\n",
      "np.exp(np.sin(a)) ━►\n",
      "[[2.31977682 0.40280713 1.15156284 2.13144999]\n",
      " [2.60888852 0.75622563 0.51841116 2.68950792]\n",
      " [1.51001334 1.72292101 0.36788304 1.71013603]]\n"
     ]
    }
   ],
   "source": [
    "show(\"np.abs(a)#;; np.sign(a)#;; np.exp(np.sin(a))#\") # utilisation de fonctions universelles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Les fonctions précédentes s'appliquent élément par élément, et renvoient donc systématiquement une matrice ayant la même taille que la matrice de départ. Il existent une seconde catégorie de fonctions de manipulation, qui vont effectuer des traitements divers sur une partie des données de la matrice, et renvoyer le résultat de ces traitements, qui pourra être soit un scalaire, soit un vecteur, soit une matrice de taille ou de dimension différente de celle de départ. La plupart de ces fonctions possèdent un argument optionnel **`axis`** qui permet de choisir la dimension (*lignes, colonnes, plans, etc*) le long de laquelle doit s'effectuer le traitement (par défaut, celui-ci s'effectue sur l'ensemble de la matrice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  6 11]\n"
     ]
    }
   ],
   "source": [
    "print(np.diag(a)) # extraction de diagonale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 8]\n"
     ]
    }
   ],
   "source": [
    "print(np.diag(a, 2)) # extraction de diagonale avec décalage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1   0   0   0]\n",
      " [ -5   6   0   0]\n",
      " [  9 -10  11   0]]\n"
     ]
    }
   ],
   "source": [
    "print(np.tril(a)) # extraction du triangle inférieur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  0  3 -4]\n",
      " [ 0  0  0  8]\n",
      " [ 0  0  0  0]]\n"
     ]
    }
   ],
   "source": [
    "print(np.triu(a, 2)) # extraction du triangle supérieur avec décalage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.max(a) ━► 11\n",
      "np.max(a, axis=0) ━► [ 9  6 11  8]\n",
      "np.min(a) ━► -12\n",
      "np.min(a, axis=1) ━► [ -4  -7 -12]\n",
      "np.ptp(a) ━► 23\n",
      "\n",
      "np.argmax(a) ━► 10\n",
      "np.argmax(a, axis=0) ━► [2 1 2 1]\n",
      "np.argmin(a) ━► 11\n",
      "np.argmin(a, axis=1) ━► [3 2 3]\n"
     ]
    }
   ],
   "source": [
    "show(\"np.max(a); np.max(a, axis=0); np.min(a); np.min(a, axis=1); np.ptp(a);\") # ptp = peak to peak\n",
    "show(\"np.argmax(a); np.argmax(a, axis=0); np.argmin(a); np.argmin(a, axis=1)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.sum(a, axis=0) ━► [ 5 -6  7 -8]\n",
      "np.cumsum(a, axis=1) ━►\n",
      "[[ 1 -1  2 -2]\n",
      " [-5  1 -6  2]\n",
      " [ 9 -1 10 -2]]\n",
      "\n",
      "np.prod(a, axis=0) ━► [ -45  120 -231  384]\n",
      "np.cumprod(a, axis=1) ━►\n",
      "[[    1    -2    -6    24]\n",
      " [   -5   -30   210  1680]\n",
      " [    9   -90  -990 11880]]\n",
      "\n",
      "np.mean(a, axis=1) ━► [-0.5  0.5 -0.5]\n",
      "np.average(a, axis=1, weights=[1,3,1,3]) ━► [-1.75  3.75 -5.75]\n",
      "np.var(a, axis=1) ━► [  7.25  43.25 111.25]\n",
      "np.std(a, axis=1) ━► [ 2.6925824   6.57647322 10.54751155]\n",
      "\n",
      "np.percentile(a, [25,50,75]) ━► [-5.5 -0.5  6.5]\n",
      "np.clip(a, -7, 7) ━►\n",
      "[[ 1 -2  3 -4]\n",
      " [-5  6 -7  7]\n",
      " [ 7 -7  7 -7]]\n",
      "\n",
      "np.sort(a, axis=None) ━► [-12 -10  -7  -5  -4  -2   1   3   6   8   9  11]\n",
      "np.sort(a, axis=0) ━►\n",
      "[[ -5 -10  -7 -12]\n",
      " [  1  -2   3  -4]\n",
      " [  9   6  11   8]]\n",
      "np.sort(a, axis=1) ━►\n",
      "[[ -4  -2   1   3]\n",
      " [ -7  -5   6   8]\n",
      " [-12 -10   9  11]]\n"
     ]
    }
   ],
   "source": [
    "show(\"np.sum(a, axis=0); np.cumsum(a, axis=1)#;; np.prod(a, axis=0); np.cumprod(a, axis=1)#;\")\n",
    "show(\"np.mean(a, axis=1); np.average(a, axis=1, weights=[1,3,1,3]); np.var(a, axis=1); np.std(a, axis=1);\")\n",
    "show(\"np.percentile(a, [25,50,75]); np.clip(a, -7, 7)#;\") # clip = écrêtage\n",
    "show(\"np.sort(a, axis=None); np.sort(a, axis=0)#; np.sort(a, axis=1)#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z ━►\n",
      "[9 1 7 6 0 0 7 7 6 2 3 5 3 7 2 3 0 1 5 4 5 7 1 5 7 5 3 2 5 8 5 6 8 5 7 3 9\n",
      " 8 9 1 1 3 7 9 6 7 0 2 0 8 5 4 7 5 5 1 5 5 2 0 4 3 4 0 2 4 1 4 1 8 3 9 4 4\n",
      " 6 4 9 3 9 1 1 2 3 7 4 7 5 4 1 1 4 0 0 4 4 1 3 5 3 7]\n",
      "np.bincount(z) ━► [ 9 13  7 12 14 15  5 13  5  7]\n",
      "\n",
      "zz ━►\n",
      "[2 0 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 0 1 1 1 1 1 1 2 1 1 2 1 1 1 2\n",
      " 2 2 0 0 1 1 2 1 1 0 1 0 2 1 1 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 0 2 1 2 1 1\n",
      " 1 1 2 1 2 0 0 1 1 1 1 1 1 1 0 0 1 0 0 1 1 0 1 1 1 1]\n",
      "np.bincount(zz) ━► [22 66 12]\n"
     ]
    }
   ],
   "source": [
    "z = np.random.randint(0, 10, 100) # création d'un vecteur d'entiers aléatoires\n",
    "zz = np.digitize(z, (2,8)) # quantification en 3 groupes : {0,1}, {2,3,4,5,6,7} {8,9}\n",
    "show(\"z#; np.bincount(z);; zz#; np.bincount(zz)\") # bincount = histogramme avec bins = 0,1,2...n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.mean(z) ━► 0.013479074072166452\n",
      "np.std(z) ━► 2.011548072225045\n",
      "histoA ━► [   5   74  587 2414 3803 2444  611   59    3]\n",
      "binsA ━► [-9 -7 -5 -3 -1  1  3  5  7  9]\n",
      "histoB ━► [  79  587 2414 3803 2444  611   62]\n",
      "binsB ━► [-1000    -5    -3    -1     1     3     5  1000]\n"
     ]
    }
   ],
   "source": [
    "z = np.random.normal(0, 2, 10000) # création d'un vecteur de valeurs aléatoires (distribution normale)\n",
    "show(\"np.mean(z); np.std(z)\") # la moyenne et l'écart-type sont conformes à la distribution choisie\n",
    "histoA, binsA = np.histogram(z, range(-9,10,2)) # création d'un histogramme (bins personnalisés)\n",
    "histoB, binsB = np.histogram(z, [-1000,-5,-3,-1,1,3,5,1000]) # création d'un histogramme (bins variables)\n",
    "show(\"histoA; binsA; histoB; binsB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 3 - Manipulation par méthodes\n",
    "\n",
    "Les fonctions de manipulation de matrices les plus utilisées sont directement implémentées sous forme de méthodes, accessibles via la notation pointée, ce qui permet une syntaxe plus compacte lors de leur mise en oeuvre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1  -2   3  -4]\n",
      " [ -5   6  -7   8]\n",
      " [  9 -10  11 -12]]\n"
     ]
    }
   ],
   "source": [
    "print(a) # rappel du contenu de la matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.max() ━► 11\n",
      "a.max(axis=0) ━► [ 9  6 11  8]\n",
      "a.min() ━► -12\n",
      "a.min(axis=1) ━► [ -4  -7 -12]\n",
      "a.ptp() ━► 23\n",
      "\n",
      "a.argmax() ━► 10\n",
      "a.argmax(axis=0) ━► [2 1 2 1]\n",
      "a.argmin() ━► 11\n",
      "a.argmin(axis=1) ━► [3 2 3]\n"
     ]
    }
   ],
   "source": [
    "show(\"a.max(); a.max(axis=0); a.min(); a.min(axis=1); a.ptp();\")\n",
    "show(\"a.argmax(); a.argmax(axis=0); a.argmin(); a.argmin(axis=1)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.sum(axis=0) ━► [ 5 -6  7 -8]\n",
      "a.cumsum(axis=1) ━►\n",
      "[[ 1 -1  2 -2]\n",
      " [-5  1 -6  2]\n",
      " [ 9 -1 10 -2]]\n",
      "\n",
      "a.prod(axis=0) ━► [ -45  120 -231  384]\n",
      "a.cumprod(axis=1) ━►\n",
      "[[    1    -2    -6    24]\n",
      " [   -5   -30   210  1680]\n",
      " [    9   -90  -990 11880]]\n",
      "\n",
      "a.mean(axis=1) ━► [-0.5  0.5 -0.5]\n",
      "a.var(axis=1) ━► [  7.25  43.25 111.25]\n",
      "a.std(axis=1) ━► [ 2.6925824   6.57647322 10.54751155]\n",
      "a.clip(-7,7) ━►\n",
      "[[ 1 -2  3 -4]\n",
      " [-5  6 -7  7]\n",
      " [ 7 -7  7 -7]]\n"
     ]
    }
   ],
   "source": [
    "show(\"a.sum(axis=0); a.cumsum(axis=1)#;; a.prod(axis=0); a.cumprod(axis=1)#;\")\n",
    "show(\"a.mean(axis=1); a.var(axis=1); a.std(axis=1); a.clip(-7,7)#\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 4 - Création de fonctions universelles\n",
    "\n",
    "En plus du catalogue de fonctions universelles prédéfinies, **`numpy`** fournit un mécanisme permettant de convertir très simplement une fonction classique (= applicable à des données scalaires) en une fonction universelle (= applicable à des données matricielles et bénéficiant du processus de vectorisation). Après avoir écrit le code de la fonction classique, la conversion se réalise en appelant la fonction **`np.frompyfunc(func, nin, nout)`** où **`func`** correspond au nom de la fonction qu'on souhaite vectoriser, **`nin`** et **`nout`** correspondent respectivement au nombre d'arguments en entrée et en sortie pour la fonction **`func`**.\n",
    "\n",
    "Voici un exemple de mise en oeuvre, avec la fonction **`facto`** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def facto(n): # définition d'une fonction classique\n",
    "  \"\"\"return n! (factorial of integer n >= 0)\"\"\"\n",
    "  out = 1\n",
    "  for loop in range(1, n+1): out *= loop\n",
    "  return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(facto) ━► <class 'function'>\n",
      "type(ufacto) ━► <class 'numpy.ufunc'>\n"
     ]
    }
   ],
   "source": [
    "ufacto = np.frompyfunc(facto, 1, 1) # conversion en fonction universelle\n",
    "show(\"type(facto); type(ufacto)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [3 6]\n",
      " [4 24]\n",
      " [5 120]\n",
      " [6 720]\n",
      " [7 5040]\n",
      " [8 40320]\n",
      " [9 362880]\n",
      " [10 3628800]\n",
      " [11 39916800]\n",
      " [12 479001600]\n",
      " [13 6227020800]\n",
      " [14 87178291200]\n",
      " [15 1307674368000]\n",
      " [16 20922789888000]\n",
      " [17 355687428096000]\n",
      " [18 6402373705728000]\n",
      " [19 121645100408832000]\n",
      " [20 2432902008176640000]]\n"
     ]
    }
   ],
   "source": [
    "z = np.arange(21) # création d'un vecteur d'entiers de 0 à 20\n",
    "print(np.stack([z, ufacto(z)]).T) # application de la fonction sur le vecteur 'z'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}