Résolution numérique d’équations différentielles : Différence entre versions

Version actuelle datée du 16 août 2019 à 02:58

Sommaire

1 Équations différentielle scalaires d’ordre 1
2 Méthode d'Euler
- 2.1 Exemple : chute libre
  - 2.1.1 Programmation python
  - 2.1.2 Résultats/précision
3 Méthode de Rounge-Kutta
- 3.1 Exemple : chute libre
  - 3.1.1 Programmation python
  - 3.1.2 Résultats/précision
4 Autres pages de la catégorie "Informatique"

Équations différentielle scalaires d’ordre 1

On étudie ici des équations diﬀérentielles d’ordre 1 qui s’écrivent sous la forme :

$x'=f(x,t)$

où $f$ est une fonction de deux variables et où l’on cherche la fonction x de la variable $t$ déﬁnie et dérivable sur un intervalle $I$ de $\mathbb {R}$ vérifiant : $\left\lbrace {\begin{array}{l}\forall t\in I,(x(t),t)\in I\\\forall t\in I,x'(t)=f(x(t),t)\\\end{array}}\right.$

Afin d'obtenir une solution unique, nous allons adjoindre à cette équation diﬀérentielle une condition initiale sous la forme d’un couple $(x0,t0)\in I$ et chercher à résoudre le problème de Cauchy suivant : $\left\lbrace {\begin{array}{l}x'=f(x,t)\\x(t_{0})=x_{0}\\\end{array}}\right.$

Sous certaines conditions sur f que nous ne détaillerons pas, ce problème admet une unique solution, que nous allons chercher à déterminer numériquement.

Méthode d'Euler

La méthode d'Euler repose sur l'utilisation de l'approximation affine de la fonction $f$ . La dérivée $x'(t)={\frac {dx(t)}{dt}}$ est approximée par ${\frac {x_{n+1}-x_{n}}{t_{n+1}-t_{n}}}={\frac {x_{n+1}-x_{n}}{h}}$ où $h$ est le pas de calcul (suffisamment petit).

On peut donc écrire la relation de récurrence : $hx'(t_{n})=x_{n+1}-x_{n}\Rightarrow x_{n+1}=x_{n}+hx'(t_{n})\Rightarrow x_{n+1}=x_{n}+h.f(x_{n},t_{n})$ .

L’algorithme de résolution utilisera donc les deux relations de récurrence suivantes : $\left\lbrace {\begin{array}{l}t_{n+1}=t_{n}+h\\x_{n+1}=x_{n}+hf(x_{n},t_{n})\\\end{array}}\right.$

que l'on peut illustrer par la représentation graphique suivante. La pente du segment entre les points $(t_{n},x_{n})$ et $(t_{n+1},x_{n+1})$ est évaluée par la pente de la fonction réelle à gauche, cad $f(x_{n},t_{n})$ .

Exemple : chute libre

Considérons un objet de masse $M$ en chute libre verticale avec frottement fluide de coefficient $\lambda$ .

Sa trajectoire est repérée dans un référentiel galiléen avec l'axe ${\vec {z}}$ vers le bas.

Sa vitesse $v$ projetée sur l'axe ${\vec {z}}$ respecte l'équation de la dynamique suivante:

$M\mathrm {.} v{\text{'}}\left(t\right){=}M\mathrm {.} g-\mathrm {\lambda } v\left(t\right)$ (1)

Avec la condition initiale :

$v(0)=0$ (2)

L'équation (1) devient : $v{\text{'}}\left(t\right)=g-{\frac {\mathrm {\lambda } }{M}}v\left(t\right)$

Remarque : La solution exacte à ce problème est trivialement connue : $v\left(t\right)={\frac {m\mathrm {.} g}{\mathrm {\lambda } }}\left(1-{e}^{{\frac {-\mathrm {\lambda } }{m}}t}\right)$

Pour la solution approchée, on obtient l’algorithme suivant :

$\left\lbrace {\begin{array}{l}{t}_{n+1}={t}_{n}+h\\{v}_{n+1}={v}_{n}+h(g-{\frac {\lambda }{M}}{v}_{n})\\\end{array}}\right.$

Programmation python

On placera les valeurs ${t}_{n}$ dans un tableau nommé t

De même on placera les valeurs ${v}_{n}$ dans un tableau nommé v_euler

La boucle de calcul des approximations successives s'écrit :

1 for n in range (0, Nb_iterations):
2     t.append(t[n]+h)     # ajout d'une valeur dans le tableau recevant les valeurs de temps
3     v.append(v_euler[n]+h*(g-v_euler[n]*_lambda/m))    # ajout d'une valeur dans le tableau recevant les vitesses

Résultats/précision

En exécutant cet algorithme et en faisant varier le nombre de points de calcul, on obtient les résultats suivants. La solution exacte est tracée en vert. Les tracés noirs sont les solutions approchées pour 5, 10, 20 et 50 points de calculs sur le même intervalle de temps :

On peut calculer les erreurs maximums de chaque approximation par rapport à la solution exacte :

Nb de points	Erreur maximum
5	100.4 %
10	45.2 %
20	21.3 %
50	8.21 %
100	4.05 %
400	1.01 %

Remarque : Pour ce problème, l'erreur maximum est inférieure à 1% pour un nombre de points de calculs supérieurs à 400.

Méthode de Rounge-Kutta

La méthode de Rounge-Kutta consiste à évaluer la pente du segment entre $(t_{n},x_{n})$ et $(t_{n+1},x_{n+1})$ , non pas à gauche mais au milieu du pas de calcul, ce qui est une meilleure approximation de la pente du segment : $x_{n+1}=x_{n}+h.f(x(t_{n}+h/2),t_{n}+h/2)$

Le terme $x(t_{n}+h/2)$ obtenu par l'approximation : $x_{n}+h/2.f(x_{n},t_{n})$ L’algorithme de résolution utilisera donc les deux relations de récurrence suivantes : $\left\lbrace {\begin{array}{l}t_{n+1}=t_{n}+h\\x_{n+1}=x_{n}+h.f(x_{n}+h/2.f(x_{n},t_{n}),t_{n}+h/2)\\\end{array}}\right.$

que l'on peut illustrer par la représentation graphique suivante. La pente du segment entre les points $(t_{n},x_{n})$ et $(t_{n+1},x_{n+1})$ est évaluée par la pente de la fonction réelle au milieu du pas de calcul.