Comparaisons

Introduction

Suivant le type de problème, trouver la meilleure méthode n'est pas toujours évident, on ne peut que tirer des règles générales. C'est de celles-ci que l'on parle dans cette page.

Pas Fixe et pas Variable

Les solveurs sont divisés en deux familles principales : celles à pas variable et celles à pas fixes.

Dans les méthodes à pas variable, le pas de temps peut varier suivant la dynamique du modèle et les tolérances.

S'il recherche un temps de simulation stable, l'utilisateur doit sélectionner un solveur à pas fixe, parce-que le temps de calcul du nouveau pas d'un solveur à pas variable ne peut pas être prédit correctement.

Bien que pour un problème simple (ou hautes tolérances), un solveur à pas variable peut diminuer le temps de simulation en calculant de grands pas, un solveur à aps fixe est préférable si le pas de temps idéal est connu et à peu près constant (l'utilisateur peut alors le renseigner dans max step size).

Pas Variable:

• LSodar
• CVode
• IDA

• Runge-Kutta 4(5)
• Dormand-Prince 4(5)
• Runge-Kutta Implicite 4(5)
• Crank-Nicolson 2(3)

Les solveurs d'EDO à pas variable ne sont pas appropriés pour des applications temps réel déterministes car le surplus de calcul au passage d'un pas de temps varie au cours de l'application.

Explicite et Implicite - Raideur

A l'intérieur de ces deux familles, on peut distinguer les solveurs Explicites des Implicites.

Alors que les méthodes explicites n'utilisent que des informations du pas actuel, les implicites tentent d'estimer les dérivées à des temps futurs. Pour faire cela, elles utilisentdes solveurs non linéaires telle que itérations point-fixe, itérations fonctionnelles (non-raide) ou Newton modifiées (raide).

Le choix de la famille est habituellement déterminé par la raideur du problème, qui estquand il y a une différence importante entre les modules des valeurs propres extrêmesde la matrice jacobienne (mal conditionnée). C'est généralement un système sensible aux discontinuités, en cela que la précision requise n'est pas constante.

Implicites:

• LSodar
• CVode
• IDA
• Runge-Kutta Implicite 4(5)
• Crank-Nicolson 2(3)

• Runge-Kutta 4(5)
• Dormand-Prince 4(5)

En un mot, les Explicites calculent directement la solution, alors que les Implicites se concentrent sur la stabilité, impliquant plus d'opérations, suivant les tolérances.

Alors comment choisir ?

Puisqu'il n'est pas possible de savoir avec certitude si tel solveur sera efficace sur un système donné, le meilleur moyen est de lancer le plus probable et de comparer les résultats avec les autres.

L'utilisateur doit d'abord établir la compexité de son problème (stabilité / raideur) et s'il désire une grande précision, une simulation rapide, un temps prévisible ou un programme automatisé.

Précision : CVode,

Temps prévisible : Pas Fixe.

Temps de simulation : LSodar,

Automatisé : LSodar,

Exemples - ODEs

Commençons par un exemple non-raide simple : une intégration de Sinus.

Dans le script suivant, on compare la différence de temps entre les solveurs en lançant l'exemple avec différents solveurs tour à tour (IDA n'est pas adapté à ce genre de problème) : Ouverture du script

La console Scilab affiche :

Temps pour LSodar :
 10.1

Temps pour CVode BDF/Newton :
 31

Temps pour CVode BDF/Functional :
 30

Temps pour CVode Adams/Newton :
 17.211

Temps pour CVode Adams/Functional :
 16.305

Temps pour Dormand-Prince :
 12.92

Temps pour Runge-Kutta :
 7.663

Temps pour Runge-Kutta implicite :
 10.881

Temps pour Crank-Nicolson :
 7.856
            

Ces résultats montrent que pour un problème non-raide simple et à même précision, Runge-Kutta est le plus rapide.

En dépit du calcul de nouveau pas de temps, LSodar n'est pas très éloigné des solveurs à pas fixe solvers parce-qu'il détermine de larges pas de temps.

Des résultats, on peut extraire des facteurs de vitesse et dresser le tableau suivant :

Ensuite, un contrôleur basique à six états continus est testé.

Dans le script suivant, on compare la différence de temps entre les solveurs en lançant l'exemple avec les neuf solveurs tout à tour (IDA n'est pas adapté à ce genre de problème) : Ouverture du script

La console Scilab affiche :

Temps pour LSodar :
 10

Temps pour CVode BDF/Newton :
 28.254

Temps pour CVode BDF/Functional :
 25.545

Temps pour CVode Adams/Newton :
 15

Temps pour CVode Adams/Functional :
 12.1

Temps pour Dormand-Prince :
 2.359

Temps pour Runge-Kutta :
 1.671

Temps pour Runge-Kutta implicite :
 5.612

Temps pour Crank-Nicolson :
 3.345
            

Ces résultats montrent que quand la raideur apparaît légèrement, BDF / Newton commence à prendre de la vitesse. Mais le problème n'est pas encore suffisamment compliqué pour que cette méthode soit intéressante.

Le tableau des facteurs de vitesse :

A présent, on utilise le filtre de Kalman, contenant quinze états continus.

Dans le script suivant, on compare la différence de temps entre les solveurs en lançant l'exemple avec les neuf solveurs tout à tour (IDA n'est pas adapté à ce genre de problème) : Ouverture du script

La console Scilab affiche :

Temps pour LSodar :
 10

Temps pour CVode BDF/Newton :
 21.3

Temps pour CVode BDF/Functional :
 15.8

Temps pour CVode Adams/Newton :
 12.5

Temps pour CVode Adams/Functional :
 8.67

Temps pour Dormand-Prince :
 1.244

Temps pour Runge-Kutta :
 0.87

Temps pour Runge-Kutta implicite :
 4

Temps pour Crank-Nicolson :
 2.657
            

Ces résultats indiquent que pour un problème pour conséquent (plus d'états continus implique plus d'équations), les itérations de Newton commencent à montrer de l'intérêt, elles se rapprochent des autres solveurs.

Le tableau des facteurs de vitesse :

Exemples - EDAs

Dans cette section, on compare IDA à DDaskr.

Exemple : une balle rebondissante.

Dans le script suivant, on compare la différence de temps entre les solveurs en lançant les trois solveurs tout à tour : Ouverture du script

La console Scilab affiche :

Temps pour IDA :
 7.5

Temps pour DDaskr - Newton :
 5.4

Temps pour DDaskr - GMRes :
 10.2
            

Ces résultats montrent que pour un problème raide, avec traversées de zéro et à même précision, DDaskr - Newton est le plus rapide.

La différence de temps est attribuée à l'implémentation optimale de DDaskr et à son moindre contrôle d'erreur.

GMRes est plus lent dû à la petitesse du problème (pas suffisamment d'états continus).

Des résultats on extrait les facteurs de vitesse :

L'exemple suivant corrobore le précédent, il est plus court mais plus complet, parce-qu'il traite du remplissage et vidage d'une cuve.

Dans le script suivant, on compare la différence de temps entre les solveurs en lançant les trois solveurs tout à tour: Ouverture du script

La console Scilab affiche :

Temps pour IDA :
 3

Temps pour DDaskr - Newton :
 0.8

Temps pour DDaskr - GMRes :
 0.85
            

Des résultats on extrait les facteurs de vitesse :

Voir Aussi

• LSodar
• CVode
• IDA
• Runge-Kutta 4(5)
• Dormand-Prince 4(5)
• Runge-Kutta Implicite 4(5)
• Crank-Nicolson 2(3)
• DDaskr
• ode
• ode_discrete
• ode_roots
• odedc
• impl