{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8f8b08b8",
   "metadata": {},
   "source": [
    "# Traitement du Signal - TDM2 : Manipulation de signaux temporels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4924f741",
   "metadata": {},
   "source": [
    "Aujourd'hui, après une bonne introduction de NumPy la semaine dernière, on va pouvoir rentrer dans le vif du sujet, à savoir les signaux. Donc, ce n'est pas très compliqué : on va tracer beaucoup de signaux. L'idée est que vous mettiez en pratique ce que vous avez vu durant le précédent TDM, afin de construire et afficher les signaux efficacement.\n",
    "\n",
    "Après avoir vu NumPy, on va utiliser également la librairie Matplotlib, dédiée à l'affichage de données sous toute forme (courbes, graphiques, etc.). Je vous invite donc à faire un tour sur la documentation de ce package, avec évidemment la documentation de NumPy:\n",
    "- NumPy : https://numpy.org/doc/2.3/user/index.html\n",
    "- Matplotlib : https://matplotlib.org/stable/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "807a0dc8",
   "metadata": {},
   "source": [
    "---\n",
    "## Correction du TDM : préambule\n",
    "\n",
    "Pour cette correction de TDM, je vais vous donner pour chaque algorithme une version minimale attendue (c'est-à-dire ce que j'attends que vous codiez au niveau minimum) et une version optimisée. Je vous conseille dans un premier temps de vérifier vos résultats avec ceux de la correction, afin de corriger les potentielles erreurs que vous avez, mais également de jeter un coup d'oeil à la version optimisée. Certaines manipulations peuvent être complexes, mais en réalité, la plupart de celles utilisées sont à votre niveau. L'objectif est que vous puissiez vous améliorer dans votre manière de coder avec NumPy et Matplotlib, même si vous avez déjà une première base fonctionnelle."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a165c65",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "---\n",
    "\n",
    "## Exercice 1 : Traçons plein de signaux !\n",
    "\n",
    "Dans Traitement du Signal, il y'a Signal. On va donc partir de la base : créer des signaux via des tableaux unidimensionnels NumPy et tracer les signaux dans de jolies figures via Matplotlib. Pas de panique, on va y aller pas à pas, avec pour commencer, l'importation des librairies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e1a5ac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importation des librairies\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f116f4ad",
   "metadata": {},
   "source": [
    "### Axe temporel\n",
    "\n",
    "Lorsqu'on trace un signal dans le domaine temporel, on affiche l'intensité du signal en fonction du temps. On va donc d'abord créer un vecteur symbolisant le temps en secondes.\n",
    "\n",
    "Créez un tableau unidimensionnel NumPy $t$, allant de -5 à 5 secondes avec un pas de temps de 0.01 secondes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11953449",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel t\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bafd39d7",
   "metadata": {},
   "source": [
    "On a notre axe temporel, créeons maintenant notre premier signal. Il est représenté sous forme de tableau unidimensionnel de même taille que l'axe temporel. Chaque valeur du signal à l'indice $i$ correspond alors à l'intensité du signal au moment $t[i]$.\n",
    "\n",
    "Notre premier signal est simple. Créez un signal proportionnel au temps, toujours sous forme de tableau NumPy unidimensionnel : $s(t) = A \\cdot t$ avec $A=0.5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b30a8b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création du signal s\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cf82da2",
   "metadata": {},
   "source": [
    "On a notre signal, notre axe temporel, il suffit alors de tracer tout ça ! On va utiliser la fonction plot de Matplotlib ([Tutoriel](https://matplotlib.org/stable/gallery/lines_bars_and_markers/simple_plot.html#sphx-glr-gallery-lines-bars-and-markers-simple-plot-py)). Faites moi une jolie figure, avec:\n",
    "- Un titre\n",
    "- Les noms des axes (et leurs unités s'il y'en a)\n",
    "- Une légende de la courbe (on sera amené à afficher plusieurs courbes sur une seule figure, donc une légende permet de mieux comprendre à quoi correspond chaque courbe)\n",
    "\n",
    "*PS: Il y'a dans le tutoriel des fonctions qui ne sont pas utiles. Veuillez sélectionner uniquement celles qui sont pertinentes...*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2096cd0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Affichage du signal s selon l'axe temporel t\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15c1ba9d",
   "metadata": {},
   "source": [
    "Voilà, notre premier signal est tracé. A vous de jouer !"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfcbebc1",
   "metadata": {},
   "source": [
    "### Signal porte $a(t)$\n",
    "\n",
    "La fonction du signal porte est définie par l'équation suivante :\n",
    "\n",
    "\n",
    "\\begin{equation*}\n",
    "a(t) = \\Pi(t) = \n",
    "\\begin{cases} \n",
    "1, & \\text{si } |t| \\leq \\frac{1}{2}, \\\\\n",
    "0, & \\text{sinon}.\n",
    "\\end{cases}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e3d3004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal a\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa851b5f",
   "metadata": {},
   "source": [
    "### Signal échelon unité $b(t)$\n",
    "\n",
    "La fonction du signal échelon unité (aussi appelée fonction de Heaviside) est définie par l'équation suivante :\n",
    "\n",
    "\\begin{equation*}\n",
    "b(t) = \\Gamma(t) = \n",
    "\\begin{cases} \n",
    "0, & \\text{si } t < 0, \\\\\n",
    "1, & \\text{si } t \\geq 0.\n",
    "\\end{cases}\n",
    "\\end{equation*}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eea7bac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal b\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05bd593b",
   "metadata": {},
   "source": [
    "### Signal Échelon Retardé $c(t)$\n",
    "\n",
    "La fonction du signal échelon retardé est une version décalée dans le temps de la fonction échelon unité. Si le retard est $t_{0}$, l'équation est donnée par :\n",
    "\n",
    "\\begin{equation*}\n",
    "c(t) = \\Gamma(t - t_0) = \n",
    "\\begin{cases} \n",
    "0, & \\text{si } t < t_0, \\\\\n",
    "1, & \\text{si } t \\geq t_0.\n",
    "\\end{cases}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4be9f8e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal c\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08947a3a",
   "metadata": {},
   "source": [
    "### Signal $d(t)$\n",
    "Le signal $d(t)$ est défini par l'équation suivante :\n",
    "\n",
    "\\begin{equation*}\n",
    "d(t)= d1(t) \\cdot d2(t) \\cdot d3(t)\n",
    "\\end{equation*}\n",
    "\n",
    "avec :\n",
    "\n",
    "\\begin{equation*}\n",
    "d1(t)= (-t + 3) \n",
    "\\end{equation*}\n",
    "\n",
    "\\begin{equation*}\n",
    "d2(t)= \\Gamma(t + 1)\n",
    "\\end{equation*}\n",
    "\n",
    "\\begin{equation*}\n",
    "d3(t)= \\Gamma(-t + 3)\n",
    "\\end{equation*}\n",
    "\n",
    "Affichez sur la même figure les signaux $d2(t)$, $d3(t)$ et $d(t)$ (n'oubliez pas les légendes !!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "792ffdcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal d\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fb92f59",
   "metadata": {},
   "source": [
    "### Signal $e(t)$\n",
    "\n",
    "Le signal $e(t)$ est défini par l'équation suivante :\n",
    "\n",
    "\\begin{equation*}\n",
    "e(t) = e^{-3t} \\cdot \\Gamma(t - 1)\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "244e1930",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal e\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a4be02a",
   "metadata": {},
   "source": [
    "### Signal cosinus $f(t)$\n",
    "\n",
    "Le signal cosinus est défini par l'équation suivante :\n",
    "\n",
    "\\begin{equation*}\n",
    "f(t) = \\cos(\\omega t)\n",
    "\\end{equation*}\n",
    "\n",
    "où $\\omega$ est la pulsation angulaire en radians par seconde.\n",
    "\n",
    "Ici, on prendra $\\omega = 2.5$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0631c000",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal f\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c4c5d25",
   "metadata": {},
   "source": [
    "Tracez maintenant ce même signal mais sur un axe temporel allant de -5 à -1 puis de 1 à 5 avec un pas de temps de 0.01 secondes.\n",
    "\n",
    "*Note 1 : Il ne faut pas de valeurs à 0 entre -1 et 1, ce qui signifie qu'il faut reconstruire un autre axe temporel t', et recréer un signal f' à partir de l'axe temporel t'.*\n",
    "\n",
    "*Note 2 : Pour créer l'axe temporel t', on peut créer deux axes temporels, puis les concatener...*\n",
    "\n",
    "*Note 3, Infinity War : Si vous tracez le signal sous forme de courbe, vous allez avoir tous vos points reliés. Il faut donc tracer le signal comme si c'était un nuage de points. Allez donc voir les options possibles dans plt.plot (paramètre fmt).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb4c7815",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel t'\n",
    "...\n",
    "\n",
    "# Création et affichage du signal f'\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a181f37",
   "metadata": {},
   "source": [
    "### Signal périodique $g(t)$\n",
    "\n",
    "Le signal $g(t)$ est un signal périodique en $2T$, dont la période (comprise entre $0$ et $2T$) est un signal carré $u(t)$, définie par l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    u(t) = \\left \\{\n",
    "                \\begin{array}{ll}\n",
    "                    1, & \\text{si } 0 \\leq t \\leq T\\\\\n",
    "                    0, & \\text{si } T \\leq t \\leq 2T \\\\\n",
    "                \\end{array}\n",
    "                \\right.\n",
    "\\end{equation*}\n",
    "\n",
    "On prendra ici $T$ = 1 secondes.\n",
    "\n",
    "*Note : pour vous aider dans la construction d'un signal périodique, ici $g(t)$, voici la marche à suivre:*\n",
    "- *Créez d'abord $t'$, une représentation alternative de l'axe temporel $t$, mais indiquant la position dans la période $2T$ (c'est-à dire qu'au lieu d'avoir des valeurs variant de -5 à 5 secondes, vous aurez une répétition de variations entre $0$ et $2T$ dans notre exemple)*\n",
    "\n",
    "- *Construisez ensuite $g(t)$ non pas en fonction de $t$ mais en fonction de $t'$. De ce fait, vous aurez votre signal périodique*\n",
    "- *Lorsque vous affichez votre signal, vous tracerez $g(t)$ en fonction de $t$*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41fb5687",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal g\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55a5f6a2",
   "metadata": {},
   "source": [
    "### Signal périodique $h(t)$\n",
    "\n",
    "Allez, un dernier signal ! Le signal $h(t)$ est un signal périodique en $2T$, dont la période (comprise entre $-T$ et $T$) est un signal triangulaire $\\Delta(t)$, définie par l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    \\Delta(t) = \\left \\{\n",
    "                \\begin{array}{ll}\n",
    "                    t+T, & \\text{si } -T \\leq t \\leq 0 \\\\\n",
    "                    -t+T, & \\text{si } 0 \\leq t \\leq T \\\\\n",
    "                \\end{array}\n",
    "                \\right.\n",
    "\\end{equation*}\n",
    "\n",
    "On prendra ici $T$ = 1 secondes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "144565d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création et affichage du signal h\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32cd29fe",
   "metadata": {},
   "source": [
    "### Une jolie figure qui regroupe tous les signaux !\n",
    "\n",
    "Affichez maintenant tous les signaux ($a$, $b$, $c$, $d$, $e$, $f$, $g$ et $h$) dans une seule figure divisées en 8 sous-figures avec la fonction subplot sur Matplotlib ([Tutoriel](https://matplotlib.org/stable/gallery/subplots_axes_and_figures/subplots_demo.html)). N'oubliez pas les titres/sous-titres. L'objectif est de faire une figure lisible, donc n'hésitez pas à regarder en détail la documentation Matplotlib !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38324f5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Affichage des 8 signaux sur une même figure\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e9c407e",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 2 (optionnel) : Des signaux de détresse !\n",
    "\n",
    "Si vous en êtes là, c'est que vous avez bien tracé les précédents signaux. Le challenge va devenir plus difficile. On va maintenant tracer PLEIN de signaux particuliers, mais pour un but précis que vous devinerez à la fin...\n",
    "\n",
    "*Note : pour un meilleur rendu, je vous conseille de tracer les différents signaux sous forme de nuages de points (comme la fonction $f'$ vue précédemment), à la différence des courbes. C'est seulement pour cet exercice...*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76335706",
   "metadata": {},
   "source": [
    "### Signal B1\n",
    "\n",
    "1er signal à construire : \n",
    "- L'axe temporel T1 est défini de -0.45 à 0.45, avec un pas de 0.005\n",
    "- Le signal B1 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B1(t) = 2\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffa7d17f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T1\n",
    "...\n",
    "\n",
    "# Création du signal B1\n",
    "...\n",
    "\n",
    "# Affichage du signal B1 selon l'axe temporel T1\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "529ce5b3",
   "metadata": {},
   "source": [
    "### Signal B2\n",
    "\n",
    "2ème signal à construire : \n",
    "- L'axe temporel T2 est défini de -7 à -3, puis de 3 à 7, avec un pas de 0.001\n",
    "- Le signal B2 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B2(t) = 3\\sqrt{-\\left(\\frac{t}{7}\\right)^{2}+1}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b70c8958",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T2\n",
    "...\n",
    "\n",
    "# Création du signal B2\n",
    "...\n",
    "\n",
    "# Affichage du signal B2 selon l'axe temporel T2\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e043af1c",
   "metadata": {},
   "source": [
    "### Signal B3\n",
    "\n",
    "3ème signal à construire : \n",
    "- L'axe temporel T3 est défini de -7 à -4, puis de 4 à 7, avec un pas de 0.001\n",
    "- Le signal B3 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B3(t) = -3\\sqrt{-\\left(\\frac{t}{7}\\right)^{2}+1}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f447d7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T3\n",
    "...\n",
    "\n",
    "# Création du signal B3\n",
    "...\n",
    "\n",
    "# Affichage du signal B3 selon l'axe temporel T3\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758958a3",
   "metadata": {},
   "source": [
    "### Signal B4\n",
    "\n",
    "4ème signal à construire : \n",
    "- L'axe temporel T4 est défini par $0.75 \\leq |t| \\leq 1$, avec un pas de 0.001\n",
    "- Le signal B4 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B4(t) = 9-8\\left|t\\right|\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cf259cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T4\n",
    "...\n",
    "\n",
    "# Création du signal B4\n",
    "...\n",
    "\n",
    "# Affichage du signal B4 selon l'axe temporel T4\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96479dac",
   "metadata": {},
   "source": [
    "### Signal B5\n",
    "\n",
    "5ème signal à construire : \n",
    "- L'axe temporel T5 est défini par $0.45 \\leq |t| \\leq 0.75$, avec un pas de 0.001\n",
    "- Le signal B5 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B5(t) = 3\\left|t\\right|+0.75\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6aa9dfb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T5\n",
    "...\n",
    "\n",
    "# Création du signal B5\n",
    "...\n",
    "\n",
    "# Affichage du signal B5 selon l'axe temporel T5\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8252a7c0",
   "metadata": {},
   "source": [
    "### Signal B6\n",
    "\n",
    "6ème signal à construire : \n",
    "- L'axe temporel T6 est défini par $1 \\leq |t| \\leq 3$, avec un pas de 0.001\n",
    "- Le signal B6 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B6(t) = 1.5-.5\\left|t\\right|-\\frac{6\\sqrt{10}}{14}\\left(\\sqrt{3-t^{2}+2\\left|t\\right|}-2\\right)\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0cc2020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T6\n",
    "...\n",
    "\n",
    "# Création du signal B6\n",
    "...\n",
    "\n",
    "# Affichage du signal B6 selon l'axe temporel T6\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68844bc",
   "metadata": {},
   "source": [
    "### Signal B7\n",
    "\n",
    "7ème signal à construire : \n",
    "- L'axe temporel T7 est défini de -4 à 4, avec un pas de 0.0001\n",
    "- Le signal B7 suit l'équation suivante:\n",
    "\n",
    "\\begin{equation*}\n",
    "    B7(t) = \\left|\\frac{t}{2}\\right|-\\frac{3\\sqrt{33}-7}{112}t^{2}+\\sqrt{1-\\left(\\operatorname{abs}\\left(\\left|t\\right|-2\\right)-1\\right)^{2}}-3\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7d61209",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Création de l'axe temporel T7\n",
    "...\n",
    "\n",
    "# Création du signal B7\n",
    "...\n",
    "\n",
    "# Affichage du signal B7 selon l'axe temporel T7\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d60e64ec",
   "metadata": {},
   "source": [
    "### Le reveal final\n",
    "\n",
    "Il est temps de tracer les 7 signaux avec leur axes temporels respectifs sur une seule et même figure. Créez donc cette figure mystérieuse, avec les courbes/nuages de points en noir pour un effet plus dramatique...\n",
    "\n",
    "Et répondez à la question que tout le monde se pose : qui devrait débarquer après avoir tracer ces 7 signaux ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4964b8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A COMPLETER\n",
    "# Affichage des 7 signaux construits sur une seule et même figure\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accb32d1",
   "metadata": {},
   "source": [
    "**_REPONSE :_** TANANANANANANANANA BATMAN !!!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7b2cfb",
   "metadata": {},
   "source": [
    "## Rendu de TP\n",
    "Le rendu qui vous est demandé pour les TDM de TDS est la version HTML de ce notebook. Pour cela, avant de déposer votre rendu, vous devez :\n",
    "- Redémarrer le noyau/kernel Python en effaçant les sorties\n",
    "- Exécuter toutes les cellules du Notebook à la suite\n",
    "- Exporter le fichier en HTML"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "deep",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}