Vous êtes sur la page 1sur 27

Analyse Numérique

par

Date de publication :

Dernière mise à jour :

Présentation, explication et implémentation en C++ des différentes méthodes


de résolution numérique.
Analyse Numérique par

1 - Introduction
1.1 - Exemples
2 - Dérivation numérique
3 - Intégration numérique
3.1 - Méthode des réctangles
3.2 - Méthode des trapèzes
3.3 - Méthode de Simpsons
3.4 - Méthode de Boode
3.5 - Méthode de Romberg
4 - Résolutions numériques
4.1 - Méthodes à un pas
4.1.1 - Méthode d'Euler
4.1.1.1 - Méthode d'Euler explicite
4.1.1.2 - Méthode d'Euler implicite
4.1.2 - Runge Kutta 2 (RK2)
4.1.3 - Runge Kutta 4 (RK4)
4.1.4 - Runge Kutta Fehlberg (RK6)
4.2 - Méthodes à pas multiples
4.2.1 - Méthodes d'Adams-Bashforth-Moulton (ABM)
4.2.2 - Méthodes de Gear
5 - Implémentation
5.1 - Conception
5.2 - Code
5.3 - Exemple
6 - Conclusion

-2-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

1 - Introduction

Nous allons voir la base de toute simulation numérique. Je pars sur le présupposé soulignant que, vous, lecteur avez
déjà une base mathématique. De plus, je ne vais pas démontrer toutes les formules utilisées puisque ce n'est pas
le but du tutorial. Le but ici est de vous donner le maximum d'outils afin que vous puissiez faire tout ce dont vous
avez besoin pour vos simulations physiques. Ce premier chapitre traitera de la base que vous devez avoir avant
de mettre un seul pied dans la physique. Les résolutions numériques (de EDO : equations differentielle ordinaire),
vous trouverez peut être cela fastidieux mais sachez que ce passage est indispensable. Le monde de la résolution
numérique ce divise en 3 types de méthodes de résolutions : Les méthodes à différentielles finies, les méthodes à
volumes finis, les méthodes des éléments finis. Nous allons nous penché sur la première dans ce tutorial. Les autres
méthodes ferons parties d'un autre tutorial. Pour résoudre les EDO issus des équations aux dérivées partielles (EDP)
nous aurons besoin de méthodes de résolutions numériques elles aussi divisées en 2 grandes familles : à pas unique
et à pas multiple. Dans ce tutorial nous nous pencherons sur les 2.

Et bien commençons...

1.1 - Exemples

Vous savez depuis le lycée que l'accélération est la dérivée de la vitesse et la vitesse celle de la position :

dx/dt=v

dx/dt=v

Jusqu'ici tout va bien, mais nous n'avons que très rarement l'équation explicite de la position de la vitesse ou
l'accélération. Puisque dans le cas contraire nous pouvons soit dériver soit intégrer pour avoir les autres composantes.

Si nous sommes dans le cas d'une chute libre (d'un corps ponctuel " pas de vitesse limite ") l'accélération sur terre
est de 9.81 m.s^-2 à peu près 10 m.s^-2, donc :

a(t)=10

Alors la vitesse est sa primitive :

v(t)=10t

+K

et si nous voulons la position en fonction du temps : nous re-intégrons

-3-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

x(t)=5t²

+ Kt

Puis viens la détermination de la constante K si à la date 0 nous sommes dans la position 0 alors x(0) = 0 et de
plus nous avons une vitesse initial v0 alors la constante est cette vitesse initiale puisque v(0) = K. Si nous partons
à une vitesse initial nulle. Cela veut dire que au bout de 5 secondes le point aura une vitesse de 50m.s^-1 et une
accélération de 125m.s^-2.

Et un autre exemple simple si nous voulons que le mouvement de notre point soit l'allure d'un cercle de rayon 1
autour du centre d'un repère orthonormé direct sur le plan xOy.

Les équations du mouvement projeté sur les axes x et y :

x(t)=cos(t)

y(t)=sin(t)

Donc pour obtenir la vitesse il faut dériver la position en fonction du temps :

vx(t)=-sin(t)

vy(t)=cos(t)

Et l'accélération sur les axes :

ax(t)=-cos(t)

ay(t)=-sin(t)

Ici nous partons sur la base que l'angle de rotation varie uniformément en fonction du temps donc nous n'avons pas
à faire de changement de variable à faire.

Voilà je pense que cela est saisi, mais il est très rare que nous ayons les équations du mouvement, en général nous
avons une situation initiale et des forces extérieures ou contraintes à respecter.

Donc nous devons tous d'abord voir comment dériver et intégrer sans avoir les équations.

-4-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

2 - Dérivation numérique

Et bien la dérivée en un point c'est le coefficient directeur de la tangente en un point donné. Donc nous pouvons
simplement la calculer :

dérivée

Et là les problèmes commencent, théoriquement plus dt est petit plus la dérivée est précise mais tous ces calculs
sont effectués sur un ordinateur et les limites de mémoire ne nous permettent pas de gestion des nombres réel (les
ordinateurs ne sont pas des machines de turing complète), c'est pourquoi il y a des erreurs d'approximations : par
exemple en C++ (pas seulement en C++) les types sont limités en précision en chiffre significatif :

Float 6

Double 15

Long double 18

Donc lorsque plus tard nous multiplierons dt par autre chose nous aurons des problèmes : par exemple si nous usons
d'un float et que l'on multiplie par 424242 ça va puisqu'il y a nos 6 chiffres significatifs mais si nous multiplions par
4242425 ça pause alors un problème puisque ici nous avons 7 chiffres significatifs, alors ce sera arrondi ou tronqué.
Un arrondi ce n'est pas vraiment grave en soit mais comme nous opérons récursivement (par récurrence) le tous
s'accumule et il y a une divergence par rapport à la solution exacte.

Deuxième méthode pour dériver : c'est à peu près la même sauf que l'on encadre le point. Cette méthode n'est pas
toujours possible puisque en général nous cherchons la position d'après. Mais comme nous le verrons plus tard
certaine méthode de résolution numérique ont besoin de plusieurs positions précédentes (Adams-Bashforth-Moutlon,
Gear, ...). Par exemple pour connaître la position d'après nous avons parfois besoin avec ces méthodes de la ou
des dernières positions.

Donc Dérivée

v(t)

a(t)

Maintenant regardons le problème de manière plus "serieuse" :

Sans entrez dans les détailles pour trouver des méthodes de dérivation plus précise nous procédons à 2
developpement de Taylor pour f(dt) et f(-dt) dont nous fesons la somme. Puis à l'aide d'un théorème dit des valeurs
intermédiaire nous determinons les dérivées avec la précision que nous voulons (cf Annexe).

Voici quelque exemple de dérivation pour les dérivées premières et seconde (O(dt^2)) dérivée centrée:

-5-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

u'(0) = (U(dt) - U(-dt))/(2*dt)

u''(0)= (U(dt) - 2*U(0) + U(-dt))/(dt^2)

Dérivée centré (utilisation des informations de part et d'autre de notre fonction à une date donnée) O(dt^4) :

u'(0) = (-U(2*dt) + 8*U(dt) - 8*U(-dt) + U(-2*dt))/(12*dt)

u''(0) = (-U(2dt) + 16U(dt) - 30U(0) + 16U(-dt) - U-(2dt))/(12*dt^2)

Et dérivée amout (utilisation des informations précedante) O(dt^2) :

u'(0) = (3U(0) - 4U(-dt) + U(-2dt))/(2dt)

u''(0) = (2U(0) - 5U(-dt) + 4U(-2dt) - U(-3dt))/(dt^2)

Trouvée des méthodes pour dérivée plus précisément n'est pas un problème vraiment ardu donc à vous d'estimer la
précision dont vous avez besoin en fonction de votre dt et des types que vous manipuler.

Voilà en ce qui concerne les dérivées numériques certes un mathématicien trouverait cela trop léger mais nous
n'avons pas besoin de plus pour l'utilité que nous allons en faire. Maintenant intégrons...

-6-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

3 - Intégration numérique

Lorsque en cour nous découvrons les intégrales on nous dit que c'est la surface qui est sous la courbe bornée par
l'axe des abscisses si la courbe est positive sinon on calcule l'opposé de l'aire. Et bien c'est ce que l'on va faire
cherché pour nos méthodes méthodes.

3.1 - Méthode des réctangles

Pour calculer

Iabfdx

il suffit ici pour de calculer l'aire du réctangle de longeur f(a) ou f(b) et largeur b-a. Cette méthode est exacte si la
fonction intégrée est constante. Cette méthode est relativement proche de la valeur exacte si la fonction ne croit ou
ne décroit "pas trop rapidement" dans notre intervale d'intégration.

Cherchons :

Ixx5505

Prenons la longeur f(5). Ici dt = 0.05.

Donc

rectIxx5

Ou avec l'autre longeur.

-7-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

rectIxx5

La valeur exacte :

Ifxxexl

Avec 1.25 nous avons 0.986...% d'erreur.

Avec 1.275125 nous avons alors 0.996...% d'erreur

Approchons nous en fesant la moyenne des aires des réctangles

calc0

3.2 - Méthode des trapèzes

Cette méthode contrairement à la précédente elle considère f(a) et f(b) pour calculer

Iabfdx

vadt

-8-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

On peut encadré si on calcule l'accélération d'après (comme toujours on verra ça après).

vadt2

Encore une fois cela pose problème à la découverte du a(t+dt).

vadt

Cette méthode est exacte pour une fonction affine (même si la fonction s'annule entre [t-dt ; t] cela marche aussi).
Mais si la fonction varie trop entre [t-dt ; t] l'intégrale n'a plus de sens ici nous avons le même problème sur la petitesse
du dt que pour la dérivée et les limites d'un ordinateur.

Reprenons notre exemple précedent :

trap2

Ce qui nous fait 0.00165...% d'erreur beaucoup mieux. Notez que nous obtenons le même resultat que si nous fesions
la moyenne des aires des réctangles que nous avons trouvé avec la méthodes des réctangles.

Avec cette méthode aussi nous avons le même problème avec la petitesse du dt et des limites de la machine de
Turing Ordinateur.

La moyenne des surfaces de 2 rectangles ayant un côté commun équivaut à la surface d'un trapèze rectangle dont
un côté est le côté commun des rectangles et les côtés sont les autres côtés des rectangles :

-9-
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

- 10 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

trap

Erreur avec cette méthode :

errtrap

Comme nous l'avons précisé en introduction pas de démonstration. Pour plusieurs raison je ne veux pas surcharger
ce cour d'agrégat mathématique (il parait que " chaque démonstration divise le nombre de lecteur par 2 "), ce n'est
pas un tutorial de mathématique ou tout simplement certain aspect des démonstrations sont trop subtile pour que
je puisses les saisir dont les expliqués.

3.3 - Méthode de Simpsons

Intégrale entre -dt et dt :

simpsons

Dans un cas plus général nous éfféctuons une erreur de :

errsimp

3.4 - Méthode de Boode

Intégrale entre -dt et dt :

boode

3.5 - Méthode de Romberg

- 11 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

C'est une méthode récursive c'est méthode nous faisons plusieurs de " mini-trapèze " (2, 4, 8, 16, #). Mais cette
méthode est relativement lourde lorsque l'on fait des résolutions numériques puisque à chaque rang on va être précise
alors on enregistre 2 fois plus d'information que le rang d'avant :

romberg

Exemple :

Pour cos(x) de 0 à PI/4

ipi2

21.46 %

ipi4

5.19% d'erreur

ipi8

1.29%

ipi16

- 12 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

0.3%

...

limrom

Personnellement je vous déconseille d'utiliser cette méthode au risque de voir vos fps chuté (si votre objectif est le
temps réel). Utiliser là si vous cherchez de la précision et non de la fluidité.

Maintenant nous savons dériver et intégré avec la position, la vitesse ou l'accélération nous pouvons retrouvé les 2
autres manquant en ayant une seul des 3.

Maintenant nous allons enfin pouvoir commencer ce qui est vraiment intéressant les méthodes de résolution
numérique.

- 13 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

4 - Résolutions numériques

Maintenant je noterais Un un élément à la date t=n et f(Un, tn) la dérivée de Un a la date t=tn. Dans cette séction
(résolutions numériques) nous allons parlé de deux types de méthode celle qui on besoin de plusieurs information
pour déterminer l'état suivant, et celle qui on besoin d'une unique information (état passé). Les meilleurs méthodes
usant d'une information sont gourmandes en calcule, et les meilleurs méthodes usant de plusieurs informations sont
gourmandes en mémoire (si nous stockons pas l'information ces méthodes sont elles aussi loudres en calcules).

4.1 - Méthodes à un pas

Les méthodes avec une information unique Un qui permet de calculer l'état d'après Un+dt sont les plus connues et
les plus utilisées.

4.1.1 - Méthode d'Euler

Euler est de loin la méthode la plus connu, la plus utilisé et à ma connaissance la moins précise.

4.1.1.1 - Méthode d'Euler explicite

Comme sont nom l'indique elle est explicite et ne necessite aucun stratagème pour découvrir l'état suivant.

euler

Ce qui veut dire que la position est

poseuler

Équation d'unités, si certains ne sont pas convaincus :

[L] = [T]*[L]/[T] + [L]

[L] = [L]

m = sec*m/sec + m

m=m

4.1.1.2 - Méthode d'Euler implicite

- 14 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

Cette méthode contrairement à la méthode explicite. Est une méthode anticipatrice. Elle a besoin d'une information
futur pour connaitre l'état futur.

Euler implicite c'est la même méthode à part qu'il faut anticiper pour connaître la dérivée qui suit :

Euler implicite = Gear 1 (G1) ou Adams-Bashforth-Moulton 1 (ABM1) ou Runge Kutta 1 (RK1)

eulerimp

Les méthodes d'Euler sont sympathiques pas difficile à utiliser mais nous avons trop d'erreur surtout pour les fonctions
sinusoïdale la solution trouvé par Euler diverge de la vrai solution ce qui pose problème lorsque l'on travail avec
des ressorts.

Réalité VS Euler explicite

Ici 5*(1-exp(-x)) en bleu est l'approximation par Euler en rose avec un pas de 0.25 il n'y a pas photo. Cherchons
l'erreur :

Réel Euler
0 0
5/e 0+5/e*dt
5/e^2 5/e*dt+5/e^2*dt
5*e^-3 5*dt*e^-1+5*dt*e^-2+5*dt*e^-3
... ...
La solution Réel est supérieure à l'approximation d'Euler

Alors l'erreur en fonction de n ->

erreuler0

erreuler1

- 15 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

erreuler2

limerreuler

Ici ce n'est pas vraiment grave puisque la fonction trouvée par Euler tend vers une limite constante mais en général
il y a une divergence par rapport à la vraie exacte qui s'accumule.

Vers l'infini et audelas

Avec 5*exp(-x) l'erreur tend vers une limite finie. Mais ici avec exp(x) avec l'approximation d'euler et un pas de 0.25
l'erreur augmente exponentiellement. Pour connaître l'erreur au nième terme :

Réel Euler
0 0
e 1+e*dt
e^2 1+e*dt+e^2*dt
e^3 1+e*dt+e^2*dt+e^3
... ...
Ici c'est l'inverse la solution Euler est supérieurs à la valeur exacte.

Alors l'erreur :

erreuler00

Err(n) = 1+dt(e*(1+e(1+e(1+e(1+...))))))))) - e^n

Err(n) = 1+dt*Somme(e^n, n, 1, n) - e^n

TODO : use LaTeX

Lim Err(n) quand n tend vers +inf = +inf (Pour nos amis matheux nous admettons que dt > 0 [logique dans notre cas]
et e*dt - e+1 > 0 puisque 0 1 sinon en effet la limite n'est pas évidente et là non plus elle est pas évidente). Deplus
notre fonction err tend vers l'infini cela veut dire que l'approximation d'Euler s'eloignera de plus en plus de la solution
exacte. Mais si on calcule le pourcentage d'erreur (valeur exacte - valeur trouvé)/ valeur exacte alors on trouvera que

- 16 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

ce pourcentage aura une limite fini de 5.05% Avec cette équation nous ne pouvons pas avoir plus de 5% d'erreur par
rapport à la solution exacte bien que la solution d'Euler s'éloigne tout le temps de la solution réel...

4.1.2 - Runge Kutta 2 (RK2)

Runge Kutta d'ordre 2 ou Méthode de Heun. Est une méthode qui fait une première approximation (K1 = Euler
explicite) puis nous nous servons de K1 pour avoir une meilleur approximation (K2). C'est une méthode qui "ce corrige
au fur et à mesure des calcules".

Un+1 = Un + dt*(o1*k1+o2+k2)

K1 = f(Un, tn)

K2 = f(Un + dt*b*K1, tn + a*dt)

Noté que si o1 = 1 et o2 = 0

Avec a et b quelconques nous retrouvons Euler explicite.

Pour Heun et RK2

Un+1 = Un + (k1+k2)*dt/2

K1 = f(Un, tn)

K2 = f(Un + dt*K1, tn)

Note pour qui la démonstration intéresse il suffit de faire un développement limité d'ordre 2 et ainsi nous pouvons
cherché une solution particulière avec une erreur égale à celle du développement limité (x²*O(x)) en identifiant les
termes o1, o2, a et b avec les termes de même puissance.

Réalité VS Runge Kutta 2 VS Euler

On voit tout de suite la différence avec le Euler. Nous allons voir maintenant la méthode la plus utiliser mais pas la
plus précise disons le meilleur rapport qualité prix pour les simulations en temps réel.

4.1.3 - Runge Kutta 4 (RK4)

Certain ne jure que par elle Runge Kutta d'ordre 4 semble être un très bon compromis entre compléxité de calcule
et résultat.

K1 = f(Un ; tn)

K2 = f(Un + k1*dt/2 ; tn + dt/2)

K3 = f(Un + k2*dt/2 ; tn + dt/2)

K4 = f(Un + k3*dt/2 ; tn+1)

- 17 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

Un+1 = Un + (k1 + 2*k2 + 2*k3 + k4)*dt/6

Réalité VS RK4 VS RK2 VS Euler

On note le progrès. Il faut noté que plus nous cherchons de la précisions plus les calcules sont nombreux comme
toujours plus c'est chère mieux c'est. Nous allons vous présentez une dernière méthode pour encore gagné de la
précision et gagné encore en complexité (big O). Notre Ô devient de plus en plus gros. Mais bon il n'y a pas que
le temps réel qui compte. Certain système fortement oscillatoire on besoin de plus de précision si on prétend à un
temps soit peu de réalisme par exemple la gestion des fluides compressibles (sans considérer les méthodes que
nous aborderons dans d'autre chapitre [Octree]).

4.1.4 - Runge Kutta Fehlberg (RK6)

Cette méthode est encore plus précise et encore plus compléxe en calcule.

K1 = f(Un ; tn)

K2 = f(Un + k1*dt/4 ; tn + dt/4)

K3 = f(Un + 3*K1*dt/32 + 9*K2*dt/32 ; tn + 3*dt/8)

K4 = f(Un + 1932*dt*K1/2197 - 7200*dt*K2/2197 + 7296*K3*dt/2197 ; tn + 12h/13)

K5 = f(Un + 439*dt*K1/216 - 8*dt*K2 + 3680*dt*K3/513 - 845*K4*dt/4104 ; tn + dt)

K6 = f(Un - 8*dt*K1/27 + 2*dt*K2 - 3544*dt*K3/2565 - 1859*dt*K4/4104 - 11*dt*K5/40 ; tn + dt/2)

En gros on cherches les coefficients directeur et on ce déplace et on recalcule sur dt/4 puis sur 3*dt/8, 12*dt/13 sur
dt et enfin sur dt/2. Après :

Un+1 = Un + dt*(16*K1/235 + 6656*K3/12825 + 28561*K4/56430 - 9*K5/50 + 2*K6/55)

Ces méthodes nécessitent juste une seule position à mémoriser juste l'ancienne pour connaître la suivante. Mais
nous allons voir des méthodes de résolutions numériques qui nécessite un peu plus de position.

4.2 - Méthodes à pas multiples

Avec les méthodes qui vont suivre je ne vais pas donnée d'exemple juste en présenté quelque une. (Voir la fin pour
implémentation)

4.2.1 - Méthodes d'Adams-Bashforth-Moulton (ABM)

Ui+1 = Ui + h*Somme(aj*f(Xi-j ; Ui-j), j=-1, n)

f(Xi-j ; Ui-j) = Fi-j (c'est l'intégrale de i à j)

ABM(1) c'est Euler nous en avons déjà parler :

- 18 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

Ui+1 = Ui + h * Fi (Euler explicite - ABM d'ordre 1)

Ui+1 = Ui + h Fi+1 (Euler implicite - ABM d'ordre 1)

ABM(2) pour celui là il faut connaître 2 informations à i et i-1 :

Ui+1 = Ui +h/2 (-Fi-1 + 3*Fi) (ABM d'ordre 2)

Ui+1 = Ui +h/2(Fi + Fi+1) trapèzes (ABM d'ordre 2)

ABM(3) à besoin de 3 infos i ; i-1 et i-2

Ui+1 = Ui +h/12 (5*Fi-2 - 16*Fi-1 + 23*Fi) (ABM d'ordre 3)

Ui+1 = Ui +h/12 (-Fi-1 + 8Fi + 5Fi+1) (ABM d'ordre 3)

ABM(4) lui 4#

Ui+1 = Ui +h/24 (-9Fi-3 + 37Fi-2 - 59Fi-1 + 55Fi) (ABM d'ordre 4)

Ui+1 = Ui + h/24 (Fi-2 - 5Fi-1 + 19Fi + 9Fi+1) (ABM d'ordre 4)

Cette méthode est relativement simple à implémenter donc je ne pense pas qu'une illustration soit nécessaire.

4.2.2 - Méthodes de Gear

Ui+1 = Ui + dt*Fi+1

(Euler implicite - Gear d'ordre 1) O(h)

Ui+1 = 1/3*(-Ui-1 + 4*Ui) +2*dt*Fi+1/3

(Gear d'ordre 2) O(h2)

Ui+1 = 1/11*(2Ui-2 - 9Ui-1 + 18*Ui) + 6*dt*Fi+1/11

(Gear d'ordre 3) O (h3)

Ui+1 = 1/25 (-3Ui-3 + 16Ui-2 - 36Ui-1 + 48*Ui) + 12*dt*Fi/25

(Gear d'ordre 4) O(h4)

De même ici il faut juste les implémentées rien de bien compliquer gérer la mémorisation des données.

- 19 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

5 - Implémentation

Après la théorie passons à la pratique l'implémentation en C++. Nous allons pas entrer dans des débats sur le choix
du langage j'apprécies ce langage et la POO c'est totalement arbitraire.

5.1 - Conception

Et bien nous n'allons pas programmer une classe " dérivée ", " intégré " et " résoudre ". Nous avons simplement
besoin d'une classe abstraite pour les résolutions numériques. Nous hériterons de cette classe à chaque fois que
nous aurons besoin d'une nouvelle méthode de résolution numérique. De quoi aura besoin notre classe abstraite qui
sera commun à toutes les méthodes de résolution :

• Différentiel de temps (ici non infinitésimal) : dt


• La date : Tp
• Un vector3D qui représentera notre fonction à l'instant Tp
• Et un pointeur vers une fonction qui est la dérivée d'un vecteur
• La fonction Next pour calculer Un+dt
• Et quelque fonction...

Regardons ce que cela donne niveau code.

5.2 - Code

Voyons ce que ça donne :

NumericalSolver.h
#ifndef __NUMERICALSOLVER_H__
#define __NUMERICALSOLVER_H__

#include "Vector3D.h"

namespace VM
{
template<class T>
class NumericalSolver
{
public :
NumericalSolver(Vector3D<T> (*f)(Vector3D<T>, T), T, Vector3D<T>);
virtual ~NumericalSolver();
Vector3D<T> (*dF) (Vector3D<T>, T); // dy/dt
Vector3D<T> F; // f
T dt; // différentiel de temps
T Tp; // temps courant
virtual void Next() = 0; // Calculer la position suivante
Vector3D<T> GetF(); // retourné la fonction
Vector3D<T> GetdF(); // Retourné dP
T Getdt(); // retourné la différentiel de temps
void Setdt(T dT); // changé la différentiel de temps
};

#include "NumericalSolver.hpp"
}

#endif

- 20 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

Et NumericalSolver.hpp n'est que l'instance des fonctions qui doit être absolument dans le même fichier puisque
template oblige voir : FAQ C++ Template. Noter le =0 après Next() qui en fait une fonction virtuelle puisqu'elle est
différente pour chaque méthode de résolution numerique.

NumericalSolver.hpp
// Constructeur
template<class T>
NumericalSolver<T>::NumericalSolver(Vector3D<T> (*f)(Vector3D<T>, T), T dT, Vector3D<T> y) : dF(f),
dt(dT), F(y), Tp(0)
{}

// Destructeur
template<class T>
NumericalSolver<T>::~NumericalSolver()
{}

// Retourner F(Tp)
template<class T>
Vector3D<T> NumericalSolver<T>::GetF()
{
return F;
}

// Retourner dF(F, Tp)/dt


template<class T>
Vector3D<T> NumericalSolver<T>::GetdF()
{
return dF(F, Tp);
}

// Retourner dt
template<class T>
T NumericalSolver<T>::Getdt()
{
return dt;
}

// Changer dt
template<class T>
void NumericalSolver<T>::Setdt(T dT)
{
dt = dT;
}

Ceci étant fait nous pouvons mettre en place notre myriade de méthode de résolution numérique exemple
Runge-Kutta d'ordre 4 (RK4) :

RK4_E.h
#ifndef __RK4_E_H__
#define __RK4_E_H__

#include "NumericalSolver.h"

namespace VM
{
template<class T>
class RK4_E : public NumericalSolver<T>
{
public :
RK4_E();
virtual ~RK4_E();

- 21 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

RK4_E.h
Vector3D<T> K1;
Vector3D<T> K2;
Vector3D<T> K3;
Vector3D<T> K4;
void Next(); // F(n+dt)
};

#include "RK4_E.hpp"
}

#endif

Définition de Next(). Et noter l'apparition de 4 variables utiles (pas indispensable mais nécessaire pour plus de clarté)
pour cette méthode voir plus haut.

RK4_E.hpp
// constructeur
template<class T>
RK4_E<T>::RK4_E() : NumericalSolver<T>(NULL, 0.01, Vector3D<T>(0, 0, 0))
{}

// destructeur
template<class T>
RK4_E<T>::~RK4_E()
{}

// Next
template<class T>
void RK4_E<T>::Next()
{
K1 = this->dF(this->F, this->dt); // dy/dt
K2 = this->dF(this->F+K1*this->dt/2, this->Tp+this->dt/2); // d(y+dt*K1/2)/d(t+dt/2)
K3 = this->dF(this->F+K2*this->dt/2, this->Tp+this->dt/2); // d(y+dt*k2/2)/d(t+dt/2)
K4 = this->dF(this->F+K3*this->dt, this->Tp+this->dt); // d(y+dt*k3)/d(t+dt)
this->F += (K1+(K2+K3)*2+K4)*this->dt/6;
this->Tp += this->dt;
}

Un exemple d'implémentation pour méthode à pas multiple Gear

Gear4_I.hpp
#ifndef __GEAR4_I_H__
#define __GEAR4_I_H__

#include "NumericalSolver.h"

namespace VM
{
// Gear implicite d'ordre 2
template<class T>
class Gear4_I : public NumericalSolver<T>
{
public :
Gear4_I(Vector3D<T> &);
virtual ~Gear4_I();

/* F <=> yn+1
yn
yn_1 <=> yn-1
yn_2 <=> yn-2
*/

- 22 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

Gear4_I.hpp
Vector3D<T> yn;
Vector3D<T> yn_1;
Vector3D<T> yn_2;
Vector3D<T> yn_3;
void Next(); // F(n+dt)
};

#include "Gear4_I.hpp"
}

#endif

Avec son hpp :

Gear4_I.hpp
template<class T>
Gear4_I<T>::Gear4_I(Vector3D<T> &ff) : NumericalSolver<T>(NULL, 0.01, ff)
{
yn = yn_1 = yn_2 = yn_3 = this->F;
}

template<class T>
Gear4_I<T>::~Gear4_I()
{}

template<class T>
void Gear4_I<T>::Next()
{
yn_3 = yn_2;
yn_2 = yn_1;
yn_1 = yn;
yn = this->F;
this->F = ((yn*48 - yn_1*36 + yn_2*16 - yn_3*3) + this->dF(this->F + this->dF(this->F,
this->Tp)*this->dt, this->Tp + this->dt)*12*this->dt)/25;
// Fn+1 calculer avec euler
this->Tp += this->dt;
}

A vous d'implémenté les méthodes que vous désirez. Mais nous n'allons pas donnez cela comme ça au programmeur
il lui faut une interface pour gérer son model physique. Donc il nous faut une classe PhysicModel qui soit lier à la
méthode de résolution numérique choisit un vecteur graviter enfin tous ce dont nous avons besoin :

PhysicModel.h
#ifndef __PHYSICMODEL_H__
#define __PHYSICMODEL_H__

#include "Euler_E.h"
#include "Euler_I.h"
#include "RK2_E.h"
#include "RK4_E.h"
#include "RK6_E.h"
#include "ABM2_E.h"
#include "ABM2_I.h"
#include "ABM3_E.h"
#include "ABM3_I.h"
#include "ABM4_E.h"
#include "ABM4_I.h"
#include "Gear2_I.h"
#include "Gear3_I.h"
#include "Gear4_I.h"
#include "Vector3D.h"

- 23 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

PhysicModel.h
namespace VM
{
enum NS
{
NS_EULER_E,//Euler explicite
NS_EULER_I,//Euler implicite
NS_RK2_E,// RungeKutta explicite
NS_RK4_E,// RK4 explicite
NS_RK6_E,// RK6 explicite
NS_ABM2_E,//Adams-Bashforth-Moulton explicite d'ordre 2
NS_ABM2_I,//Adams-Bashforth-Moulton implicite d'ordre 2
NS_ABM3_E,//ABM3 explicite
NS_ABM3_I,//ABM3 implicite
NS_ABM4_E,// ABM4 explicite
NS_ABM4_I,// ABM4 implicite
NS_G2_I,//Gear implicite d'ordre 2
NS_G3_I,
NS_G4_I
};
template<class T>
class PhysicModel
{
public :
PhysicModel(Vector3D<T> &);
PhysicModel(Vector3D<T> &, NS);
PhysicModel(Vector3D<T> &, NS, Vector3D<T>);
PhysicModel(Vector3D<T> &, NS, Vector3D<T>, T);
virtual ~PhysicModel();
NS tns;
NumericalSolver<T> *ns;
Vector3D<T> g; // Vecteur d'acceleration de la gravité
T angle; // angle de lancé
T v0; // vitesse initial
Vector3D<T> p; // position

void Simulation();
};

#include "PhysicModel.hpp"

typedef PhysicModel<float> fPhysicModel;


}

#endif

Bien sur ce PhysicModel changera ici il s'agit simplement d'une model pour lancer un point. Vous trouverez joint à
ce tutorial une source illustrant quelque implémentation et un exemple.

5.3 - Exemple

Dans notre source nous avons un exemple simple de lancer d'un corps ponctuel. Ce point a :

• Une vitesse initial v0


• Un angle de lancer angle
• Une masse

Donc résonnons analytiquement avant de donnée notre dérivée. Cherchons l'accélération à Tp=0.

Ax = 0

- 24 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

Ay = g

Alors pour la vitesse il s'agit d'une intégral :

Vx = k0

Vy = tg/m + k1

Alors pour déterminer nos constantes k0 et k1 regardons la vitesse à Tp = 0.

Vx(0) = v0*cos(angle)

Vy(0) = v0*sin(angle)

Donc

Vx = v0*cos(angle)

Vy = tg/m + v0*sin(angle)

Voilà nous avons :

Dx/dt = v0*cos(angle)

Dy/dt = tg/m + v0*sin(angle)

"Y a qu'a" lancer la résolution...

En ce qui concerne l'exemple :

Il s'agit d'un code en développement qui à pour but final de réaliser un moteur physique. Donc pour l'instant incomplet
certaine chose peuvent sembler à revoir où inutile pour l'instant mais nous verrons avec cette série de tutoriaux notre
moteur ce former...

Dans le code vous trouverez un fichier param.txt où ou pourrez parameterer le lancer avec les éléments qui suivent
dans l'ordre :

1 dt en sec
2 masse en kg
3 vitesse en m.s^-1
4 angle de lancer (en radian)

- 25 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

6 - Conclusion

Et bien voilà lorsque vous aurez saisi tous ça vous verrez avec l'expérience vous userez tel ou tel méthodes de
résolution mais en général si vous faites du temps réel vous serez réduit à Euler, RK2, RK4, les ABM voir RK6. Par
la suite nous appliquerons ces méthodes pour faire des simulations tel les soft body (corps mous, vêtements), rigid
body, fluide, ... Nous verrons les volumes finis et ferons nos simulations 3D dans des pixels 3D (vortex) pour " lancer
" des fluides, des solides, ...

- 26 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/
Analyse Numérique par

- 27 -
Les sources présentés sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation
de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2007 - KHIAT Soufiane. Aucune reproduction,
même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://chkone.developpez.com/

Vous aimerez peut-être aussi