M62_TP1_NOM_Prenom.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "![Département de Mathématiques](https://ktzanev.github.io/logolabopp/math-ulille/math-ulille_100.gif)\n",
    "\n",
    "# TP 1 - Les équations différentielles de dimension 1\n",
    "\n",
    "Dans ce premier TP nous allons étudier numériquement des équations du premier ordre de dimension 1.<br>\n",
    "Il s'agit d'exemples vus dans les **fiche A** de TD.\n",
    "\n",
    "**Attention :** Pour que le code entre les exercices soit au maximum similaire et permettre de faire des copier/coller, nous utilisons plusieurs fois les mêmes noms pour des fonctions différentes. **Ceci est une très mauvaise pratique qui mène à des résultats imprévisibles si on n'exécute pas les cellules dans l'ordre.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "On commence par charger les bibliothèques « standards » dont on aura besoin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# numpy pour les calculs (vectoriels)\n",
    "import numpy as np\n",
    "# matplotlib (référencé comme `plt` ici) pour les graphiques\n",
    "from matplotlib import pyplot as plt\n",
    "# la bibliothèque pour tracer les trajectoires\n",
    "from scipy.integrate import odeint\n",
    "# la bibliothèque qui permet d'utiliser (le décorateur) @interact\n",
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Une fonction utile\n",
    "\n",
    "La fonction `champ_normalise` permet de tracer le champ de vecteur $(1,f(y,t))$ **normalisé** associé au problème de Cauchy $y'=f(y,t)$.\n",
    "La fonction `f` passé en paramètre doit accepter deux **vecteurs** `y` et `t` comme paramètres. Autrement dit elle doit être définie avec `f = lambda y,t : ...` ou avec `def f(y,t):` où `y` et `t` sont des tableaux `numpy` (ou des nombres).\n",
    "\n",
    "**Attention :** L'ordre des paramètres de `f` est inversé par rapport aux cours et les tds :\n",
    "- en cours et td : $y'(t) = f(t,y(t))$ _(temps, puis variable spatiale)_\n",
    "- en python (`odeint`) : `f(y,t)` _(variable spatiale, puis temps)_\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# affiche le champ normalisé sur la figure courante\n",
    "# - f représente la fonction de y'=f(y,t)\n",
    "# - tmin, tmax, ymin, ymax est la fenêtre d'affichage\n",
    "# - N est le nombre de discrétisations en chaque direction\n",
    "def champ_normalise(f, tmin, tmax, ymin, ymax, N=15, **kw):\n",
    "    F = lambda Y: [np.ones_like(Y[0]), f(Y[1], Y[0])]  # la fonction du problème autonome associé\n",
    "    T = np.linspace(tmin, tmax, N)  # abscisses des points de la grille\n",
    "    Y = np.linspace(ymin, ymax, N)  # ordonnées des points de la grille\n",
    "    U, V = F(np.meshgrid(T, Y))  # les composantes du champ de vecteurs\n",
    "    M = np.hypot(U, V)  # calcule la norme du vecteur (U,V)\n",
    "    M[M == 0] = 1  # évite la division par 0\n",
    "    U /= M  # normalise la composante U\n",
    "    V /= M  # normalise la composante V\n",
    "    return plt.quiver(T, Y, U, V, angles='xy', **kw)  # trace le champ de vecteurs sur la grille de NxN points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Exercice 3 (exemple)\n",
    "\n",
    "Commençons par illustrer l'utilisation de python avec l'exercice 3 de la feuille de TD n°1. On vous rappelle que dans cet exercice on a étudié l'équation\n",
    "$$\n",
    "    y'=|y|+|t|\n",
    "$$\n",
    "qui est de la forme de Cauchy $y'=f(y,t)$ avec $f(y,t) =|y|+|t|$.\n",
    "\n",
    "Nous allons définir et tester la fonction $f$ de la façon suivante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# la fonction f\n",
    "f = lambda y, t: np.abs(y) + np.abs(t)\n",
    "\n",
    "# test\n",
    "assert f(0, 0) == 0, \"|0]+|0] = 0\"\n",
    "assert f(-3, 1) == 4, \"|-3]+|1] = 4\"\n",
    "assert np.shape(f(np.ones(3), np.zeros(3))) == (3, ), \"la fonction doit accepter des vecteurs comme paramètres\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Pour dessiner le champ de vecteurs associé à ce problème de Cauchy non autonome de dimension 1, on place $t$ sur abscisse et $y$ sur l'ordonné et on utilise la fonction `champ_normalise` définie précédemment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -2, 2, -2, 2\n",
    "\n",
    "# taille de la figure\n",
    "plt.figure(figsize=(2 * (tmax - tmin), 2 * (ymax - ymin)))\n",
    "# on détermine la fenêtre d'affichage\n",
    "plt.axis([tmin, tmax, ymin, ymax])\n",
    "# on trace les axes en `yellow`\n",
    "plt.plot([tmin, tmax], [0, 0], \"y\")\n",
    "plt.plot([0, 0], [ymin, ymax], \"y\")\n",
    "\n",
    "# on dessine le champ normalisé\n",
    "champ_normalise(f, tmin, tmax, ymin, ymax, width=.002)\n",
    "\n",
    "# on rajoute le titre\n",
    "plt.title(f\"Le champ de vecteurs.\")\n",
    "# et on affiche tout ça\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### La solution avec CI $y(0)=0$\n",
    "\n",
    "Nous avons vu en TD que la solution (appelée ici $s$) qui vérifie la condition initiale $y(0)=0$ est\n",
    "$$\n",
    "s : t\\mapsto \n",
    "\\begin{cases}\n",
    "    -t-1+e^t    & \\text{ si } t\\geq 0\\\\\n",
    "    -t+1-e^{-t} & \\text{ si } t\\leq 0\\\\\n",
    "\\end{cases}.\n",
    "$$\n",
    "\n",
    "On peut encoder cette fonction ainsi :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "s = lambda t: np.piecewise(t, [t < 0, t >= 0], [lambda t: -t + 1 - np.exp(-t), lambda t: -t - 1 + np.exp(t)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Pour dessiner le graphe de cette fonction on utilise la commande `plt.plot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -2, 2, -2, 2\n",
    "\n",
    "# taille de la figure\n",
    "plt.figure(figsize=(2 * (tmax - tmin), 2 * (ymax - ymin)))\n",
    "# on détermine la fenêtre d'affichage\n",
    "plt.axis([tmin, tmax, ymin, ymax])\n",
    "# on trace les axes en `yellow`\n",
    "plt.plot([tmin, tmax], [0, 0], \"y\")\n",
    "plt.plot([0, 0], [ymin, ymax], \"y\")\n",
    "\n",
    "# la solution que nous avons trouvée en TD pour (0,0)\n",
    "t = np.linspace(tmin, tmax, 100)\n",
    "plt.plot(t, s(t), \"r\")\n",
    "\n",
    "plt.title(f\"La solution avec y(0)=0.\")\n",
    "# et on affiche tout ça\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### La solution avec CI $y(0) = y_0$\n",
    "\n",
    "Nous n'avons pas décrit en TD la solution avec la condition initiale plus générale $y(0) = y_0$, même si c'est possible. Ici nous allons profiter de la fonction `odeint` pour tracer cette solution pour différentes valeurs de $y_0$. Commençons par le cas $y_{0}=1$. Dans ce cas particulier la solution est affine pour $t\\in[-1,0]$, et nous pouvons vérifier ceci visuellement en dessinant la droite de pente $1$ qui passe par $(-1,0)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -2, 2, -2, 2\n",
    "\n",
    "# choix de la condition initiale\n",
    "t_0 = 0\n",
    "y_0 = 1\n",
    "\n",
    "# taille de la figure\n",
    "plt.figure(figsize=(2 * (tmax - tmin), 2 * (ymax - ymin)))\n",
    "# on détermine la fenêtre d'affichage\n",
    "plt.axis([tmin, tmax, ymin, ymax])\n",
    "# on trace les axes en `yellow`\n",
    "plt.plot([tmin, tmax], [0, 0], \"y\")\n",
    "plt.plot([0, 0], [ymin, ymax], \"y\")\n",
    "\n",
    "# la droite de pente 1 qui passe par (-1,0) pour comparer avec la solution\n",
    "t = np.linspace(tmin, tmax, 2)\n",
    "plt.plot(t, t + 1, \"lightgray\")\n",
    "\n",
    "# La solution approchée, trouvée avec odeint\n",
    "# la partie de la courbe pour t dans [t_0,tmax] (le futur)\n",
    "futur = np.linspace(t_0, tmax, 50)\n",
    "v = odeint(f, y_0, futur)\n",
    "plt.plot(futur, v, \"b\")\n",
    "# la partie de la courbe pour t dans [tmin,t_0] (le passé)\n",
    "passe = np.linspace(t_0, tmin, 50)\n",
    "v = odeint(f, y_0, passe)\n",
    "plt.plot(passe, v, \"g--\")\n",
    "\n",
    "# le point de départ (la condition initiale)\n",
    "plt.plot(t_0, y_0, 'or')\n",
    "# le titre\n",
    "plt.title(f\"Solution avec y({t_0})={y_0}.\")\n",
    "# et on affiche tout ça\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Le graphique en version « statique »\n",
    "\n",
    "Nous somme prêt maintenant pour rassembler les différents éléments sur une même image. Pour cela nous allons créer une fonction `solution(t_0, y_0)` qui prend les paramètre $t_0$ et $y_0$ et qui dessine sur le même graphique :\n",
    "- le champ de vecteurs ;\n",
    "- la solution exacte $s$ qui vérifie $y(0)=0$ ;\n",
    "- la solution approchée obtenue avec `odeint` qui vérifie $y(t_0) = y_0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -2, 2, -2, 2\n",
    "\n",
    "# le dessin pour la condition initiale (t_0,y_0)\n",
    "def solution(t_0=0, y_0=0):\n",
    "    # taille de la figure\n",
    "    plt.figure(figsize=(2 * (tmax - tmin), 2 * (ymax - ymin)))\n",
    "    # on détermine la fenêtre d'affichage\n",
    "    plt.axis([tmin, tmax, ymin, ymax])\n",
    "    # on trace les axes en `yellow`\n",
    "    plt.plot([tmin, tmax], [0, 0], \"y\")\n",
    "    plt.plot([0, 0], [ymin, ymax], \"y\")\n",
    "\n",
    "    # on dessine le champ normalisé\n",
    "    champ_normalise(f, tmin, tmax, ymin, ymax, width=.002)\n",
    "\n",
    "    # la solution que nous avons trouvée en TD pour (0,0)\n",
    "    t = np.linspace(tmin, tmax, 100)\n",
    "    plt.plot(t, s(t), \"r\")\n",
    "\n",
    "    # La solution approchée, trouvée avec odeint\n",
    "    # la partie de la courbe pour t dans [t_0,tmax] (le futur)\n",
    "    futur = np.linspace(t_0, tmax, 50)\n",
    "    v = odeint(f, y_0, futur)\n",
    "    plt.plot(futur, v, \"b\")\n",
    "    # la partie de la courbe pour t dans [tmin,t_0] (le passé)\n",
    "    passe = np.linspace(t_0, tmin, 50)\n",
    "    v = odeint(f, y_0, passe)\n",
    "    plt.plot(passe, v, \"g--\")\n",
    "\n",
    "    # le point de départ (la condition initiale)\n",
    "    plt.plot(t_0, y_0, 'or')\n",
    "    # le titre\n",
    "    plt.title(f\"Solution avec y({t_0})={y_0}.\")\n",
    "    # et on affiche tout ça\n",
    "    plt.show()\n",
    "\n",
    "# vérifions que ça fonctionne\n",
    "solution(0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Le graphique en version « dynamique »\n",
    "\n",
    "Maintenant nous pouvons facilement rendre dynamique le graphique précédent en faisant varier $t_0$ et $y_0$ grâce au décorateur `@interact`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# choix de la condition initiale grâce à des curseurs\n",
    "@interact(t_0=(tmin, tmax, .5), y_0=(ymin, ymax, .5))\n",
    "# le dessin pour la condition initiale (t_0,y_0)\n",
    "def dyn_solution(t_0=0, y_0=0):\n",
    "    solution(t_0, y_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Exercice 4 (exemple)\n",
    "\n",
    "Notre équation étant\n",
    "$$\n",
    "    y'=|y|^{\\frac{2}{3}} \n",
    "$$\n",
    "la fonction $f$ à définir est $f(y,t) = |y|^{\\frac{2}{3}}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# la fonction f\n",
    "f = lambda y, t: np.cbrt(y**2)  # ici `np.cbrt` est la racine cubique\n",
    "\n",
    "# test\n",
    "assert f(0, 0) == 0, \"En y=0 la fonction doit valoir 0\"\n",
    "assert f(1, 0) == 1, \"En y=1 la fonction doit valoir 1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Les solutions\n",
    "\n",
    "Comme nous avons vu en TD cette équation ne vérifie pas la condition de Cauchy-Lipschitz. Nous avons vu qu'il y a une infinité de solutions qui vérifient $y(0)=0$, obtenues en recollant la fonction constante $y=0$ et une fonction\n",
    "$$\n",
    "    s_{t_0}(t) = \\left(\\frac{t-t_0}{3}\\right)^3\n",
    "$$\n",
    "vérifie aussi la condition initiale $s(t_0)=0$ pour $t_0 \\geq 0$.\n",
    "\n",
    "Pour définir cette fonction $s_{t_0}$ dépendant de paramètre $t_0$, en python nous allons définir une fonction `ss(t_0)` qui va retourner la fonction recherchée. Ainsi nous allons pouvoir faire `s = ss(1)`, par exemple, puis `s(1)` devrait valoir `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# ss(t_0) retourne la fonction non triviale qui vérifie s(t_0) = 0\n",
    "ss = lambda t_0: lambda t: ((t - t_0) / 3.)**3\n",
    "\n",
    "assert ss(1)(1) == 0, \"La fonction ss(1) doit s'annuler en 1 par construction.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Le graphique en version « dynamique »\n",
    "\n",
    "Pour cet exercice nous allons directement passer à la version dynamique du graphique qui regroupe :\n",
    "- le champ de vecteurs ;\n",
    "- la solution approchée qui vérifie $y(t_0) = y_0$ trouvée par `odeint` (quand $y_0 = 0$ il s'agit de la fonction constante $y=0$, et dans les autres cas c'est la fonction $s_{t_0}$ qui est approximée) ;\n",
    "- les « branches » manquant dus à la non-unicité de la solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -10, 10, -10, 10\n",
    "\n",
    "# discrétisation du temps (100 instants dans [tmin,tmax])\n",
    "t = np.linspace(tmin, tmax, 100)\n",
    "\n",
    "@interact(t_0=(tmin, tmax, .5), y_0=(ymin, ymax, .5))\n",
    "def dyn_solution(t_0=0, y_0=0):\n",
    "    # taille de la figure\n",
    "    plt.figure(figsize=(.5 * (tmax - tmin), .5 * (ymax - ymin)))\n",
    "    # on détermine la fenêtre d'affichage\n",
    "    plt.axis([tmin, tmax, ymin, ymax])\n",
    "    # on trace les axes (qui coïncident avec l'isocline infinie)\n",
    "    plt.plot([tmin, tmax], [0, 0], \"y\")\n",
    "    plt.plot([0, 0], [ymin, ymax], \"y\")\n",
    "\n",
    "    # on dessine le champ normalisé\n",
    "    champ_normalise(f, tmin, tmax, ymin, ymax, width=.002)\n",
    "\n",
    "    # La solution approchée, trouvée avec odeint\n",
    "    # la partie de la courbe pour t dans [t_0,tmax] (le futur)\n",
    "    futur = np.linspace(t_0, tmax, 50)\n",
    "    v = odeint(f, y_0, futur)\n",
    "    plt.plot(futur, v, \"b\")\n",
    "    # la partie de la courbe pour t dans [tmin,t_0] (le passé)\n",
    "    passe = np.linspace(t_0, tmin, 50)\n",
    "    v = odeint(f, y_0, passe)\n",
    "    plt.plot(passe, v, \"g--\")\n",
    "\n",
    "    # les solutions non trouvées par odeint\n",
    "    if y_0 == 0:\n",
    "        # (t/3)^3\n",
    "        s = ss(t_0)\n",
    "        plt.plot(t, s(t), \"r\")\n",
    "    elif y_0 != 0:\n",
    "        # la solution constante 0\n",
    "        plt.plot([tmin, tmax], [0, 0], \"r\")\n",
    "\n",
    "    # le point de départ (la condition initiale)\n",
    "    plt.plot(t_0, y_0, 'or')\n",
    "    # le titre\n",
    "    plt.title(f\"Des solutions avec y({t_0})={y_0}.\")\n",
    "    # et on affiche tout ça\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Exercice 5 (à faire)\n",
    "\n",
    "Dans cet exercice nous avons étudié l'équation non autonome\n",
    "$$\n",
    "    (1+t+t^2)y'+(2t+1)y = (1+t+t^2)^2. \n",
    "$$\n",
    "Ainsi la fonction $f$ à définir est $f(y,t) =-\\frac{1+2t}{1+t+t^2}y+(1+t+t^2)$.\n",
    "\n",
    "Définissez cette fonction `f(y,t)` qui doit passer les tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# la fonction f\n",
    "\n",
    "# test\n",
    "assert f(0, 0) == 1, \"f(0,0) = 1\"\n",
    "assert f(1, 1) == 2, \"f(1,1) = 2\"\n",
    "assert np.shape(f(np.ones(3), np.zeros(3))) == (3, ), \"la fonction doit accepter des vecteurs comme paramètres\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### La solution exacte avec $y(0)=c$\n",
    "\n",
    "Nous avons vu en TD que la solution qui vérifie $y(0)=c$ est\n",
    "$$\n",
    "s_c : t\\mapsto \\frac{c+t+t^2+t^3+t^4/2+t^5/5}{1+t+t^2}\n",
    "$$\n",
    "\n",
    "Définissez une fonction `ss(c)` qui retourne la fonction $s_c$. Cette fonction doit passer les tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# la fonction ss qui retourne une fonction.\n",
    "\n",
    "# si s = ss(1), alors s(0)=1 car s_c(0) = c\n",
    "assert ss(1)(0) == 1, \"s_c(0) = c\"\n",
    "assert np.shape(ss(1)(np.ones(3))) == (3, ), \"la fonction doit accepter des vecteurs comme paramètres\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### La représentation graphique\n",
    "\n",
    "Adapter les représentations graphiques (dynamique, avec paramètres `t_0` et `y_0`) des exercices 3 et 4 à cet exercice. Le graphique doit représenter, en plus de la solution exacte `ss(y_0)` qui vérifie $y(0)=y_0$, la solution trouvée par `odeint` qui vérifie la condition initiale $y(t_0)=y_0$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -10, 10, -5, 5\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "**Question :** Expliquer comment à partir de la représentation graphique du champ de vecteurs _(et non à partir de l'équation de départ)_ on voit qu'il ne s'agit pas d'une équation autonome."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## exercice 9 (à faire)\n",
    "\n",
    "L'équation autonome étudié dans cet exercice est\n",
    "$$\n",
    "    y'=\\sqrt{1+y^2}. \n",
    "$$\n",
    "Ainsi la fonction $f$ à définir est $f(y,t) =\\sqrt{1+y^2}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# la fonction f\n",
    "\n",
    "# test\n",
    "assert f(0, 0) == 1, \"f(0,*) = 1\"\n",
    "assert f(1, 1) == np.sqrt(2), \"f(1,*) = sqrt(2)\"\n",
    "assert np.shape(f(np.ones(3), np.zeros(3))) == (3, ), \"la fonction doit accepter des vecteurs comme paramètres\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### La solution en (0,1)\n",
    "\n",
    "Nous avons vu en TD que la solution qui vérifie la condition initiale $y(0)=1$ est\n",
    "$$\n",
    "    s : t\\mapsto \\sinh(t+\\operatorname{arcsinh}(1))\n",
    "$$\n",
    "\n",
    "Soit $s_c$ la solution qui vérifie $s_c(0) = c$. Définissez la fonction `ss(c)` qui retourne la solution qui vaut `c` en `0`. Cette fonction doit vérifier les tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# la fonction s qui vérifie s(0) = 1\n",
    "\n",
    "# si s=ss(c), alors s(0)=c\n",
    "s = ss(1)\n",
    "assert s(0) == 1, \"si s=ss(1), alors s(0) doit être 1\"\n",
    "assert (s(np.array([0, np.arcsinh(-1)])) == np.array([1, 0])).all(), \"s([0,arcsinh(-1)]) = [1,0]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### La représentation graphique\n",
    "\n",
    "Adapter les représentations graphiques des exercices 3 et 4 à cet exercice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "tmin, tmax, ymin, ymax = -10, 10, -5, 5\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "**Question :** Expliquer comment à partir de la représentation graphique du champ de vecteurs _(et non à partir de l'équation de départ)_ on voit qu'il s'agit d'une équation autonome."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}