{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Python version 3.8.5 (default, Jul 28 2020, 12:59:40) \n", "[GCC 9.3.0]\n" ] } ], "source": [ "import sys #only needed to determine Python version number\n", "print('Python version ' + sys.version)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# M62 TP 4 - Étude de la convergence" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "IPython.notebook.set_autosave_interval(300000)" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Autosaving every 300 seconds\n" ] } ], "source": [ "%reset -f\n", "%matplotlib inline\n", "%autosave 300\n", "\n", "from matplotlib.pylab import *\n", "from scipy.optimize import fsolve" ] }, { "cell_type": "markdown", "metadata": { "toc": true }, "source": [ "

Table of Contents

\n", "
" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "WyG-bTRQE3f6" }, "source": [ "# Étude de la convergence\n", "\n", "Considérons le problème de Cauchy\n", "\n", ">trouver la fonction $y \\colon I\\subset \\mathbb{R} \\to \\mathbb{R}$ définie sur l'intervalle $I=[0,1]$ telle que\n", "$$\n", "\\begin{cases}\n", "y'(t) = y(t), &\\forall t \\in I=[0,1],\\\\\n", "y(0) = 1\n", "\\end{cases}\n", "$$\n", "dont la solution est $y(t)=e^{t}$. \n", "\n", "On se propose d'estimer l'ordre de convergence d'une méthode numérique.\n", "+ Pour chaque schéma, on calcule la solution approchée avec différentes valeurs de $h_k=1/N_k$. On sauvegarde les valeurs de $h_k$ dans le vecteur `H`. \n", "+ Pour chaque valeur de $h_k$, on calcule le maximum de la valeur absolue de l'erreur et on sauvegarde toutes ces erreurs dans le vecteur `err_schema` de sort que `err_schema[k]` contient $e_k=\\max_{i=0,\\dots,N_k}|y(t_i)-u_{i}|$. \n", "+ Pour afficher l'ordre de convergence on utilise une échelle logarithmique, i.e. on représente $\\ln(h)$ sur l'axe des abscisses et $\\ln(\\text{err})$ sur l'axe des ordonnées. \n", " En effet, si $\\text{err}=Ch^p$ alors $\\ln(\\text{err})=\\ln(C)+p\\ln(h)$. \n", " En échelle logarithmique, $p$ représente donc la pente de la ligne droite $\\ln(\\text{err})$.\n", "\n", "Remarque: puisque la fonction $\\varphi(t,y)=y$ est linéaire, toute méthode implicite peut être rendue explicite par un calcul élémentaire en explicitant directement pour chaque schéma l'expression de $u_{n+1}$. Cependant, nous pouvons utiliser le le module `SciPy` sans modifier l'implémentation des schémas (mais on payera l'ordre de convergence de `fsolve`).\n", "\n", "Estimer l'ordre de convergence des méthodes:\n", "1. EE, AB$_2$, AB$_3$, AB$_4$, AB$_5$, N$_2$, N$_3$, N$_4$\n", "2. EI, CN, AM$_1$, AM$_2$, AM$_3$, AM$_4$, BDF$_2$, BDF$_3$\n", "3. EM, Heun, RK4-1, RK4-2\n", "4. AM$_4$-AB$_1$, AM$_4$-AB$_2$, AM$_4$-AB$_3$\n", " \n", "\n", "**Attention: les schémas multistep ont besoin d'initialiser plusieurs pas de la suite définie pas récurrence pour pouvoir démarrer. \n", "Dans cette étude, au lieu d'utiliser un schéma d'ordre inférieur pour initialiser la suite, on utilisera la solution exacte (en effet, l'utilisation d'un schéma d'ordre inférieur dégrade l'ordre de précision).**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On écrit les schémas numériques :\n", "+ les nœuds d'intégration $[t_0,t_1,\\dots,t_{N}]$ sont contenus dans le vecteur `tt` (qui change en fonction de `h`) \n", "+ les valeurs $[u_0,u_1,\\dots,u_{N}]$ pour chaque méthode sont contenues dans le vecteur `uu`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Schémas explicites" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "y69SGZjfIDo9" }, "source": [ "### Schéma de Adam-Bashforth à 1 pas = schéma d'Euler progressif\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{n+1}=u_n+h\\varphi(t_n,u_n)& n=0,1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "_Bgo6mNyIQgu" }, "outputs": [], "source": [ "def EE(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " for i in range(N):\n", " uu.append(uu[i]+h*phi(tt[i],uu[i]))\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "bJ2pbhejIQM2" }, "source": [ "### Schéma de Adam-Bashforth à 2 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{n+1}=u_n+\\frac{h}{2}\\Bigl(3\\varphi(t_n,u_n)-\\varphi(t_{n-1},u_{n-1})\\Bigr)& n=1,2,3,4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "g38fKrIgSiBQ" }, "outputs": [], "source": [ "def AB2(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " uu.append(sol_exacte(tt[1]))\n", " for i in range(1,N):\n", " k1 = phi( tt[i], uu[i] )\n", " k2 = phi( tt[i-1], uu[i-1] )\n", " uu.append( uu[i] + (3*k1-k2)*h/2 )\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "nI8swyc6RxIR" }, "source": [ "### Schéma de Adam-Bashforth à 3 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{n+1}=u_n+\\frac{h}{12}\\Bigl(23\\varphi(t_n,u_n)-16\\varphi(t_{n-1},u_{n-1})+5\\varphi(t_{n-2},u_{n-2})\\Bigr)& n=2,3,4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "awcWzBp7SXvQ" }, "source": [ "### Schéma de Adam-Bashforth à 4 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{3}=y_3,\\\\\n", "u_{n+1}=u_n+\\frac{h}{24}\\Bigl(55\\varphi(t_n,u_n)-59\\varphi(t_{n-1},u_{n-1})+37\\varphi(t_{n-2},u_{n-2})-9\\varphi(t_{n-3},u_{n-3})\\Bigr)& n=3,4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "heLmvMe_S0y6" }, "source": [ "### Schéma de Adam-Bashforth à 5 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{3}=y_3,\\\\\n", "u_{4}=y_4,\\\\\n", "u_{n+1}=u_n+\\frac{h}{720}\\Bigl(1901\\varphi(t_n,u_n)-2774\\varphi(t_{n-1},u_{n-1})+2616\\varphi(t_{n-2},u_{n-2})-1274\\varphi(t_{n-3},u_{n-3})+251\\varphi(t_{n-4},u_{n-4})\\Bigr)& n=4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "OldEmxFfTJfq" }, "source": [ "### Schéma de Nylström à 2 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{n+1}=u_{n-1}+2h\\varphi(t_{n},u_{n})& n=1,2,3,4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "dADQEhyYTVQz" }, "source": [ "### Schéma de Nylström à 3 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{n+1}=u_{n-1}+\\frac{h}{3}\\Bigl(7\\varphi(t_{n},u_{n})-2\\varphi(t_{n-1},u_{n-1})+\\varphi(t_{n-2},u_{n-2})\\Bigr)& n=2,3,4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "LsgdqQnfTf66" }, "source": [ "### Schéma de Nylström à 4 pas\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{1}=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{3}=y_3,\\\\\n", "u_{n+1}=u_{n-1}+\\frac{h}{3}\\Bigl(8\\varphi(t_{n},u_{n})-5\\varphi(t_{n-1},u_{n-1})+4\\varphi(t_{n-2},u_{n-2})-\\varphi(t_{n-3},u_{n-3})\\Bigr)& n=3,4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "_50Xo95mT9tC" }, "source": [ "### Schéma de Runge-Kutta RK4-1\n", "$$\\begin{cases}\n", "u_0=y(t_0)=y_0,\\\\\n", "\\tilde u_{n+1/2}=u_n+\\frac{h}{2} \\varphi(t_{n},u_{n}),\\\\\n", "\\check u_{n+1/2}=u_n+\\frac{h}{2} \\varphi(t_{n}+\\frac{h}{2},\\tilde u_{n+1/2}),\\\\\n", "\\hat u_{n+1}=u_n+h\\varphi(t_{n+1},\\check u_{n+1/2}),\\\\\n", "u_{n+1}=u_n+\\frac{h}{6}\\left(\\varphi(t_{n},u_{n})+2\\varphi(t_{n}+\\frac{h}{2},\\tilde u_{n+1/2} )+2\\varphi(t_{n}+\\frac{h}{2}, \\check u_{n+1/2})+\\varphi(t_{n+1},\\hat u_{n+1} \\right)& n=0,1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Schémas implicites" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "y69SGZjfIDo9" }, "source": [ "### Schéma d'Euler régressif\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{n+1}=u_n+h\\varphi(t_{n+1},u_{n+1})& n=0,1,2,\\dots N-1\n", "\\end{cases}\n", "$$\n", "avec $u_{n+1}$ zéro de la fonction $$x\\mapsto -x+u_n+h\\varphi(t_{n+1},x).$$" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "_Bgo6mNyIQgu" }, "outputs": [], "source": [ "def EI(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " for i in range(N):\n", " temp = fsolve(lambda x: -x+uu[i]+h*phi(tt[i+1],x), uu[i])\n", " uu.append(temp)\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma de Crank-Nicolson\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_{n+1}=u_n+\\frac{h}{2}\\Bigl(\\varphi(t_n,u_n)+\\varphi(t_{n+1},u_{n+1})\\Bigr)& n=0,1,2,\\dots N-1\n", "\\end{cases}\n", "$$\n", "avec $u_{n+1}$ un zéro de la fonction $x\\mapsto -x+u_n+\\frac{h}{2}(\\varphi(t_n,u_n)+\\varphi(t_{n+1},x))$." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def CN(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " for i in range(len(tt)-1):\n", " temp = fsolve(lambda x: -x+uu[i]+0.5*h*( phi(tt[i+1],x)+phi(tt[i],uu[i]) ), uu[i])\n", " uu.append(temp)\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma de AM-2\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_{n+1}=u_n+\\frac{h}{12}\\Bigl(5\\varphi(t_{n+1},u_{n+1})+8\\varphi(t_n,u_n)-\\varphi(t_{n-1},u_{n-1})\\Bigr)& n=1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def AM2(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " uu.append(sol_exacte(tt[1]))\n", " for i in range(1,N):\n", " temp = fsolve(lambda x: -x+uu[i]+h*( 5*phi(tt[i+1],x)+8*phi(tt[i],uu[i])-phi(tt[i-1],uu[i-1]) )/12, uu[i])\n", " uu.append(temp)\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma de AM-3\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{n+1}=u_n+\\frac{h}{24}\\Bigl(9\\varphi(t_{n+1},u_{n+1})+19\\varphi(t_n,u_n)-5\\varphi(t_{n-1},u_{n-1})+\\varphi(t_{n-2},u_{n-2})\\Bigr)& n=2,3,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma de AM-4\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{3}=y_3,\\\\\n", "u_{n+1}=u_n+\\frac{h}{720}\\Bigl(251\\varphi(t_{n+1},u_{n+1})+646\\varphi(t_n,u_n)-264\\varphi(t_{n-1},u_{n-1})+106\\varphi(t_{n-2},u_{n-2})-19\\varphi(t_{n-3},u_{n-3})\\Bigr)& n=3,4,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma de AM-5\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{3}=y_3,\\\\\n", "u_{4}=y_4,\\\\\n", "u_{n+1}=u_n+\\frac{h}{1440}\\Bigl(475\\varphi(t_{n+1},u_{+1})+1427\\varphi(t_n,u_n)-798\\varphi(t_{n-1},u_{n-1})+482\\varphi(t_{n-2},u_{n-2})-173\\varphi(t_{n-3},u_{n-3})+27\\varphi(t_{n-4},u_{n-4})\\Bigr),& n=4,5,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma BDF2\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_{n+1}=\\frac{4}{3}u_n-\\frac{1}{3}u_{n-1}+\\frac{2}{3}h\\varphi(t_{n+1},u_{n+1})& n=1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma BDF3\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_{2}=y_2,\\\\\n", "u_{n+1}=\\frac{18}{11}u_n-\\frac{9}{11}u_{n-1}+\\frac{2}{11}u_{n-2}+\\frac{6}{11}h\\varphi(t_{n+1},u_{n+1})& n=2,3,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Schémas predicteur-correcteur" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "p4f0txAsIwNG" }, "source": [ "### Schéma d'Euler modifié\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "\\tilde u = u_n+\\frac{h}{2}\\varphi(t_n,u_n),\\\\\n", "u_{n+1}=u_n+h\\varphi\\left(t_n+\\frac{h}{2},\\tilde u\\right)& n=0,1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "O5rOYvtPI7TO" }, "outputs": [], "source": [ "def EM(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " for i in range(N):\n", " k1 = phi( tt[i], uu[i] )\n", " uu.append( uu[i]+h*phi(tt[i]+h/2,uu[i]+k1*h/2) )\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma de Heun\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "\\tilde u = u_n+h\\varphi(t_n,u_n)\\\\\n", "u_{n+1}=u_n+\\frac{h}{2}\\Bigl(\\varphi(t_n,u_n)+\\varphi(t_{n+1},\\tilde u)\\Bigr)& n=0,1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "1ewZyxhHRYxg" }, "outputs": [], "source": [ "def heun(phi,tt,y0):\n", " h = tt[1]-tt[0]\n", " uu = [y0]\n", " for i in range(N):\n", " k1 = phi( tt[i], uu[i] )\n", " k2 = phi( tt[i+1], uu[i] + k1*h )\n", " uu.append( uu[i] + (k1+k2)*h/2 )\n", " return uu" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma AM-2 AB-1\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "\\tilde u=u_n+h\\varphi(t_n,u_n),\\\\\n", "u_{n+1}=u_n+\\frac{h}{12}\\Bigl(5\\varphi(t_{n+1},\\tilde u)+8\\varphi(t_n,u_n)-\\varphi(t_{n-1},u_{n-1})\\Bigr)& n=1,2,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "23PyYGzhQwuo" }, "source": [ "### Schéma AM-3 AB-2\n", "$$\n", "\\begin{cases}\n", "u_0=y_0,\\\\\n", "u_1=y_1,\\\\\n", "u_2=y_2,\\\\\n", "\\tilde u=u_n+\\frac{h}{2}(3\\varphi(t_n,u_n)-\\varphi(t_{n-1},u_{n-1})),\\\\\n", "u_{n+1}=u_n+\\frac{h}{24}\\Bigl(9\\varphi(t_{n+1},\\tilde u)+19\\varphi(t_n,u_n)-5\\varphi(t_{n-1},u_{n-1})+\\varphi(t_{n-2},u_{n-2})\\Bigr)& n=2,3,\\dots N-1\n", "\\end{cases}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Convergence" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "cnwNf75iGe0F" }, "source": [ "On initialise le problème de Cauchy" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "OLLu4aFJFENg" }, "outputs": [], "source": [ "t0, y0, tfinal = 0, 1, 3" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ve4iOfOIGsYc" }, "source": [ "On définit la solution exacte:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "W3EcAN2eGz2j" }, "outputs": [], "source": [ "def sol_exacte(t):\n", "\treturn exp(t)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "xpjn_ogYGo20" }, "source": [ "On définit l'équation différentielle : `phi` est une fonction python qui contient la fonction mathématique $\\varphi(t, y)$ dépendant des variables $t$ et $y$." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "df9F-MXWGm2a" }, "outputs": [], "source": [ "def phi(t,y):\n", "\treturn y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour chaque schéma, on calcule la solution approchée avec différentes valeurs de $h_k=1/N_k$, à savoir $N_k=2$, $2^2$, $2^3$, ... $2^{10}$). On sauvegarde les valeurs de $h_k$ dans le vecteur `H`. \n", "\n", "Pour chaque valeur de $h_k$, on calcule le maximum de la valeur absolue de l'erreur et on sauvegarde toutes ces erreurs dans le vecteur `err_schema` de sort que `err_schema[k]` contient $e_k=\\max_{i=0,...,N_k}|y(t_i)-u_{i}|$ avec $N_k=2^{k+1}$." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "H = []\n", "\n", "err_ep = []\n", "err_AB2 = []\n", "\n", "err_er = []\n", "err_CN = []\n", "\n", "err_em = []\n", "err_heun = []\n", "\n", "for k in range(8):\n", "\tN = 2**(k+3)\n", "\th = (tfinal-t0)/N\n", "\tH.append(h)\n", "\ttt = [t0+i*h for i in range(N+1)]\n", "\tyy = [sol_exacte(t) for t in tt]\n", "\t# schemas explicites\n", "\tuu_ep = EE(phi,tt,y0)\n", "\tuu_AB2 = AB2(phi,tt,y0)\n", "\t# schemas implicites\n", "\tuu_er = EI(phi,tt,y0)\n", "\tuu_CN = CN(phi,tt,y0)\n", "\t# schemas predictor-corrector\n", "\tuu_em = EM(phi,tt,y0)\n", "\tuu_heun = heun(phi,tt,y0)\n", "\t# erreurs\n", "\terr_ep.append(max([abs(uu_ep[i]-yy[i]) for i in range(N+1)]))\n", "\terr_AB2.append(max([abs(uu_AB2[i]-yy[i]) for i in range(N+1)]))\n", "\t\n", "\terr_er.append(max([abs(uu_er[i]-yy[i]) for i in range(N+1)]))\n", "\terr_CN.append(max([abs(uu_CN[i]-yy[i]) for i in range(N+1)]))\n", "\t\n", "\terr_em.append(max([abs(uu_em[i]-yy[i]) for i in range(N+1)]))\n", "\terr_heun.append(max([abs(uu_heun[i]-yy[i]) for i in range(N+1)]))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "SnKKU27oGyQb" }, "source": [ "Pour estimer l'ordre de convergence on estime la pente de la droite qui relie l'erreur au pas $k$ à l'erreur au pas $k+1$ en echelle logarithmique en utilisant la fonction `polyfit` basée sur la régression linéaire. \t" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 }, "base_uri": "https://localhost:8080/", "height": 3818, "output_extras": [ { "item_id": 1 }, { "item_id": 2 }, { "item_id": 3 }, { "item_id": 4 }, { "item_id": 5 }, { "item_id": 6 }, { "item_id": 7 }, { "item_id": 8 }, { "item_id": 9 }, { "item_id": 10 }, { "item_id": 11 } ] }, "colab_type": "code", "executionInfo": { "elapsed": 2188, "status": "ok", "timestamp": 1520423878951, "user": { "displayName": "Gloria Faccanoni", "photoUrl": "//lh4.googleusercontent.com/-gY6sCpFtBJo/AAAAAAAAAAI/AAAAAAAABdo/a_W4-RMG5X0/s50-c-k-no/photo.jpg", "userId": "116371262733782746288" }, "user_tz": -60 }, "id": "oz1tVYNtG4-3", "outputId": "9b89f5ec-83c5-4797-e057-8d6c20560051" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "figure(1,figsize=(20,5))\n", "\n", "subplot(1,3,1)\n", "loglog(H,err_ep, 'r-o',label='AB-1=EE')\n", "loglog(H,err_AB2, 'g-+',label='AB-2')\n", "xlabel('$h$')\n", "ylabel('$e$')\n", "title(\"Schemas explicites\")\n", "legend() \n", "grid(True)\n", "\n", "subplot(1,3,2)\n", "loglog(H,err_er, 'r-o',label='AM-0=EI')\n", "loglog(H,err_CN, 'b-v',label='AM-1=CN')\n", "xlabel('$h$')\n", "ylabel('$e$')\n", "title(\"Schemas implicites\")\n", "legend() \n", "grid(True)\n", "\n", "subplot(1,3,3)\n", "loglog(H,err_em, 'c-o',label='EM')\n", "loglog(H,err_heun, 'y->',label='Heun')\n", "xlabel('$h$')\n", "ylabel('$e$')\n", "title(\"Schemas predicteur-correcteur\")\n", "legend() \n", "grid(True)\n", "\n", "show()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "4HPS2hE6G54k" }, "source": [ "Pour afficher l'ordre de convergence on utilise une échelle logarithmique : on représente $\\ln(h)$ sur l'axe des abscisses et $\\ln(\\text{err})$ sur l'axe des ordonnées. Le but de cette représentation est clair: si $\\text{err}=Ch^p$ alors $\\ln(\\text{err})=\\ln(C)+p\\ln(h)$. En échelle logarithmique, $p$ représente donc la pente de la ligne droite $\\ln(\\text{err})$." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "autoexec": { "startup": false, "wait_interval": 0 } }, "colab_type": "code", "id": "ySox-VsNGt8p" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EE\t 0.92\n", "AB2\t 1.92\n", "\n", "\n", "EI\t 1.12\n", "CN\t 2.01\n", "\n", "\n", "EM\t 1.95\n", "Heun\t 1.95\n" ] } ], "source": [ "print ('EE\\t %1.2f' %(polyfit(log(H),log(err_ep), 1)[0]))\n", "print ('AB2\\t %1.2f' %(polyfit(log(H),log(err_AB2), 1)[0]))\n", "print('\\n')\n", "print ('EI\\t %1.2f' %(polyfit(log(H),log(err_er), 1)[0]))\n", "print ('CN\\t %1.2f' %(polyfit(log(H),log(err_CN), 1)[0]))\n", "print('\\n')\n", "print ('EM\\t %1.2f' %(polyfit(log(H),log(err_em), 1)[0]))\n", "print ('Heun\\t %1.2f' %(polyfit(log(H),log(err_heun), 1)[0]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "colab": { "collapsed_sections": [], "default_view": {}, "name": "EdoExplicites.ipynb", "provenance": [], "version": "0.3.2", "views": {} }, "kernelspec": { "display_name": "Python 3", "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.8.5" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": true, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": true, "user_envs_cfg": true }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": true, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": true, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }