M62_TP4_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 4 - Les équations différentielles autonomes de dimension 2 (suite)\n",
    "\n",
    "Dans ce quatrième TP nous allons étudier numériquement des équations autonomes du premier ordre de dimension 2.<br>\n",
    "Il s'agit d'exemples vus dans la fiche B 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": [
    "## Quelques fonctions utiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Le champ de vecteurs\n",
    "\n",
    "On reprend la fonction `champ_vectoriel` du TP3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# affiche le champ de vecteurs sur la figure courante\n",
    "# - F : représente la fonction de Y'=F(Y)\n",
    "# - xmin, Xmax, ymin, ymax : détermine la fenêtre d'affichage\n",
    "# - normalise : si `False` le champ n'est pas normalisé\n",
    "# - step : est le pas de discrétisations en chaque direction\n",
    "def champ_vectoriel(F, xmin, xmax, ymin, ymax, normalise=True, step=.5, **kw):\n",
    "    X = np.arange(xmin, xmax, step)  # abscisses des points de la grille\n",
    "    Y = np.arange(ymin, ymax, step)  # ordonnées des points de la grille\n",
    "    U, V = F(np.meshgrid(X, Y))  # les composantes du champ de vecteurs\n",
    "    if normalise:\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(X, Y, U, V, angles='xy', **kw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Les courbes de niveau\n",
    "\n",
    "On reprend la fonction `lignes_niveaux` du TP3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# la fonction qui trace les lignes de niveaux de h qui passe par les points xy\n",
    "# - h : une fonction de R^2 dans R\n",
    "# - xmin, xmax, ymin, ymax : le limites du tracé\n",
    "# - xy : une liste de points de la forme [[x1,x2,...],[y1,y2,...]] par lesquelles passent les niveaux\n",
    "# - N : le nombre de points de la discrétisation de x et de y\n",
    "# - fmt : le format de la valeur de la courbe de niveau\n",
    "# - alpha : le niveau de transparence entre 0 (transparent) et 1 (opaque)\n",
    "def lignes_niveaux(h, xmin, xmax, ymin, ymax, xy, N=100, fmt='%.1f', alpha=.5):\n",
    "    C = np.unique(h(np.array(xy)))  # les valeurs de h aux points xy dans l'ordre croissant\n",
    "    x = np.linspace(xmin, xmax, N)\n",
    "    y = np.linspace(ymin, ymax, N)\n",
    "    z = h(np.meshgrid(x, y))  # les valeurs de h aux points (x,y)\n",
    "    lignes_niveau = plt.contour(x, y, z, levels=C, alpha=alpha)  # les courbes de niveaux\n",
    "    plt.clabel(lignes_niveau, C, fmt=fmt)  # on ajuste le format des étiquettes des courbes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Ajustements de F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "#### Rajout du paramètre temps\n",
    "\n",
    "On reprend la fonction `avec_t` du TP3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "avec_t = lambda F: lambda Y, t: F(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Ralentir le temps en dehors de la fenêtre d'affichage\n",
    "\n",
    "On reprend la fonction `ralentir` du TP3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# C'est une fonction C^1 qui :\n",
    "#  - est égale à 1 dans le disque de rayon r\n",
    "#  - décroit exponentiellement en dehors de ce disque\n",
    "def cutoff(Y, r):\n",
    "    nY = np.maximum(Y[0] * Y[0] + Y[1] * Y[1] - r * r, 0)\n",
    "    return np.exp(-nY)\n",
    "\n",
    "# la fonction qui « ralentie » F en dehors de la fenêtre [xmin, xmax, ymin, ymax]\n",
    "def ralentir(F, xmin, xmax, ymin, ymax):\n",
    "    r = max(abs(xmax), abs(xmin), abs(ymax), abs(ymin)) * np.sqrt(2)  # le rayon d'un disque qui contient la fenêtre\n",
    "    return lambda Y: F(Y) * cutoff(Y, r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Exercice 5 (à faire)\n",
    "\n",
    "### 1) La fonction de Cauchy\n",
    "\n",
    "La fonction du problème de Cauchy autonome étudié dans cet exercice est :\n",
    "$$\n",
    "    F(Y) = (-y+xy, x+\\frac{1}{2}(x^2-y^2)) \\text{ pour } Y=(x,y).\n",
    "$$\n",
    "\n",
    "Définissez cette fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# La définition de F\n",
    "\n",
    "# test\n",
    "Y = np.array([[0, 1], [0, 1]])  # les arguments (0,0) et (1,1)\n",
    "R = np.array([[0, 0], [0, 1]])  # le résultat attendu\n",
    "assert np.all(F(Y) == R), \"F(0,0) = (0,0) and F(1,1) = (0,1)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### 2) La rotation $\\pm 120°$\n",
    "\n",
    "Nous avons vu en TD que ce problème est invariant par la rotation à 120°. Pour pouvoir vérifier cette affirmation nous allons d'abord définir l'application `R120` qui applique la rotation à 120° qui opère sur des vecteurs `Y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# La définition de la rotation R120 qui prend un 2-vecteur comme paramètre\n",
    "\n",
    "# Ce n'est pas une façon optimale de définir la rotation à -120° = +240°.\n",
    "# Donc vous pouvez faire mieux, si vous voulez.\n",
    "R240 = lambda Y: R120(R120(Y))\n",
    "\n",
    "# test\n",
    "Y = np.array([[0, 1], [0, 0]])  # R120([1,0]) = [-1/2, sqrt(3)/2]\n",
    "assert f\"{R120(Y)[1,1]:.10f}\" == \"0.8660254038\", f\"{R120(Y)[1,1]:.10f} = 0.8660254038 ?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### 3) Le graphique « dynamique » avec les solutions approchées\n",
    "\n",
    "Inspirer vous des exemples traités pour afficher un graphique dynamique qui :\n",
    "- permet de choisir la condition initiale `x_0, y_0` entre -4 et 4 ;\n",
    "- affiche les isoclines $I_\\infty$, $I_{\\pm\\frac{1}{\\sqrt{3}}}$;\n",
    "- affiche le champ de vecteurs normalisé\n",
    "- contient la solution approchée obtenue avec `odeint`\n",
    "- superpose la solution obtenue par rotation de 120° (dont la condition initiale est choisi de façon appropriée).\n",
    "\n",
    "Le but de ce graphique est de faire la « preuve » visuelle de l'invariance par rotation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# choix de la fenêtre\n",
    "xmin, xmax, ymin, ymax = -4, 4, -4, 4\n",
    "\n",
    "# choix de la condition initiale grâce à des curseurs\n",
    "@interact(x_0=(xmin, xmax, .2), y_0=(ymin, ymax, .2))\n",
    "# le dessin avec la solution pour la condition initiale (x_0,y_0)\n",
    "def dyn_solution(x_0=1, y_0=np.sqrt(3)):\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### 4) Observations\n",
    "\n",
    "1. Combien de points fixes observez-vous ?\n",
    "1. Avez-vous pu identifier numériquement les coordonnées de ces points fixes ?\n",
    "1. Combien d'orbites sont contenus dans l'isocline $I_\\infty$ d'après les observations ? (décrivez votre expérience)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "**Solution :**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Exercice 6 (à faire)\n",
    "\n",
    "La fonction dans cet exercice dépend du paramètre $\\varepsilon$ :\n",
    "$$ \n",
    "    F_\\varepsilon(Y) = (y, -x+\\varepsilon(x^2-1)y) \\text{ pour } Y=(x,y).\n",
    "$$\n",
    "\n",
    "Vous avez carte blanche pour réaliser l'étude de cet EDO. Inspirez-vous des questions posées dans la feuille de TD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "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
}