Mise à jour didacticiel pour 2022-2023 (ajout help, plot, contour, while, if,...

Mise à jour didacticiel pour 2022-2023 (ajout help, plot, contour, while, if, déclaration de fonction, comparaison de matrices)

Mise à jour didacticiel pour 2022-2023 (ajout help, plot, contour, while, if,...
e71d1eb1 · tmalon · e700ccfd · e71d1eb1
Commit e71d1eb1 authored 3 years ago by tmalon
--- a/tutoriels/matlab/matlab_2022_2023.ipynb
+++ b/tutoriels/matlab/matlab_2022_2023.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Didacticiel Matlab\n",
+    "\n",
+    "Ce didacticiel aborde la plupart des fonctionnalités utilisées dans les TP de Matlab, notamment pour les TP de probas et de stats. Vous pouvez exécuter les blocs de texte et de code un par un en prenant le temps de bien les comprendre.\n",
+    "\n",
+    "Avant de commencer, assurez-vous que le noyau Octave est sélectionné. Pour cela, si la barre inférieure indique \"No Kernel\", cliquez dessus et choisissez \"Octave\".\n",
+    "\n",
+    "Une fois ce noyau sélectionné, vous pouvez lancer successivement chaque cellule au fur et à mesure de votre lecture en cliquant sur la triangle dans la barre supérieure.\n",
+    "\n",
+    "## 1) Définition de matrices\n",
+    "\n",
+    "Pour définir un **vecteur ligne** :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "V_ligne = [1 3 5 7 9]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour définir un **vecteur colonne** :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "V_colonne = [2; 4; 6; 8; 10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "De manière générale, on utilise **des espaces (ou des virgules) comme séparateur horizontal** et le **point virgule comme séparateur vertical**.\n",
+    "La même règle s'applique à la définition d'une matrice. Essayez de prédire la matrice qui sera définie par l'instruction suivante avant de l'exécuter :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M = [1 3 5 7 9; 2 4 6 8 10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut également construire M à partir de la **concaténation** des vecteurs définis précédemment. On pourrait penser à écrire quelque chose comme :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M = [V_ligne; V_colonne]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "À l'exécution de cette ligne, une erreur de dimensions est levée. En effet, V_ligne est de taille 1x5 et V_colonne est de taille 5x1.\n",
+    "En transposant V_colonne (V_colonne' ou transpose(V_colonne)), on résout ce problème de dimensions :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M = [V_ligne; V_colonne']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Comme les valeurs de M sont régulièrement espacées, il est possible d'utiliser des **plages de valeurs** avec un certain pas.\n",
+    "Exécutez les deux instructions suivantes et identifiez à chaque fois les bornes de la plage ainsi que le pas."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Enum1 = 3:7:90"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Enum2 = 5:3:20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Essayez de réécrire V_ligne, V_colonne et M en utilisant des plages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V_ligne ="
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V_colonne = "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M ="
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " Vérifiez avec les solutions données ci-dessous.\n",
+    " **Attention à ne pas écrire V_colonne = 2:2:10'** car la transposition ne s'applique alors qu'à 10 et on obtiendrait un vecteur ligne."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V_ligne = 1:2:9\n",
+    "V_colonne = (2:2:10)'\n",
+    "V_colonne = transpose(2:2:10)\n",
+    "M = [1:2:9; 2:2:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Enfin, il est possible de définir des matrices ne contenant que des 0 ou que des 1, ou encore des matrices identités (des 1 sur la diagonale et des 0 partout ailleurs).\n",
+    "Dans tous ces cas, il faut indiquer les dimensions de la matrice souhaitée. Si une seule dimension est donnée, elle est utilisée comme nombre de lignes et de colonnes : on obtient alors une matrice carrée."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M0 = zeros(3, 5)\n",
+    "M1 = ones(3, 5)\n",
+    "M2 = ones(4, 4)\n",
+    "M3 = ones(4)\n",
+    "Id = eye(4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2) Opérations sur les matrices\n",
+    "\n",
+    "Il est possible d'ajouter une constante à un vecteur/une matrice :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MplusTrois = M+3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il est possible de multiplier un vecteur/une matrice par une constante :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "troisFoisM = 3*M"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il est possible d'additionner des matrices de mêmes tailles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MplusMplusM = M+M+M"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Attention, sous certaines conditions, Matlab permet les additions entre une matrice et un vecteur s'ils ont une dimension en commun.\n",
+    "Le vecteur est alors répliqué selon la dimension non commune pour faire la même taille que la matrice. Par exemple, les deux instructions suivantes sont équivalentes :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M + [1 3 5 7 9]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M + [1 3 5 7 9; 1 3 5 7 9]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "M est de taille (2,5) et V_ligne = [1 3 5 7 9] est de taille (1,5) donc, lors de l'addition, V_ligne est répliqué deux fois pour faire la taille de M.\n",
+    "Vous nous déconseillons d'utiliser cette réplication propre à Matlab et nous verrons plus loin comment répliquer manuellement un vecteur ou une matrice."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Le produit matriciel usuel entre M1 de taille (m,k) et M2 de taille (k,n) donne une matrice de taille (m,n).\n",
+    "Il se fait comme suit :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M*V_colonne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V_ligne*V_colonne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V_colonne*V_ligne"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il est alors possible de répliquer un vecteur en le multipliant par un vecteur ones de taille adaptée. Par exemple, pour répliquer [1 3 5 7 9] de taille (1,5) en [1 3 5 7 9; 1 3 5 7 9] de taille (2,5), on peut faire l'instruction suivante :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ones(2,1) * [1 3 5 7 9]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Enfin, il existe la fonction **repmat** (pour réplique matrice) qui permet de répliquer une matrice un certain nombre de fois horizontalement et un certain nombre de fois verticalement pour obtenir une plus grande matrice. Par exemple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "repmat(M, 4, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ainsi, pour répliquer [1 3 5 7 9] en une matrice de tailles (2,5), on peut faire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "repmat([1 3 5 7 9], 2, 1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il est possible de vectoriser une matrice. Le vecteur obtenu est **la concaténation des colonnes** de la matrice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M_vectorise = M(:)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sur des matrices de mêmes tailles, il est possible d'effectuer des **opérations élément par élément**, comme suit :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I = [200 180 170 190 155; 205 190 195 165 150; 210 215 175 155 190]\n",
+    "Coefficients = [0.5 0.2 0.4 0.8 1; 0.4 0.2 0 1 0.9; 0.75 0.5 0.6 1 0.1]\n",
+    "\n",
+    "I.*Coefficients % Produit élément par élément de I et de Coefficients"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I.*I % Matrice des carrés des éléments de I"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I.^3 % Matrice de chaque élément de I élevé à la puissance 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Certaines fonctions s'effectuent sur tous les éléments d'une matrice sans qu'il soit nécessaire de le préciser avec un \".\".\n",
+    "C'est notamment le cas des fonctions usuelles cosinus **cos**, sinus **sin**, racine carrée **sqrt**, etc :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "racineI = sqrt(I)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I - racineI.*racineI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dans cet exemple, on remarque que l'on obtient pas une matrice entièrement composée de 0 car la précision de la machine sur les opérations flottantes est limitée. Notez la présence du facteur multiplicatif 1.0e-13."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3) Modification des éléments d'une matrice\n",
+    "\n",
+    "Lorsque l'on veut modifier la valeur d'un élément en particulier, une première syntaxe consiste à préciser le numéro de ligne et le numéro de colonne de l'élément :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z1 = zeros(7, 5); % Ce point-virgule en fin de ligne permet de ne pas afficher le résultat de l'instruction\n",
+    "Z1(2, 3) = 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On remarque qu'en Matlab, les indices commencent à 1 et non à 0 comme dans de nombreux langages (C, Python...).\n",
+    "Une deuxième syntaxe consiste à donner **l'indice absolu** de l'élément. De nouveau, on compte selon les colonnes :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z1(5) = 18"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z1(13) = 21"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il existe deux fonctions **sub2ind** et **ind2sub** qui permettent de convertir un indice absolu en indices relatifs (numéros de ligne et de colonne) et inversement. Il est nécessaire de donner la taille de la matrice considérée en entrée de ces fonctions :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[ligne, colonne] = ind2sub(size(Z1), 13)\n",
+    "indice_absolu = sub2ind(size(Z1), 2, 4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La fonction **ind2sub** est une fonction qui peut renvoyer plusieurs sorties : elle renvoie l'indice de ligne et l'indice de colonne. Nous donnerons d'autres exemples de ce genre de fonctions plus loin."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour modifier plusieurs éléments simultanément, il faut indiquer les indices des éléments à modifier et donner les nouvelles valeurs de ces éléments dans une matrice de taille adaptée. Nous donnons plusieurs exemples ci-dessous, prenez le temps de les comprendre :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z2 = zeros(9, 7);\n",
+    "Z2(2, 3:7) = V_ligne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z2(4:8, 1) = V_colonne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z2(5:6, 3:7) = M"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il est possible d'extraire une sous-matrice en indiquant les plages d'indices désirées. Par exemple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z2(3:8, 1:5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut également indiquer un pas. Essayez de prédire ce que renvoie l'instruction suivante puis exécutez-la :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z2(2:2:6, 3:2:7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La sous-matrice obtenue est de taille (3,3). Il est donc possible de modifier tous ces éléments d'un coup en donnant les nouvelles valeurs dans une matrice de taille (3,3), comme dans l'exemple suivant. Prenez le temps de bien localiser les éléments de A dans la matrice Z2 :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A = [3 4 2; 5 5 5; 9 0 3]\n",
+    "Z2(2:2:6, 3:2:7) = A"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La longueur d'un vecteur peut être obtenue par la fonction **length** :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "longueur = length(V_ligne)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "L'utilisation de **length** sur une matrice est déconseillé car la fonction ne retourne alors que la plus grande dimension de la matrice.\n",
+    "\n",
+    "Le **nombre de lignes** et le **nombre de colonnes** d'une matrice peuvent être obtenus avec **size** en faisant :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z3 = zeros(6, 4)\n",
+    "nb_lignes = size(Z3, 1)\n",
+    "nb_colonnes = size(Z3, 2)\n",
+    "plus_grande_dimension = length(Z3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il existe plusieurs façons de redéfinir une ligne (ou une colonne) entière. On peut donner une plage d'indices allant de 1 à nb_lignes ou nb_colonnes :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z3(4, 1:nb_colonnes) = 99\n",
+    "Z3(1:nb_lignes, 2) = -55"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut utiliser le symbole \":\" qui indique de considérer tous les éléments de la ligne (ou de la colonne) :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z4 = zeros(6, 4)\n",
+    "Z4(3, :) = 11\n",
+    "Z4(:, 4) = -33"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Enfin, il est possible d'utiliser le mot clé \"end\" à la place de nb_lignes ou nb_colonnes :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z5 = zeros(6, 4)\n",
+    "Z5(2, 1:end) = 222\n",
+    "Z5(1:end, 1) = 666"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour modifier simultanément plusieurs éléments, on utilise un vecteur d'indices absolus. Par exemple, pour mettre la valeur 1 aux indices absolus 2, 5, 7, 12, 13, 14, 19 d'une matrice de tailles (6,4), on utilise :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z6 = zeros(6, 4)\n",
+    "Z6([2, 5, 7, 12, 13, 14, 19]) = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La fonction **sub2ind** évoquée précédemment peut s'avérer utile pour récupérer un indice absolu à partir des numéros de ligne et de colonne d'un élément. En pratique, on n'utilise rarement ces conversions car Matlab dispose de fonctions qui permettent de s'en passer. Nous donnons un exemple ci-dessous."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Supposons que l'on dispose d'une matrice I et que l'on souhaite remplacer tous les éléments de I de valeur inférieure à un certain seuil (disons 177) par 0. L'instruction I <= 177 renvoie une matrice booléenne :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I = [200 180 170 190 155; 205 190 195 165 150; 210 215 175 155 190]\n",
+    "I <= 177"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour récupérer les indices des valeurs de I inférieures à 177 avec **find** :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "find(I <= 177)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut alors récupérer les valeurs de I inférieures à 177 en faisant :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I(find(I <= 177))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "L'instruction suivante, plus épurée, renvoie le même résultat :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I(I <= 177)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ainsi, pour mettre à 0 tous les éléments de I inférieures à 177, on peut écrire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I(I<=177) = 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "qui est la version plus épurée de :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I(find(I<=177)) = 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Enfin, pour tester l'égalité entre deux matrices (ou vecteurs), on pourrait être tentés de faire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A = [pi, 2*pi, 3*pi; 4*pi, 5*pi, 6*pi] \n",
+    "B = [3.1416, 6.2832, 9.4248; 12.5664, 15.7080, 18.8496]\n",
+    "A == B"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Les valeurs affichées dans A et dans B sont les mêmes. Pourtant, la matrice de booléens A == B ne contient que des 0 (associés à la valeur \"faux\"). Deux problèmes entrent en jeu :\n",
+    "- d'une part, Matlab n'affiche qu'un certain nombre de décimales ;\n",
+    "- d'autre part, lorsque l'on manipule des nombres flottants, on manipule en vérité des valeurs à une précision machine près.\n",
+    "\n",
+    "La façon standard de vérifier que deux flottants sont égaux consiste donc à vérifier que leur différence en valeur absolue est inférieur à un certain seuil de précision fixé par l'utilisateur en fonction du contexte. Par exemple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "abs(pi-3.1416) < 0.001\n",
+    "abs(pi-3.1416) < 0.000001"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "De façon analogue, la vérification d'égalité entre deux matrices impliquera :\n",
+    "- de vérifier qu'elles ont la même taille (donc le même nombre de coefficients) ;\n",
+    "- que les différences en valeur absolue des coefficients terme à terme sont inférieures à un certain seuil."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4) Fonctions utiles\n",
+    "On peut modifier la forme d'une matrice avec la fonction **reshape** : la seule contrainte est que le nombre d'éléments total doit rester le même. À nouveau, l'ordre des éléments se retrouve dans la vectorisation de la matrice, comme illustré ci-dessous sur une matrice de taille (4,6) (donc à 24 éléments). Prenez le temps de bien comprendre les exemples ci-dessous :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "J = [200 180 170 190 155 120; 205 190 195 165 150 60; 210 215 175 155 190 160; 125 155 165 145 200 185]\n",
+    "J1 = J(:) % Vectorisation de J\n",
+    "J2 = reshape(J, 3, 8)\n",
+    "J3 = reshape(J, 6, 4)\n",
+    "J4 = reshape(J, 8, 3)\n",
+    "J5 = reshape(J, 24, 1) % équivalent à J(:)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La fonction **max** permet de récupérer l'élément d'un vecteur (colonne ou ligne) de valeur maximale, ainsi que son indice.\n",
+    "Il s'agit d'une fonction qui peut renvoyer plusieurs sorties, tout comme **size**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "W = [4, 12, 3, 7, 6]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Observez les deux syntaxes suivantes et identifiez les différences :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "valeur_maximale = max(W)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[valeur_maximale, indice_du_maximum] = max(W)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Si l'on ne précise qu'une seule sortie, **max** ne renvoie que la valeur maximale.\n",
+    "Pour obtenir l'indice du maximum, il faut demander deux sorties entre crochets comme dans la deuxième syntaxe.\n",
+    "Si l'on ne souhaite se servir que de l'indice du maximum, il est possible de se passer de la sortie correspondant à la valeur du maximum avec le symbole \"~\" :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[~, indice_du_maximum] = max(W)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dans le cas d'une matrice, la fonction **max** permet de récupérer la valeur maximale de chaque colonne ainsi que son indice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "J\n",
+    "maxima = max(J)\n",
+    "[~, indices_maxima] = max(J)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "De la même façon, la fonction **sort** permet de trier les valeurs par ordre croissant ('ascend') ou décroissant ('descend') et de renvoyer les indices correspondants si deux sorties sont demandées."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "W\n",
+    "valeurs_ordre_croissant = sort(W, 'ascend') % Par défaut, sort utilise ascend s'il n'y a pas de 2ème paramètre\n",
+    "valeurs_ordre_decroissant = sort(W, 'descend')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[valeurs_ordre_croissant, indices_ordre_croissant] = sort(W, 'ascend')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[~, indices_ordre_croissant] = sort(W, 'ascend')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut vérifier que W(indices_ordre_croissant) donne valeurs_ordre_croissant :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "W(indices_ordre_croissant)\n",
+    "valeurs_ordre_croissant"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La fonction **mean** renvoie :\n",
+    "- la moyenne des éléments d'un vecteur lorsqu'elle est utilisée sur un vecteur ;\n",
+    "- les moyennes de chaque colonne ou de chaque ligne d'une matrice lorsqu'elle est utilisée sur une matrice.\n",
+    "\n",
+    "Pour préciser si la moyenne doit être calculée par lignes ou par colonnes, il est nécessaire d'ajouter un deuxième argument égal à 1 (par colonnes) ou à 2 (par lignes). Par défaut, en l'absence de deuxième argument, la moyenne est calculée par colonnes (valeur par défaut : 1)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V = [2 3 5 8 12]\n",
+    "mean(V)\n",
+    "\n",
+    "M = [1 3 5 7 9; 2 4 6 8 10]\n",
+    "moyennes_par_colonnes = mean(M, 1)\n",
+    "moyennes_par_lignes = mean(M, 2)\n",
+    "moyennes_par_defaut = mean(M)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "De façon similaire, la fonction **sum** renvoie :\n",
+    "- la somme des éléments d'un vecteur lorsqu'elle est utilisée sur un vecteur ;\n",
+    "- les sommes de chaque colonne ou de chaque ligne d'une matrice lorsqu'elle est utilisée sur une matrice.\n",
+    "De nouveau, pour préciser si les moyennes doivent être calculées par lignes ou par colonnes, on ajoute un deuxième argument égal à 1 (par colonnes) ou à 2 (par lignes). Par défaut, si l'on n'indique pas de deuxième argument, il est égal à 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V = [2 3 5 8 12]\n",
+    "sum(V)\n",
+    "\n",
+    "M = [1 3 5 7 9; 2 4 6 8 10]\n",
+    "sommes_par_colonnes = sum(M, 1)\n",
+    "sommes_par_lignes = sum(M, 2)\n",
+    "sommes_par_defaut = sum(M)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ainsi, les moyennes peuvent être calculées soit avec **mean**, soit avec **sum** et **size**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M = [1 3 5 7 9; 2 4 6 8 10];\n",
+    "mean(M, 1)\n",
+    "sum(M, 1)/size(M, 1)\n",
+    "mean(M, 2)\n",
+    "sum(M, 2)/size(M, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Enfin, il est possible de consulter la document d'une fonction avec la commande **help**. Des exemples numériques sont notamment donnés en fin de documentation :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "help sum"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5) Définir une fonction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il est possible de définir des fonctions en donnant ses paramètres d'entrée et de sortie.\n",
+    "Attention, cette fonctionnalité n'étant pas disponible sur notebook, vous aurez le message d'erreur suivant en exécutant le bloc : \"Error: Function definition not supported in this context. Create functions in code file\".\n",
+    "L'idée est avant tout de voir la syntaxe d'une défintion de fonction.\n",
+    "\n",
+    "Par exemple, si l'on veut définir une fonction appelée **calculs_basiques** qui, à partir de deux entrées **a** et **b** renvoie trois sorties contenant respectivement la somme, la différence et le produit de **a** et **b**, on peut écrire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "function [somme, difference, produit] = calculs_basiques(A, B)\n",
+    "    somme = A+B;\n",
+    "    difference = A-B;\n",
+    "    produit = A.*B;\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il serait également possible de stocker ces trois valeurs dans un vecteur et de n'avoir que ce vecteur en sortie. On écrirait alors :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "function resultats = calculs_basiques_variante(A, B)\n",
+    "    resultats = [A+B, A-B, A*B];\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Il faut faire bien attention à la façon dont sont appelées les fonctions dans le code. Par exemple, si l'on écrit :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "resultats = calculs_basiques(3, 5);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "resultats sera égal à 8 car il ne contiendra que la première sortie de **calculs_basiques** (somme). On a déjà abordé ce point en présentant les fonctions **sort** et **max** : elles peuvent retourner plusieurs sorties mais ne retournent que la première d'entre elles si l'on ne précise pas avec des crochets les sorties désirées.\n",
+    "\n",
+    "À l'inverse, si l'on écrit :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[somme, difference, produit] = calculs_basiques_variante(3, 5);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "une erreur sera affichée car une seule sortie est attendue de la part de la fonction **calculs_basiques_variante**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6) Les structures de contrôle\n",
+    "### 6.1) Les boucles for"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Lorsque l'on veut faire une boucle **for** en Matlab, on précise un vecteur contenant toutes les valeurs que doit prendre l'indice de boucle (i dans l'exemple donné ci-dessous). Par exemple, pour une boucle de 1 à 1000 on utilisera le vecteur [1 2 3 ... 1000] qui s'écrit plus simplement 1:1000."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "somme = 0;\n",
+    "for i = 1:10\n",
+    "    somme = somme + i  % Ajouter un ';' en fin de ligne permet d'éviter l'affichage à chaque tour de boucle\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Cet exemple illustre bien l'intérêt d'ajouter des ';' en fin de ligne pour éviter l'affichage.\n",
+    "\n",
+    "Dans l'exemple suivant, nous souhaitons calculer une matrice C qui est la somme de deux matrices A et B.\n",
+    "Nous montrons comment le faire de deux manières différentes :\n",
+    "- avec une boucle **for**\n",
+    "- matriciellement\n",
+    "\n",
+    "Pour chaque méthode, nous mesurons le temps d'exécution en appelant les instructions **tic** et **toc** respectivement avant et après le bloc de code dont on veut mesurer le temps d'exécution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A = rand(2000,1500);\n",
+    "B = rand(size(A));\n",
+    "C = zeros(size(A));\n",
+    "\n",
+    "tic\n",
+    "% Avec une boucle for\n",
+    "for i = 1:size(C, 1)\n",
+    "    for j = 1:size(C, 2)\n",
+    "        C(i, j) = A(i, j) + B(i, j);\n",
+    "    end\n",
+    "end\n",
+    "toc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A = rand(2000, 1500);\n",
+    "B = rand(size(A));\n",
+    "C = zeros(size(A));\n",
+    "\n",
+    "tic\n",
+    "C = A + B;\n",
+    "toc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Bien souvent, le fait d'utiliser des boucles **for** augmente les temps de calcul.\n",
+    "Il n'est cependant pas toujours évident de se passer de ces boucles, mais nous vous demanderons de les éviter au maximum lorsqu'elles sont remplaçables par d'autres fonctions ou opérations matricielles.\n",
+    "\n",
+    "Pour illustrer un cas où se passer de boucle **for** n'est pas évident, nous proposons l'exemple d'une quantification d'histogramme.\n",
+    "Nous souhaitons compter le nombre d'éléments d'une matrice dont la valeur est comprise entre 0 et 0.1, entre 0.1 et 0.2, entre 0.2 et 0.3...et entre 0.9 et 1.\n",
+    "De nouveau, nous proposons une version avec boucle **for** et une version sans. Prenez le temps de bien comprendre les deux versions :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M = rand(800, 600);\n",
+    "\n",
+    "Histogramme = zeros(1, 10);\n",
+    "\n",
+    "tic\n",
+    "for i = 1:size(M, 1)\n",
+    "    for j = 1:size(M, 2)\n",
+    "        valeur = floor(M(i, j)*10);  % pour obtenir un indice entre 0 et 9\n",
+    "        indice = valeur+1;  % les indices en Matlab commencent à 1\n",
+    "        Histogramme(indice) = Histogramme(indice) + 1;\n",
+    "    end\n",
+    "end\n",
+    "toc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "M = rand(800, 600);\n",
+    "\n",
+    "Histogramme = zeros(1, 10);\n",
+    "\n",
+    "tic\n",
+    "M = repmat(M(:), 1, 10);\n",
+    "intervalles1 = 0:0.1:0.9;\n",
+    "intervalles2 = 0.1:0.1:1;\n",
+    "\n",
+    "Histogramme = sum(M >= intervalles1 & M < intervalles2);\n",
+    "toc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Le symbole **&** désigne ici le ET logique.\n",
+    "De la même façon, on peut écrire un OU logique avec le symbole **|**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 6.2) Utilisation de while et if"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nous illustrons rapidement l'utilisation de **while** et **if** au travers de l'exemple d'une fonction cherchant à déterminer si un nombre **n** est premier ou non en calculant le reste de la division euclidienne de tous les nombres de 2 à racine carrée (**sqrt**) de **n** et en déclarant que le nombre n'est pas premier si l'un de ces restes est nul. En Matlab, on peut écrire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "function primalite = est_premier(n)\n",
+    "    primalite = 1;\n",
+    "    indice = 2;\n",
+    "    while indice <= sqrt(n) & primalite\n",
+    "        if mod(n, indice) == 0\n",
+    "            primalite = 0;\n",
+    "        end\n",
+    "        indice = indice + 1;\n",
+    "    end\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7) Affichage de courbes\n",
+    "\n",
+    "### 7.1) plot de R dans R\n",
+    "\n",
+    "Il est possible de tracer des courbes avec la fonction **plot**.\n",
+    "Commençons par un exemple simple :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = [3, 5, 7, 8, 11, 15];\n",
+    "Y = [3, 4, -5, 6, 1, 10];\n",
+    "plot(X, Y);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour ajouter un titre à la figure, on peut faire :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot(X, Y);\n",
+    "title('Tracer de Y en fonction de X');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut également ajouter du texte le long des axes :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot(X, Y);\n",
+    "title('Tracer de Y en fonction de X');\n",
+    "xlabel('Valeurs contenues dans X');\n",
+    "ylabel('Valeurs contenues dans Y');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut préciser la couleur du tracé de la façon suivante :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot(X, Y,'r');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Si on ne souhaite qu'avec des points non reliés, on peut indiquer le type de marqueurs (parmi *, +, o)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot(X, Y,'*');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour combiner marqueur et couleur :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot(X, Y,'r*');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On peut regrouper plusieurs figures avec la fonction **subplot** : on indique d'abord le nombre de lignes n, le nombre de colonnes m et enfin l'indice (entre 1 et n\\*m) de la figure que l'on dessine. On peut choisir pour chaque sous-figure d'ajouter un titre et des étiquettes sur les axes ou non :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "subplot(2,2,1);\n",
+    "plot(X, Y);\n",
+    "title('Titre de la sous-figure 1')\n",
+    "\n",
+    "subplot(2,2,2);\n",
+    "plot(X, Y,'r');\n",
+    "xlabel('Axe X de la figure 2')\n",
+    "\n",
+    "subplot(2,2,3);\n",
+    "plot(X, Y,'*');\n",
+    "ylabel('Axe Y de la figure 3')\n",
+    "\n",
+    "subplot(2,2,4);\n",
+    "plot(X, Y,'r*');\n",
+    "title('Titre de la sous-figure 4')\n",
+    "xlabel('Axe X de la figure 4')\n",
+    "ylabel('Axe Y de la figure 4')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 7.2) plot de R² dans R\n",
+    "\n",
+    "La fonction **contour(X, Y, Z)** permet un affichage en lignes de niveaux. De nouveau, nous illustrons son utilisation au travers d'un exemple. Nous commençons par définir deux axes X et Y gradués à chaque unité de -20 à 20 : X et Y sont donc deux vecteurs de taille 41. Une valeur z est attribuée à chaque couple (x, y). Pour pouvoir utiliser **contour**, il faut stocker tous les valeurs z dans une matrice Z (qui seront donc de taille 41x41).\n",
+    "\n",
+    "Pour avoir une certaine régularité dans les lignes de niveaux de l'exemple ci-dessous, nous calculons chaque valeur de Z à partir des valeurs voisines et perturbons la valeur d'une quantité comprise entre -0.5 et 0.5 (rand-0.5). Il aurait été possible de simplement assigner une valeur aléatoire, mais les lignes de niveaux auraient alors été plus difficiles à visualiser."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = -20:20;\n",
+    "Y = -20:20;\n",
+    "Z = zeros(41,41);\n",
+    "for i = 2:41\n",
+    "    for j = 2:41\n",
+    "        Z(i,j) = rand - 0.5 + (Z(i-1,j-1)+Z(i-1,j)+Z(i,j-1))/3;\n",
+    "    end\n",
+    "end\n",
+    "contour(X, Y, Z);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Enfin, la documentation Matlab détaille et illustre tous les types d'affichage possibles (on y retrouve notamment des histogrammes et des courbes en 3D) sur la page suivante : https://www.mathworks.com/help/matlab/creating_plots/types-of-matlab-plots.html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8) Lecture et affichage d'images\n",
+    "\n",
+    "En Matlab, les images sont représentées par des matrices dont chaque élément représente le niveau de gris (pour des images en noir et blanc) ou la couleur (pour des images en couleur) d'un pixel de l'image. Pour des images en niveaux de gris, les matrices associées sont bidimensionnelles et sont de taille (nb_lignes, nb_colonnes). Pour des images en couleur, les matrices associées sont tridimensionnelles et sont de taille (nb_lignes, nb_colonnes, 3) : les 3 canaux de la troisième dimension permettent d'encoder le niveau de couleur (rouge, vert ou bleu) du pixel (codage RGB).\n",
+    "\n",
+    "Les valeurs sont prises entre 0 et 255 inclus.\n",
+    "\n",
+    "À titre d'exemples :\n",
+    "- (r = 255, g = 0, b = 0) donne du rouge vif\n",
+    "- (r = 255, g = 255, b = 0) donne du jaune vif\n",
+    "- (r = 128, g = 128, b = 128) donne du gris\n",
+    "- pour des images en niveaux de gris, 0 correspond au noir et 255 au blanc\n",
+    "\n",
+    "Vous pouvez sélectionner une couleur et obtenir son code RGB sur le site suivant : https://htmlcolorcodes.com/fr/selecteur-de-couleur/\n",
+    "\n",
+    "De manière générale, les fonctions d'affichage seront déjà écrites dans les TP de probabilités et statistiques. Nous présentons donc rapidement les principales fonctions.\n",
+    "\n",
+    "Matlab dispose de quelques images internes.\n",
+    "La lecture d'une image se fait avec la fonction **imread** :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I = imread('einstein.jpg')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imagesc(I);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pour l'affichage des images en niveaux de gris, Matlab utilise une palette de couleurs. Par défaut, il s'agit de couleurs allant du jaune/vert pour les niveaux de gris élevés au bleu pour les niveaux de gris faibles.\n",
+    "Il est possible de modifier la palette de couleurs avec l'instruction **colormap** comme suit :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colormap gray;\n",
+    "imagesc(I);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ci-dessous, un exemple d'image en couleur. Notez que la matrice est affichée canal par canal : I(:,:,1) correspond au canal rouge, I(:,:,2) au canal vert et I(:,:,3) au canal bleu. En pratique, on n'affichera pas les matrices. Pour cela, vous pouvez ajouter un \";\" en fin de ligne.\n",
+    "\n",
+    "Lorsque l'on affiche des images en couleur, il n'y a pas de colormap à gérer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I = imread('fruits.jpg');  % En mettant un \";\" après la fermeture de parenthèse, la matrice n'est pas affichée"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imagesc(I);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9) Exemple complet : distance moyenne entre deux points d'un cercle\n",
+    "Nous présentons ici un exemple de programme Matlab faisant appel à différentes fonctionnalités présentées précédemment. Assurez-vous de bien comprendre chacune des lignes de code.\n",
+    "\n",
+    "On se propose de calculer la distance moyenne entre deux points situés sur un cercle de rayon 1.\n",
+    "Pour cela, nous tirons aléatoirement 100 paires de points et calculons les distances entre points, paire par paire.\n",
+    "Pour faire ce tirage aléatoire, nous utilisons la fonction **rand** qui tire des valeurs aléatoires entre 0 et 1 (selon une loi uniforme) et multiplions par 2\\*pi pour avoir des angles entre 0 et 2\\*pi et donc des points sur le cercle unité en utilisant **cos** et **sin**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nb_points = 100;\n",
+    "\n",
+    "thetas1 = 2*pi*rand(1, nb_points); % Pour tirer nb_points angles entre 0 et 2*pi\n",
+    "thetas2 = 2*pi*rand(1, nb_points); % Pour tirer nb_points autres angles entre 0 et 2*pi\n",
+    "\n",
+    "points1 = [cos(thetas1); sin(thetas1)]; % Pour créer nb_points points sur le cercle unité\n",
+    "points2 = [cos(thetas2); sin(thetas2)]; % Pour créer nb_points autres points sur le cercle unité\n",
+    "\n",
+    "distances = sqrt(sum((points1 - points2).^2,1));\n",
+    "% (points1 - points2).^2 contient les (x2-x1)^2 sur la première ligne et les (y2-y1)^2 sur la deuxième ligne\n",
+    "% sum(points1 - points2).^2,1) est un vecteur contenant les (x2-x1)^2+(y2-y1)^2\n",
+    "% sqrt(sum(points1 - points2).^2,1)) est un vecteur contenant les Racine((x2-x1)^2+(y2-y1)^2), donc les distances\n",
+    "\n",
+    "distance_moyenne = mean(distances)\n",
+    "\n",
+    "4/pi % Valeur théorique à trouver"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Essayez d'augmenter la valeur de nb_points. Plus elle est grande, plus vous devriez trouver une distance moyenne proche de la distance moyenne théorique."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 10) Erreurs classiques\n",
+    "\n",
+    "On ne parvient pas toujours à écrire un code sans erreur du premier coup.\n",
+    "Au travers de messages d'erreur, Matlab indique généralement le type d'erreur rencontré (problème de dimension, variable non définie...) et la ligne à laquelle se produit l'erreur.\n",
+    "\n",
+    "Dans cette partie, nous vous fournissons plusieurs instructions Matlab qui renvoient une erreur lorsqu'elles sont lancées. À vous de comprendre d'où proviennent les erreurs et de les corriger :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Matrice = 256*rand(320, 240));  % Matrice de nombres aléatoires entre 0 et 256"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "% On souhaite ajouter à chaque colonne de A sa colonne suivante. La dernière colonne de A reste inchangée.\n",
+    "Matrice(:, 1:end-1) = Matrice(:, 1:end-1) + matrice(:, 1:end);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "% On souhaite ensuite centrer les valeurs en retirant la valeur moyenne de la matrice obtenue.\n",
+    "Matrice = Matrice - repmat(mean(meen(Matrice)), 320, 240);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "% On souhaite mettre à 0 tous les coefficients négatifs.\n",
+    "(Matrice < 0) = 0;"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Matlab",
+   "language": "matlab",
+   "name": "matlab"
+  },
+  "language_info": {
+   "codemirror_mode": "octave",
+   "file_extension": ".m",
+   "help_links": [
+    {
+     "text": "MetaKernel Magics",
+     "url": "https://metakernel.readthedocs.io/en/latest/source/README.html"
+    }
+   ],
+   "mimetype": "text/x-octave",
+   "name": "matlab",
+   "version": "0.16.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
+%% Cell type:markdown id: tags:
+
+# Didacticiel Matlab
+
+Ce didacticiel aborde la plupart des fonctionnalités utilisées dans les TP de Matlab, notamment pour les TP de probas et de stats. Vous pouvez exécuter les blocs de texte et de code un par un en prenant le temps de bien les comprendre.
+
+Avant de commencer, assurez-vous que le noyau Octave est sélectionné. Pour cela, si la barre inférieure indique "No Kernel", cliquez dessus et choisissez "Octave".
+
+Une fois ce noyau sélectionné, vous pouvez lancer successivement chaque cellule au fur et à mesure de votre lecture en cliquant sur la triangle dans la barre supérieure.
+
+## 1) Définition de matrices
+
+Pour définir un **vecteur ligne** :
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_ligne = [1 3 5 7 9]
+```
+
+%% Cell type:markdown id: tags:
+
+Pour définir un **vecteur colonne** :
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_colonne = [2; 4; 6; 8; 10]
+```
+
+%% Cell type:markdown id: tags:
+
+De manière générale, on utilise **des espaces (ou des virgules) comme séparateur horizontal** et le **point virgule comme séparateur vertical**.
+La même règle s'applique à la définition d'une matrice. Essayez de prédire la matrice qui sera définie par l'instruction suivante avant de l'exécuter :
+
+%% Cell type:code id: tags:
+
+``` matlab
+M = [1 3 5 7 9; 2 4 6 8 10]
+```
+
+%% Cell type:markdown id: tags:
+
+On peut également construire M à partir de la **concaténation** des vecteurs définis précédemment. On pourrait penser à écrire quelque chose comme :
+
+%% Cell type:code id: tags:
+
+``` matlab
+M = [V_ligne; V_colonne]
+```
+
+%% Cell type:markdown id: tags:
+
+À l'exécution de cette ligne, une erreur de dimensions est levée. En effet, V_ligne est de taille 1x5 et V_colonne est de taille 5x1.
+En transposant V_colonne (V_colonne' ou transpose(V_colonne)), on résout ce problème de dimensions :
+
+%% Cell type:code id: tags:
+
+``` matlab
+M = [V_ligne; V_colonne']
+```
+
+%% Cell type:markdown id: tags:
+
+Comme les valeurs de M sont régulièrement espacées, il est possible d'utiliser des **plages de valeurs** avec un certain pas.
+Exécutez les deux instructions suivantes et identifiez à chaque fois les bornes de la plage ainsi que le pas.
+
+%% Cell type:code id: tags:
+
+``` matlab
+Enum1 = 3:7:90
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+Enum2 = 5:3:20
+```
+
+%% Cell type:markdown id: tags:
+
+Essayez de réécrire V_ligne, V_colonne et M en utilisant des plages.
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_ligne =
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_colonne =
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+M =
+```
+
+%% Cell type:markdown id: tags:
+
+ Vérifiez avec les solutions données ci-dessous.
+ **Attention à ne pas écrire V_colonne = 2:2:10'** car la transposition ne s'applique alors qu'à 10 et on obtiendrait un vecteur ligne.
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_ligne = 1:2:9
+V_colonne = (2:2:10)'
+V_colonne = transpose(2:2:10)
+M = [1:2:9; 2:2:10]
+```
+
+%% Cell type:markdown id: tags:
+
+Enfin, il est possible de définir des matrices ne contenant que des 0 ou que des 1, ou encore des matrices identités (des 1 sur la diagonale et des 0 partout ailleurs).
+Dans tous ces cas, il faut indiquer les dimensions de la matrice souhaitée. Si une seule dimension est donnée, elle est utilisée comme nombre de lignes et de colonnes : on obtient alors une matrice carrée.
+
+%% Cell type:code id: tags:
+
+``` matlab
+M0 = zeros(3, 5)
+M1 = ones(3, 5)
+M2 = ones(4, 4)
+M3 = ones(4)
+Id = eye(4)
+```
+
+%% Cell type:markdown id: tags:
+
+## 2) Opérations sur les matrices
+
+Il est possible d'ajouter une constante à un vecteur/une matrice :
+
+%% Cell type:code id: tags:
+
+``` matlab
+MplusTrois = M+3
+```
+
+%% Cell type:markdown id: tags:
+
+Il est possible de multiplier un vecteur/une matrice par une constante :
+
+%% Cell type:code id: tags:
+
+``` matlab
+troisFoisM = 3*M
+```
+
+%% Cell type:markdown id: tags:
+
+Il est possible d'additionner des matrices de mêmes tailles
+
+%% Cell type:code id: tags:
+
+``` matlab
+MplusMplusM = M+M+M
+```
+
+%% Cell type:markdown id: tags:
+
+Attention, sous certaines conditions, Matlab permet les additions entre une matrice et un vecteur s'ils ont une dimension en commun.
+Le vecteur est alors répliqué selon la dimension non commune pour faire la même taille que la matrice. Par exemple, les deux instructions suivantes sont équivalentes :
+
+%% Cell type:code id: tags:
+
+``` matlab
+M + [1 3 5 7 9]
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+M + [1 3 5 7 9; 1 3 5 7 9]
+```
+
+%% Cell type:markdown id: tags:
+
+M est de taille (2,5) et V_ligne = [1 3 5 7 9] est de taille (1,5) donc, lors de l'addition, V_ligne est répliqué deux fois pour faire la taille de M.
+Vous nous déconseillons d'utiliser cette réplication propre à Matlab et nous verrons plus loin comment répliquer manuellement un vecteur ou une matrice.
+
+%% Cell type:markdown id: tags:
+
+Le produit matriciel usuel entre M1 de taille (m,k) et M2 de taille (k,n) donne une matrice de taille (m,n).
+Il se fait comme suit :
+
+%% Cell type:code id: tags:
+
+``` matlab
+M*V_colonne
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_ligne*V_colonne
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+V_colonne*V_ligne
+```
+
+%% Cell type:markdown id: tags:
+
+Il est alors possible de répliquer un vecteur en le multipliant par un vecteur ones de taille adaptée. Par exemple, pour répliquer [1 3 5 7 9] de taille (1,5) en [1 3 5 7 9; 1 3 5 7 9] de taille (2,5), on peut faire l'instruction suivante :
+
+%% Cell type:code id: tags:
+
+``` matlab
+ones(2,1) * [1 3 5 7 9]
+```
+
+%% Cell type:markdown id: tags:
+
+Enfin, il existe la fonction **repmat** (pour réplique matrice) qui permet de répliquer une matrice un certain nombre de fois horizontalement et un certain nombre de fois verticalement pour obtenir une plus grande matrice. Par exemple :
+
+%% Cell type:code id: tags:
+
+``` matlab
+repmat(M, 4, 2)
+```
+
+%% Cell type:markdown id: tags:
+
+Ainsi, pour répliquer [1 3 5 7 9] en une matrice de tailles (2,5), on peut faire :
+
+%% Cell type:code id: tags:
+
+``` matlab
+repmat([1 3 5 7 9], 2, 1)
+```
+
+%% Cell type:markdown id: tags:
+
+Il est possible de vectoriser une matrice. Le vecteur obtenu est **la concaténation des colonnes** de la matrice.
+
+%% Cell type:code id: tags:
+
+``` matlab
+M_vectorise = M(:)
+```
+
+%% Cell type:markdown id: tags:
+
+Sur des matrices de mêmes tailles, il est possible d'effectuer des **opérations élément par élément**, comme suit :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I = [200 180 170 190 155; 205 190 195 165 150; 210 215 175 155 190]
+Coefficients = [0.5 0.2 0.4 0.8 1; 0.4 0.2 0 1 0.9; 0.75 0.5 0.6 1 0.1]
+
+I.*Coefficients % Produit élément par élément de I et de Coefficients
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+I.*I % Matrice des carrés des éléments de I
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+I.^3 % Matrice de chaque élément de I élevé à la puissance 3
+```
+
+%% Cell type:markdown id: tags:
+
+Certaines fonctions s'effectuent sur tous les éléments d'une matrice sans qu'il soit nécessaire de le préciser avec un ".".
+C'est notamment le cas des fonctions usuelles cosinus **cos**, sinus **sin**, racine carrée **sqrt**, etc :
+
+%% Cell type:code id: tags:
+
+``` matlab
+racineI = sqrt(I)
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+I - racineI.*racineI
+```
+
+%% Cell type:markdown id: tags:
+
+Dans cet exemple, on remarque que l'on obtient pas une matrice entièrement composée de 0 car la précision de la machine sur les opérations flottantes est limitée. Notez la présence du facteur multiplicatif 1.0e-13.
+
+%% Cell type:markdown id: tags:
+
+## 3) Modification des éléments d'une matrice
+
+Lorsque l'on veut modifier la valeur d'un élément en particulier, une première syntaxe consiste à préciser le numéro de ligne et le numéro de colonne de l'élément :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z1 = zeros(7, 5); % Ce point-virgule en fin de ligne permet de ne pas afficher le résultat de l'instruction
+Z1(2, 3) = 4
+```
+
+%% Cell type:markdown id: tags:
+
+On remarque qu'en Matlab, les indices commencent à 1 et non à 0 comme dans de nombreux langages (C, Python...).
+Une deuxième syntaxe consiste à donner **l'indice absolu** de l'élément. De nouveau, on compte selon les colonnes :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z1(5) = 18
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z1(13) = 21
+```
+
+%% Cell type:markdown id: tags:
+
+Il existe deux fonctions **sub2ind** et **ind2sub** qui permettent de convertir un indice absolu en indices relatifs (numéros de ligne et de colonne) et inversement. Il est nécessaire de donner la taille de la matrice considérée en entrée de ces fonctions :
+
+%% Cell type:code id: tags:
+
+``` matlab
+[ligne, colonne] = ind2sub(size(Z1), 13)
+indice_absolu = sub2ind(size(Z1), 2, 4)
+```
+
+%% Cell type:markdown id: tags:
+
+La fonction **ind2sub** est une fonction qui peut renvoyer plusieurs sorties : elle renvoie l'indice de ligne et l'indice de colonne. Nous donnerons d'autres exemples de ce genre de fonctions plus loin.
+
+%% Cell type:markdown id: tags:
+
+Pour modifier plusieurs éléments simultanément, il faut indiquer les indices des éléments à modifier et donner les nouvelles valeurs de ces éléments dans une matrice de taille adaptée. Nous donnons plusieurs exemples ci-dessous, prenez le temps de les comprendre :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z2 = zeros(9, 7);
+Z2(2, 3:7) = V_ligne
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z2(4:8, 1) = V_colonne
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z2(5:6, 3:7) = M
+```
+
+%% Cell type:markdown id: tags:
+
+Il est possible d'extraire une sous-matrice en indiquant les plages d'indices désirées. Par exemple :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z2(3:8, 1:5)
+```
+
+%% Cell type:markdown id: tags:
+
+On peut également indiquer un pas. Essayez de prédire ce que renvoie l'instruction suivante puis exécutez-la :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z2(2:2:6, 3:2:7)
+```
+
+%% Cell type:markdown id: tags:
+
+La sous-matrice obtenue est de taille (3,3). Il est donc possible de modifier tous ces éléments d'un coup en donnant les nouvelles valeurs dans une matrice de taille (3,3), comme dans l'exemple suivant. Prenez le temps de bien localiser les éléments de A dans la matrice Z2 :
+
+%% Cell type:code id: tags:
+
+``` matlab
+A = [3 4 2; 5 5 5; 9 0 3]
+Z2(2:2:6, 3:2:7) = A
+```
+
+%% Cell type:markdown id: tags:
+
+La longueur d'un vecteur peut être obtenue par la fonction **length** :
+
+%% Cell type:code id: tags:
+
+``` matlab
+longueur = length(V_ligne)
+```
+
+%% Cell type:markdown id: tags:
+
+L'utilisation de **length** sur une matrice est déconseillé car la fonction ne retourne alors que la plus grande dimension de la matrice.
+
+Le **nombre de lignes** et le **nombre de colonnes** d'une matrice peuvent être obtenus avec **size** en faisant :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z3 = zeros(6, 4)
+nb_lignes = size(Z3, 1)
+nb_colonnes = size(Z3, 2)
+plus_grande_dimension = length(Z3)
+```
+
+%% Cell type:markdown id: tags:
+
+Il existe plusieurs façons de redéfinir une ligne (ou une colonne) entière. On peut donner une plage d'indices allant de 1 à nb_lignes ou nb_colonnes :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z3(4, 1:nb_colonnes) = 99
+Z3(1:nb_lignes, 2) = -55
+```
+
+%% Cell type:markdown id: tags:
+
+On peut utiliser le symbole ":" qui indique de considérer tous les éléments de la ligne (ou de la colonne) :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z4 = zeros(6, 4)
+Z4(3, :) = 11
+Z4(:, 4) = -33
+```
+
+%% Cell type:markdown id: tags:
+
+Enfin, il est possible d'utiliser le mot clé "end" à la place de nb_lignes ou nb_colonnes :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z5 = zeros(6, 4)
+Z5(2, 1:end) = 222
+Z5(1:end, 1) = 666
+```
+
+%% Cell type:markdown id: tags:
+
+Pour modifier simultanément plusieurs éléments, on utilise un vecteur d'indices absolus. Par exemple, pour mettre la valeur 1 aux indices absolus 2, 5, 7, 12, 13, 14, 19 d'une matrice de tailles (6,4), on utilise :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Z6 = zeros(6, 4)
+Z6([2, 5, 7, 12, 13, 14, 19]) = 1
+```
+
+%% Cell type:markdown id: tags:
+
+La fonction **sub2ind** évoquée précédemment peut s'avérer utile pour récupérer un indice absolu à partir des numéros de ligne et de colonne d'un élément. En pratique, on n'utilise rarement ces conversions car Matlab dispose de fonctions qui permettent de s'en passer. Nous donnons un exemple ci-dessous.
+
+%% Cell type:markdown id: tags:
+
+Supposons que l'on dispose d'une matrice I et que l'on souhaite remplacer tous les éléments de I de valeur inférieure à un certain seuil (disons 177) par 0. L'instruction I <= 177 renvoie une matrice booléenne :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I = [200 180 170 190 155; 205 190 195 165 150; 210 215 175 155 190]
+I <= 177
+```
+
+%% Cell type:markdown id: tags:
+
+Pour récupérer les indices des valeurs de I inférieures à 177 avec **find** :
+
+%% Cell type:code id: tags:
+
+``` matlab
+find(I <= 177)
+```
+
+%% Cell type:markdown id: tags:
+
+On peut alors récupérer les valeurs de I inférieures à 177 en faisant :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I(find(I <= 177))
+```
+
+%% Cell type:markdown id: tags:
+
+L'instruction suivante, plus épurée, renvoie le même résultat :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I(I <= 177)
+```
+
+%% Cell type:markdown id: tags:
+
+Ainsi, pour mettre à 0 tous les éléments de I inférieures à 177, on peut écrire :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I(I<=177) = 0
+```
+
+%% Cell type:markdown id: tags:
+
+qui est la version plus épurée de :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I(find(I<=177)) = 0
+```
+
+%% Cell type:markdown id: tags:
+
+Enfin, pour tester l'égalité entre deux matrices (ou vecteurs), on pourrait être tentés de faire :
+
+%% Cell type:code id: tags:
+
+``` matlab
+A = [pi, 2*pi, 3*pi; 4*pi, 5*pi, 6*pi]
+B = [3.1416, 6.2832, 9.4248; 12.5664, 15.7080, 18.8496]
+A == B
+```
+
+%% Cell type:markdown id: tags:
+
+Les valeurs affichées dans A et dans B sont les mêmes. Pourtant, la matrice de booléens A == B ne contient que des 0 (associés à la valeur "faux"). Deux problèmes entrent en jeu :
+- d'une part, Matlab n'affiche qu'un certain nombre de décimales ;
+- d'autre part, lorsque l'on manipule des nombres flottants, on manipule en vérité des valeurs à une précision machine près.
+
+La façon standard de vérifier que deux flottants sont égaux consiste donc à vérifier que leur différence en valeur absolue est inférieur à un certain seuil de précision fixé par l'utilisateur en fonction du contexte. Par exemple :
+
+%% Cell type:code id: tags:
+
+``` matlab
+abs(pi-3.1416) < 0.001
+abs(pi-3.1416) < 0.000001
+```
+
+%% Cell type:markdown id: tags:
+
+De façon analogue, la vérification d'égalité entre deux matrices impliquera :
+- de vérifier qu'elles ont la même taille (donc le même nombre de coefficients) ;
+- que les différences en valeur absolue des coefficients terme à terme sont inférieures à un certain seuil.
+
+%% Cell type:markdown id: tags:
+
+## 4) Fonctions utiles
+On peut modifier la forme d'une matrice avec la fonction **reshape** : la seule contrainte est que le nombre d'éléments total doit rester le même. À nouveau, l'ordre des éléments se retrouve dans la vectorisation de la matrice, comme illustré ci-dessous sur une matrice de taille (4,6) (donc à 24 éléments). Prenez le temps de bien comprendre les exemples ci-dessous :
+
+%% Cell type:code id: tags:
+
+``` matlab
+J = [200 180 170 190 155 120; 205 190 195 165 150 60; 210 215 175 155 190 160; 125 155 165 145 200 185]
+J1 = J(:) % Vectorisation de J
+J2 = reshape(J, 3, 8)
+J3 = reshape(J, 6, 4)
+J4 = reshape(J, 8, 3)
+J5 = reshape(J, 24, 1) % équivalent à J(:)
+```
+
+%% Cell type:markdown id: tags:
+
+La fonction **max** permet de récupérer l'élément d'un vecteur (colonne ou ligne) de valeur maximale, ainsi que son indice.
+Il s'agit d'une fonction qui peut renvoyer plusieurs sorties, tout comme **size**.
+
+%% Cell type:code id: tags:
+
+``` matlab
+W = [4, 12, 3, 7, 6]
+```
+
+%% Cell type:markdown id: tags:
+
+Observez les deux syntaxes suivantes et identifiez les différences :
+
+%% Cell type:code id: tags:
+
+``` matlab
+valeur_maximale = max(W)
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+[valeur_maximale, indice_du_maximum] = max(W)
+```
+
+%% Cell type:markdown id: tags:
+
+Si l'on ne précise qu'une seule sortie, **max** ne renvoie que la valeur maximale.
+Pour obtenir l'indice du maximum, il faut demander deux sorties entre crochets comme dans la deuxième syntaxe.
+Si l'on ne souhaite se servir que de l'indice du maximum, il est possible de se passer de la sortie correspondant à la valeur du maximum avec le symbole "~" :
+
+%% Cell type:code id: tags:
+
+``` matlab
+[~, indice_du_maximum] = max(W)
+```
+
+%% Cell type:markdown id: tags:
+
+Dans le cas d'une matrice, la fonction **max** permet de récupérer la valeur maximale de chaque colonne ainsi que son indice.
+
+%% Cell type:code id: tags:
+
+``` matlab
+J
+maxima = max(J)
+[~, indices_maxima] = max(J)
+```
+
+%% Cell type:markdown id: tags:
+
+De la même façon, la fonction **sort** permet de trier les valeurs par ordre croissant ('ascend') ou décroissant ('descend') et de renvoyer les indices correspondants si deux sorties sont demandées.
+
+%% Cell type:code id: tags:
+
+``` matlab
+W
+valeurs_ordre_croissant = sort(W, 'ascend') % Par défaut, sort utilise ascend s'il n'y a pas de 2ème paramètre
+valeurs_ordre_decroissant = sort(W, 'descend')
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+[valeurs_ordre_croissant, indices_ordre_croissant] = sort(W, 'ascend')
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+[~, indices_ordre_croissant] = sort(W, 'ascend')
+```
+
+%% Cell type:markdown id: tags:
+
+On peut vérifier que W(indices_ordre_croissant) donne valeurs_ordre_croissant :
+
+%% Cell type:code id: tags:
+
+``` matlab
+W(indices_ordre_croissant)
+valeurs_ordre_croissant
+```
+
+%% Cell type:markdown id: tags:
+
+La fonction **mean** renvoie :
+- la moyenne des éléments d'un vecteur lorsqu'elle est utilisée sur un vecteur ;
+- les moyennes de chaque colonne ou de chaque ligne d'une matrice lorsqu'elle est utilisée sur une matrice.
+
+Pour préciser si la moyenne doit être calculée par lignes ou par colonnes, il est nécessaire d'ajouter un deuxième argument égal à 1 (par colonnes) ou à 2 (par lignes). Par défaut, en l'absence de deuxième argument, la moyenne est calculée par colonnes (valeur par défaut : 1).
+
+%% Cell type:code id: tags:
+
+``` matlab
+V = [2 3 5 8 12]
+mean(V)
+
+M = [1 3 5 7 9; 2 4 6 8 10]
+moyennes_par_colonnes = mean(M, 1)
+moyennes_par_lignes = mean(M, 2)
+moyennes_par_defaut = mean(M)
+```
+
+%% Cell type:markdown id: tags:
+
+De façon similaire, la fonction **sum** renvoie :
+- la somme des éléments d'un vecteur lorsqu'elle est utilisée sur un vecteur ;
+- les sommes de chaque colonne ou de chaque ligne d'une matrice lorsqu'elle est utilisée sur une matrice.
+De nouveau, pour préciser si les moyennes doivent être calculées par lignes ou par colonnes, on ajoute un deuxième argument égal à 1 (par colonnes) ou à 2 (par lignes). Par défaut, si l'on n'indique pas de deuxième argument, il est égal à 1.
+
+%% Cell type:code id: tags:
+
+``` matlab
+V = [2 3 5 8 12]
+sum(V)
+
+M = [1 3 5 7 9; 2 4 6 8 10]
+sommes_par_colonnes = sum(M, 1)
+sommes_par_lignes = sum(M, 2)
+sommes_par_defaut = sum(M)
+```
+
+%% Cell type:markdown id: tags:
+
+Ainsi, les moyennes peuvent être calculées soit avec **mean**, soit avec **sum** et **size**.
+
+%% Cell type:code id: tags:
+
+``` matlab
+M = [1 3 5 7 9; 2 4 6 8 10];
+mean(M, 1)
+sum(M, 1)/size(M, 1)
+mean(M, 2)
+sum(M, 2)/size(M, 2)
+```
+
+%% Cell type:markdown id: tags:
+
+Enfin, il est possible de consulter la document d'une fonction avec la commande **help**. Des exemples numériques sont notamment donnés en fin de documentation :
+
+%% Cell type:code id: tags:
+
+``` matlab
+help sum
+```
+
+%% Cell type:markdown id: tags:
+
+## 5) Définir une fonction
+
+%% Cell type:markdown id: tags:
+
+Il est possible de définir des fonctions en donnant ses paramètres d'entrée et de sortie.
+Attention, cette fonctionnalité n'étant pas disponible sur notebook, vous aurez le message d'erreur suivant en exécutant le bloc : "Error: Function definition not supported in this context. Create functions in code file".
+L'idée est avant tout de voir la syntaxe d'une défintion de fonction.
+
+Par exemple, si l'on veut définir une fonction appelée **calculs_basiques** qui, à partir de deux entrées **a** et **b** renvoie trois sorties contenant respectivement la somme, la différence et le produit de **a** et **b**, on peut écrire :
+
+%% Cell type:code id: tags:
+
+``` matlab
+function [somme, difference, produit] = calculs_basiques(A, B)
+    somme = A+B;
+    difference = A-B;
+    produit = A.*B;
+end
+```
+
+%% Cell type:markdown id: tags:
+
+Il serait également possible de stocker ces trois valeurs dans un vecteur et de n'avoir que ce vecteur en sortie. On écrirait alors :
+
+%% Cell type:code id: tags:
+
+``` matlab
+function resultats = calculs_basiques_variante(A, B)
+    resultats = [A+B, A-B, A*B];
+end
+```
+
+%% Cell type:markdown id: tags:
+
+Il faut faire bien attention à la façon dont sont appelées les fonctions dans le code. Par exemple, si l'on écrit :
+
+%% Cell type:code id: tags:
+
+``` matlab
+resultats = calculs_basiques(3, 5);
+```
+
+%% Cell type:markdown id: tags:
+
+resultats sera égal à 8 car il ne contiendra que la première sortie de **calculs_basiques** (somme). On a déjà abordé ce point en présentant les fonctions **sort** et **max** : elles peuvent retourner plusieurs sorties mais ne retournent que la première d'entre elles si l'on ne précise pas avec des crochets les sorties désirées.
+
+À l'inverse, si l'on écrit :
+
+%% Cell type:code id: tags:
+
+``` matlab
+[somme, difference, produit] = calculs_basiques_variante(3, 5);
+```
+
+%% Cell type:markdown id: tags:
+
+une erreur sera affichée car une seule sortie est attendue de la part de la fonction **calculs_basiques_variante**.
+
+%% Cell type:markdown id: tags:
+
+## 6) Les structures de contrôle
+### 6.1) Les boucles for
+
+%% Cell type:markdown id: tags:
+
+Lorsque l'on veut faire une boucle **for** en Matlab, on précise un vecteur contenant toutes les valeurs que doit prendre l'indice de boucle (i dans l'exemple donné ci-dessous). Par exemple, pour une boucle de 1 à 1000 on utilisera le vecteur [1 2 3 ... 1000] qui s'écrit plus simplement 1:1000.
+
+%% Cell type:code id: tags:
+
+``` matlab
+somme = 0;
+for i = 1:10
+    somme = somme + i  % Ajouter un ';' en fin de ligne permet d'éviter l'affichage à chaque tour de boucle
+end
+```
+
+%% Cell type:markdown id: tags:
+
+Cet exemple illustre bien l'intérêt d'ajouter des ';' en fin de ligne pour éviter l'affichage.
+
+Dans l'exemple suivant, nous souhaitons calculer une matrice C qui est la somme de deux matrices A et B.
+Nous montrons comment le faire de deux manières différentes :
+- avec une boucle **for**
+- matriciellement
+
+Pour chaque méthode, nous mesurons le temps d'exécution en appelant les instructions **tic** et **toc** respectivement avant et après le bloc de code dont on veut mesurer le temps d'exécution.
+
+%% Cell type:code id: tags:
+
+``` matlab
+A = rand(2000,1500);
+B = rand(size(A));
+C = zeros(size(A));
+
+tic
+% Avec une boucle for
+for i = 1:size(C, 1)
+    for j = 1:size(C, 2)
+        C(i, j) = A(i, j) + B(i, j);
+    end
+end
+toc
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+A = rand(2000, 1500);
+B = rand(size(A));
+C = zeros(size(A));
+
+tic
+C = A + B;
+toc
+```
+
+%% Cell type:markdown id: tags:
+
+Bien souvent, le fait d'utiliser des boucles **for** augmente les temps de calcul.
+Il n'est cependant pas toujours évident de se passer de ces boucles, mais nous vous demanderons de les éviter au maximum lorsqu'elles sont remplaçables par d'autres fonctions ou opérations matricielles.
+
+Pour illustrer un cas où se passer de boucle **for** n'est pas évident, nous proposons l'exemple d'une quantification d'histogramme.
+Nous souhaitons compter le nombre d'éléments d'une matrice dont la valeur est comprise entre 0 et 0.1, entre 0.1 et 0.2, entre 0.2 et 0.3...et entre 0.9 et 1.
+De nouveau, nous proposons une version avec boucle **for** et une version sans. Prenez le temps de bien comprendre les deux versions :
+
+%% Cell type:code id: tags:
+
+``` matlab
+M = rand(800, 600);
+
+Histogramme = zeros(1, 10);
+
+tic
+for i = 1:size(M, 1)
+    for j = 1:size(M, 2)
+        valeur = floor(M(i, j)*10);  % pour obtenir un indice entre 0 et 9
+        indice = valeur+1;  % les indices en Matlab commencent à 1
+        Histogramme(indice) = Histogramme(indice) + 1;
+    end
+end
+toc
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+M = rand(800, 600);
+
+Histogramme = zeros(1, 10);
+
+tic
+M = repmat(M(:), 1, 10);
+intervalles1 = 0:0.1:0.9;
+intervalles2 = 0.1:0.1:1;
+
+Histogramme = sum(M >= intervalles1 & M < intervalles2);
+toc
+```
+
+%% Cell type:markdown id: tags:
+
+Le symbole **&** désigne ici le ET logique.
+De la même façon, on peut écrire un OU logique avec le symbole **|**
+
+%% Cell type:markdown id: tags:
+
+### 6.2) Utilisation de while et if
+
+%% Cell type:markdown id: tags:
+
+Nous illustrons rapidement l'utilisation de **while** et **if** au travers de l'exemple d'une fonction cherchant à déterminer si un nombre **n** est premier ou non en calculant le reste de la division euclidienne de tous les nombres de 2 à racine carrée (**sqrt**) de **n** et en déclarant que le nombre n'est pas premier si l'un de ces restes est nul. En Matlab, on peut écrire :
+
+%% Cell type:code id: tags:
+
+``` matlab
+function primalite = est_premier(n)
+    primalite = 1;
+    indice = 2;
+    while indice <= sqrt(n) & primalite
+        if mod(n, indice) == 0
+            primalite = 0;
+        end
+        indice = indice + 1;
+    end
+end
+```
+
+%% Cell type:markdown id: tags:
+
+## 7) Affichage de courbes
+
+### 7.1) plot de R dans R
+
+Il est possible de tracer des courbes avec la fonction **plot**.
+Commençons par un exemple simple :
+
+%% Cell type:code id: tags:
+
+``` matlab
+X = [3, 5, 7, 8, 11, 15];
+Y = [3, 4, -5, 6, 1, 10];
+plot(X, Y);
+```
+
+%% Cell type:markdown id: tags:
+
+Pour ajouter un titre à la figure, on peut faire :
+
+%% Cell type:code id: tags:
+
+``` matlab
+plot(X, Y);
+title('Tracer de Y en fonction de X');
+```
+
+%% Cell type:markdown id: tags:
+
+On peut également ajouter du texte le long des axes :
+
+%% Cell type:code id: tags:
+
+``` matlab
+plot(X, Y);
+title('Tracer de Y en fonction de X');
+xlabel('Valeurs contenues dans X');
+ylabel('Valeurs contenues dans Y');
+```
+
+%% Cell type:markdown id: tags:
+
+On peut préciser la couleur du tracé de la façon suivante :
+
+%% Cell type:code id: tags:
+
+``` matlab
+plot(X, Y,'r');
+```
+
+%% Cell type:markdown id: tags:
+
+Si on ne souhaite qu'avec des points non reliés, on peut indiquer le type de marqueurs (parmi *, +, o)
+
+%% Cell type:code id: tags:
+
+``` matlab
+plot(X, Y,'*');
+```
+
+%% Cell type:markdown id: tags:
+
+Pour combiner marqueur et couleur :
+
+%% Cell type:code id: tags:
+
+``` matlab
+plot(X, Y,'r*');
+```
+
+%% Cell type:markdown id: tags:
+
+On peut regrouper plusieurs figures avec la fonction **subplot** : on indique d'abord le nombre de lignes n, le nombre de colonnes m et enfin l'indice (entre 1 et n\*m) de la figure que l'on dessine. On peut choisir pour chaque sous-figure d'ajouter un titre et des étiquettes sur les axes ou non :
+
+%% Cell type:code id: tags:
+
+``` matlab
+subplot(2,2,1);
+plot(X, Y);
+title('Titre de la sous-figure 1')
+
+subplot(2,2,2);
+plot(X, Y,'r');
+xlabel('Axe X de la figure 2')
+
+subplot(2,2,3);
+plot(X, Y,'*');
+ylabel('Axe Y de la figure 3')
+
+subplot(2,2,4);
+plot(X, Y,'r*');
+title('Titre de la sous-figure 4')
+xlabel('Axe X de la figure 4')
+ylabel('Axe Y de la figure 4')
+```
+
+%% Cell type:markdown id: tags:
+
+### 7.2) plot de R² dans R
+
+La fonction **contour(X, Y, Z)** permet un affichage en lignes de niveaux. De nouveau, nous illustrons son utilisation au travers d'un exemple. Nous commençons par définir deux axes X et Y gradués à chaque unité de -20 à 20 : X et Y sont donc deux vecteurs de taille 41. Une valeur z est attribuée à chaque couple (x, y). Pour pouvoir utiliser **contour**, il faut stocker tous les valeurs z dans une matrice Z (qui seront donc de taille 41x41).
+
+Pour avoir une certaine régularité dans les lignes de niveaux de l'exemple ci-dessous, nous calculons chaque valeur de Z à partir des valeurs voisines et perturbons la valeur d'une quantité comprise entre -0.5 et 0.5 (rand-0.5). Il aurait été possible de simplement assigner une valeur aléatoire, mais les lignes de niveaux auraient alors été plus difficiles à visualiser.
+
+%% Cell type:code id: tags:
+
+``` matlab
+X = -20:20;
+Y = -20:20;
+Z = zeros(41,41);
+for i = 2:41
+    for j = 2:41
+        Z(i,j) = rand - 0.5 + (Z(i-1,j-1)+Z(i-1,j)+Z(i,j-1))/3;
+    end
+end
+contour(X, Y, Z);
+```
+
+%% Cell type:markdown id: tags:
+
+Enfin, la documentation Matlab détaille et illustre tous les types d'affichage possibles (on y retrouve notamment des histogrammes et des courbes en 3D) sur la page suivante : https://www.mathworks.com/help/matlab/creating_plots/types-of-matlab-plots.html
+
+%% Cell type:markdown id: tags:
+
+## 8) Lecture et affichage d'images
+
+En Matlab, les images sont représentées par des matrices dont chaque élément représente le niveau de gris (pour des images en noir et blanc) ou la couleur (pour des images en couleur) d'un pixel de l'image. Pour des images en niveaux de gris, les matrices associées sont bidimensionnelles et sont de taille (nb_lignes, nb_colonnes). Pour des images en couleur, les matrices associées sont tridimensionnelles et sont de taille (nb_lignes, nb_colonnes, 3) : les 3 canaux de la troisième dimension permettent d'encoder le niveau de couleur (rouge, vert ou bleu) du pixel (codage RGB).
+
+Les valeurs sont prises entre 0 et 255 inclus.
+
+À titre d'exemples :
+- (r = 255, g = 0, b = 0) donne du rouge vif
+- (r = 255, g = 255, b = 0) donne du jaune vif
+- (r = 128, g = 128, b = 128) donne du gris
+- pour des images en niveaux de gris, 0 correspond au noir et 255 au blanc
+
+Vous pouvez sélectionner une couleur et obtenir son code RGB sur le site suivant : https://htmlcolorcodes.com/fr/selecteur-de-couleur/
+
+De manière générale, les fonctions d'affichage seront déjà écrites dans les TP de probabilités et statistiques. Nous présentons donc rapidement les principales fonctions.
+
+Matlab dispose de quelques images internes.
+La lecture d'une image se fait avec la fonction **imread** :
+
+%% Cell type:code id: tags:
+
+``` matlab
+I = imread('einstein.jpg')
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+imagesc(I);
+```
+
+%% Cell type:markdown id: tags:
+
+Pour l'affichage des images en niveaux de gris, Matlab utilise une palette de couleurs. Par défaut, il s'agit de couleurs allant du jaune/vert pour les niveaux de gris élevés au bleu pour les niveaux de gris faibles.
+Il est possible de modifier la palette de couleurs avec l'instruction **colormap** comme suit :
+
+%% Cell type:code id: tags:
+
+``` matlab
+colormap gray;
+imagesc(I);
+```
+
+%% Cell type:markdown id: tags:
+
+Ci-dessous, un exemple d'image en couleur. Notez que la matrice est affichée canal par canal : I(:,:,1) correspond au canal rouge, I(:,:,2) au canal vert et I(:,:,3) au canal bleu. En pratique, on n'affichera pas les matrices. Pour cela, vous pouvez ajouter un ";" en fin de ligne.
+
+Lorsque l'on affiche des images en couleur, il n'y a pas de colormap à gérer.
+
+%% Cell type:code id: tags:
+
+``` matlab
+I = imread('fruits.jpg');  % En mettant un ";" après la fermeture de parenthèse, la matrice n'est pas affichée
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+imagesc(I);
+```
+
+%% Cell type:markdown id: tags:
+
+## 9) Exemple complet : distance moyenne entre deux points d'un cercle
+Nous présentons ici un exemple de programme Matlab faisant appel à différentes fonctionnalités présentées précédemment. Assurez-vous de bien comprendre chacune des lignes de code.
+
+On se propose de calculer la distance moyenne entre deux points situés sur un cercle de rayon 1.
+Pour cela, nous tirons aléatoirement 100 paires de points et calculons les distances entre points, paire par paire.
+Pour faire ce tirage aléatoire, nous utilisons la fonction **rand** qui tire des valeurs aléatoires entre 0 et 1 (selon une loi uniforme) et multiplions par 2\*pi pour avoir des angles entre 0 et 2\*pi et donc des points sur le cercle unité en utilisant **cos** et **sin**.
+
+%% Cell type:code id: tags:
+
+``` matlab
+nb_points = 100;
+
+thetas1 = 2*pi*rand(1, nb_points); % Pour tirer nb_points angles entre 0 et 2*pi
+thetas2 = 2*pi*rand(1, nb_points); % Pour tirer nb_points autres angles entre 0 et 2*pi
+
+points1 = [cos(thetas1); sin(thetas1)]; % Pour créer nb_points points sur le cercle unité
+points2 = [cos(thetas2); sin(thetas2)]; % Pour créer nb_points autres points sur le cercle unité
+
+distances = sqrt(sum((points1 - points2).^2,1));
+% (points1 - points2).^2 contient les (x2-x1)^2 sur la première ligne et les (y2-y1)^2 sur la deuxième ligne
+% sum(points1 - points2).^2,1) est un vecteur contenant les (x2-x1)^2+(y2-y1)^2
+% sqrt(sum(points1 - points2).^2,1)) est un vecteur contenant les Racine((x2-x1)^2+(y2-y1)^2), donc les distances
+
+distance_moyenne = mean(distances)
+
+4/pi % Valeur théorique à trouver
+```
+
+%% Cell type:markdown id: tags:
+
+Essayez d'augmenter la valeur de nb_points. Plus elle est grande, plus vous devriez trouver une distance moyenne proche de la distance moyenne théorique.
+
+%% Cell type:markdown id: tags:
+
+## 10) Erreurs classiques
+
+On ne parvient pas toujours à écrire un code sans erreur du premier coup.
+Au travers de messages d'erreur, Matlab indique généralement le type d'erreur rencontré (problème de dimension, variable non définie...) et la ligne à laquelle se produit l'erreur.
+
+Dans cette partie, nous vous fournissons plusieurs instructions Matlab qui renvoient une erreur lorsqu'elles sont lancées. À vous de comprendre d'où proviennent les erreurs et de les corriger :
+
+%% Cell type:code id: tags:
+
+``` matlab
+Matrice = 256*rand(320, 240));  % Matrice de nombres aléatoires entre 0 et 256
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+% On souhaite ajouter à chaque colonne de A sa colonne suivante. La dernière colonne de A reste inchangée.
+Matrice(:, 1:end-1) = Matrice(:, 1:end-1) + matrice(:, 1:end);
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+% On souhaite ensuite centrer les valeurs en retirant la valeur moyenne de la matrice obtenue.
+Matrice = Matrice - repmat(mean(meen(Matrice)), 320, 240);
+```
+
+%% Cell type:code id: tags:
+
+``` matlab
+% On souhaite mettre à 0 tous les coefficients négatifs.
+(Matrice < 0) = 0;
+```