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

De WikiMéca
Sauter à la navigation Sauter à la recherche
(Programmation python)
(Exemple : chute libre)
(6 révisions intermédiaires par le même utilisateur non affichées)
Ligne 13 : Ligne 13 :
  
  
===Principe de la méthode d'Euler===
+
===Méthode d'Euler===
  
 
La méthode d'Euler repose sur l'utilisation de l'approximation affine de la fonction.
 
La méthode d'Euler repose sur l'utilisation de l'approximation affine de la fonction.
Ligne 21 : Ligne 21 :
  
 
L’algorithme de résolution utilisera donc les deux relations de récurrence suivantes :  
 
L’algorithme de résolution utilisera donc les deux relations de récurrence suivantes :  
{{Systeme|t_{n+1} {{=}} t_n+h|x_{n+1} {{=}} x_n+h f(x_n,y_n) }}
+
{{Systeme|t_{n+1} {{=}} t_n+h|x_{n+1} {{=}} x_n+h f(x_n,t_n) }}
  
 
===Exemple : chute libre===
 
===Exemple : chute libre===
Ligne 37 : Ligne 37 :
 
Avec la condition initiale :
 
Avec la condition initiale :
  
<math>v(0)=v_0</math>  (2)
+
<math>v(0)=0</math>  (2)
  
 
L'équation (1) devient :
 
L'équation (1) devient :
Ligne 60 : Ligne 60 :
 
for n in range (0, Nb_iterations):
 
for n in range (0, Nb_iterations):
 
     t.append(t[n]+h)    # ajout d'une valeur dans le tableau recevant les valeurs de temps
 
     t.append(t[n]+h)    # ajout d'une valeur dans le tableau recevant les valeurs de temps
     v.append(v_euler[n]+h*(-g-v_euler[n]*lambda/m))    # ajout d'une valeur dans le tableau recevant les vitesses
+
     v.append(v_euler[n]+h*(g-v_euler[n]*lambda/m))    # ajout d'une valeur dans le tableau recevant les vitesses
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 +
====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 :
 +
 +
[[Fichier:Euler chute libre.svg]]
 +
 +
On peut calculer les erreurs maximums de chaque approximation par rapport à la solution exacte :
 +
{| class="wikitable"
 +
|-
 +
! 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.

Version du 12 août 2019 à 10:49

Équations différentielle scalaires d’ordre 1

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

est une fonction de deux variables et où l’on cherche la fonction x de la variable définie et dérivable sur un intervalle de vérifiant :

Afin d'obtenir une solution unique, nous allons adjoindre à cette équation différentielle une condition initiale sous la forme d’un couple et chercher à résoudre le problème de Cauchy suivant :


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. La dérivée est approximée par est le pas de calcul (suffisamment petit).

On peut donc écrire la relation de récurrence :

L’algorithme de résolution utilisera donc les deux relations de récurrence suivantes :


Exemple : chute libre

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

Sa trajectoire est repérée dans un référentiel galiléen avec l'axe vers le bas.

Chute libre.svg

Sa vitesse projetée sur l'axe respecte l'équation de la dynamique suivante:

(1)

Avec la condition initiale :

(2)

L'équation (1) devient :

Remarque : La solution exacte à ce problème est trivialement connue :

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


Programmation python

On placera les valeurs dans un tableau nommé t

De même on placera les valeurs 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 :

Euler chute libre.svg

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.