b79c8eda64a096bccf27c54b7a82f0246025b34c
[scilab.git] / scilab / modules / xcos / help / fr_FR / solvers / 3-Dormand-Prince.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!--
3  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
4  * Copyright (C) Scilab Enterprises - 2012 - Paul Bignier
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.
9  * The terms are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  -->
12 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg"  xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="fr_FR" xml:id="DoPri">
13     <refnamediv>
14         <refname>Dormand-Prince 4(5)</refname>
15         <refpurpose>
16             <emphasis>Dormand-Prince</emphasis> est un solveur numérique fournissant une méthode explicite efficace pour résoudre des Problèmes à Valeur Initiale d'Equations Différentielles Ordinarires (EDOs).
17         </refpurpose>
18     </refnamediv>
19     <refsection>
20         <title>Description</title>
21         <para>
22             Appelé par <link linkend="xcos">xcos</link>, <emphasis>Dormand-Prince</emphasis> est un solveur numérique fournissant une méthode explicite efficace pour résoudre des Problèmes à Valeur Initiale de la forme :
23         </para>
24         <para>
25             <latex>
26                 \begin{eqnarray}
27                 \dot{y} = f(t,y), \hspace{3 mm} y(t_0) = y_0, \hspace{3 mm} y \in R^N
28                 \end{eqnarray}
29             </latex>
30         </para>
31         <para>
32             <emphasis>CVode</emphasis> et <emphasis>IDA</emphasis> utilisent un pas variable dans l'intégration.
33         </para>
34         <para>
35             Le défaut de cela est l'imprévisibilité du temps de calcul. Avec <emphasis>Runge-Kutta</emphasis>, on ne s'adapte pas à la complexité du problème, mais on garantit un temps de calcul stable.
36         </para>
37         <para>
38             Cette méthode est explicite, donc non concernée par les itérations fonctionnelles ou de Newton, et est déconseillée pour les problèmes raides.
39         </para>
40         <para>
41             C'est une amélioration de la méthode d'Euler, qui approxime 
42             <emphasis>
43                 y<subscript>n+1</subscript>
44             </emphasis>
45             en tronquant le développement de Taylor.
46         </para>
47         <para>
48             Par convention, pour utiliser des pas fixes, le programme commence par calculer un pas <emphasis>h</emphasis> qui approche le paramère de simulation <link linkend="Simulatemenu_Menu_entries">max step size</link>.
49         </para>
50         <para>
51             Une différence notable de <emphasis>Runge-Kutta</emphasis> par rapport à <emphasis>Sundials</emphasis> est qu'il calcule jusqu'à la septième dérivée de <emphasis>y</emphasis>, alors que les autres n'utilisent que des combinaisons linéaires de <emphasis>y</emphasis> et <emphasis>y'</emphasis>.
52         </para>
53         <para>
54             Ici, la valeur suivante est déterminée par la valeur actuelle 
55             <emphasis>
56                 y<subscript>n</subscript>
57             </emphasis>
58             plus la moyenne pondérée de six incréments, où chaque incrément est le produit du pas, <emphasis>h</emphasis>, et une estimation de la pente spécifiée par la fonction <emphasis>f(t,y)</emphasis> :
59             <itemizedlist>
60                 <listitem>
61                     <emphasis>k1</emphasis> est l'incrément basé sur la pente au début de l'intervalle, utilisant 
62                     <emphasis>
63                         y<subscript>n</subscript>
64                     </emphasis>
65                     (méthode d'Euler),
66                 </listitem>
67                 <listitem>
68                     <emphasis>k2, k3, k4</emphasis> et <emphasis>k5</emphasis> sont les incréments basés sur la pente à repectivement <emphasis>0.2, 0.3, 0.8</emphasis> et <emphasis>0.9</emphasis> de l'intervalle, s'utilisant mutuellement,
69                 </listitem>
70                 <listitem>
71                     <emphasis>k6</emphasis> est l'incrément basé sur la pente à la fin de l'intervalle, utilisant des combinaisons des autres <emphasis>ki</emphasis>.
72                 </listitem>
73             </itemizedlist>
74         </para>
75         <para>
76             On peut voir qu'avec les <emphasis>ki</emphasis>, on progresse dans les dérivées de 
77             <emphasis>
78                 y<subscript>n</subscript>
79             </emphasis>
80             . Dans le calcul des <emphasis>ki</emphasis>, on utilise délibérément des coefficients qui donnent une erreur en 
81             <emphasis>
82                 O(h<superscript>5</superscript>)
83             </emphasis>
84             à chaque pas.
85         </para>
86         <para>
87             L'erreur totale est donc en 
88             <emphasis>
89                 nombre de pas * O(h<superscript>5</superscript>)
90             </emphasis>
91             . Et puisque par définition <emphasis>nombre de pas = taille de l'intervalle / h</emphasis>, l'erreur totale est en 
92             <emphasis>
93                 O(h<superscript>4</superscript>)
94             </emphasis>
95             .
96         </para>
97         <para>
98             Cette analyse d'erreur a baptisé la méthode <emphasis>Dormand-Prince 4(5)</emphasis>: 
99             <emphasis>
100                 O(h<superscript>5</superscript>)
101             </emphasis>
102             par pas de temps, 
103             <emphasis>
104                 O(h<superscript>4</superscript>)
105             </emphasis>
106             au total.
107         </para>
108         <para>
109             Bien que le solveur fonctionne bien pour <link linkend="Simulatemenu_Menu_entries">max step size</link> jusqu'à 
110             <emphasis>
111                 10<superscript>-3</superscript>
112             </emphasis>
113             , des erreurs d'arrondi surviennent parfois quand l'on approche 
114             <emphasis>
115                 4*10<superscript>-4</superscript>
116             </emphasis>
117             . En effet, le scindage de l'intervalle ne peut pas être effectué correctement et l'on obtient des résultats imprévisibles.
118         </para>
119     </refsection>
120     <refsection>
121         <title>Exemples</title>
122         <para>
123             <link type="scilab" linkend="scilab.xcos/xcos/examples/solvers/ODE_Example.zcos">
124                 <inlinemediaobject>
125                     <imageobject>
126                         <imagedata align="center" fileref="../../../examples/solvers/ODE_Example.zcos" valign="middle"/>
127                     </imageobject>
128                 </inlinemediaobject>
129             </link>
130             <scilab:image><![CDATA[
131 loadScicos();
132 loadXcosLibs();
133 importXcosDiagram(SCI + "/modules/xcos/examples/solvers/ODE_Example.zcos");
134 scs_m.props.tol(6) = 5;
135 scs_m.props.tol(7) = 10^-2;
136 try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
137 ]]></scilab:image>
138         </para>
139         <para>
140             Le bloc intégrale retourne son état continu, on peut l'évaluer avec <emphasis>Dormand-Prince</emphasis> en lançant l'exemple :
141         </para>
142         <para>
143             <programlisting language="example"><![CDATA[
144       // Import du diagramme et réglage du temps final
145       loadScicos();
146       loadXcosLibs();
147       importXcosDiagram("SCI/modules/xcos/examples/solvers/ODE_Example.zcos");
148       scs_m.props.tf = 5000;
149
150       // Sélection de Dormand-Prince et réglage de la précision
151       scs_m.props.tol(6) = 5;
152       scs_m.props.tol(7) = 10^-2;
153
154       // Lancement du chrono, de la simulation et affichage du temps
155       tic();
156       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
157       t = toc();
158       disp(t, "Temps pour Dormand-Prince :");
159       ]]></programlisting>
160         </para>
161         <para>
162             La console Scilab affiche :
163             <screen><![CDATA[
164 Temps pour Dormand-Prince:
165  9.197
166             ]]></screen>
167         </para>
168         <para>
169             Maintenant, dans le script suivant, on compare la différence de temps entre <emphasis>Dormand-Prince</emphasis> et <emphasis>CVode</emphasis> en lançant l'exemple avec les cinq solveurs tour à tour :
170             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integDoPri.sce">
171                 Open the script
172             </link>
173         </para>
174         <para>
175             <screen><![CDATA[
176 Temps pour BDF / Newton :
177  18.894
178
179 Temps pour BDF / Functional :
180  18.382
181
182 Temps pour Adams / Newton :
183  10.368
184
185 Temps pour Adams / Functional :
186  9.815
187
188 Temps pour Dormand-Prince :
189  7.842
190             ]]></screen>
191         </para>
192         <para>
193             Ces résultats montrent que pour un problème non-raide, pour à peu près la même précision demandée et en forçant la même taille de pas, <emphasis>Dormand-Prince</emphasis> est plus rapide.
194         </para>
195     </refsection>
196     <refsection>
197         <title>Voir Aussi</title>
198         <simplelist type="inline">
199             <member>
200                 <link linkend="LSodar">LSodar</link>
201             </member>
202             <member>
203                 <link linkend="CVode">CVode</link>
204             </member>
205             <member>
206                 <link linkend="IDA">IDA</link>
207             </member>
208             <member>
209                 <link linkend="RK">Runge-Kutta 4(5)</link>
210             </member>
211             <member>
212                 <link linkend="RKImp">Runge-Kutta Implicite 4(5)</link>
213             </member>
214             <member>
215                 <link linkend="DDaskr">DDaskr</link>
216             </member>
217             <member>
218                 <link linkend="Comparaisons">Comparaisons</link>
219             </member>
220             <member>
221                 <link linkend="ode">ode</link>
222             </member>
223             <member>
224                 <link linkend="ode_discrete">ode_discrete</link>
225             </member>
226             <member>
227                 <link linkend="ode_root">ode_root</link>
228             </member>
229             <member>
230                 <link linkend="odedc">odedc</link>
231             </member>
232             <member>
233                 <link linkend="impl">impl</link>
234             </member>
235         </simplelist>
236     </refsection>
237     <refsection>
238         <title>Bibliographie</title>
239         <para>
240             Journal of Computational and Applied Mathematics, Volume 15, Parution 2, 2 Juin 1986, Pages 203-211 <ulink url="http://dl.acm.org/citation.cfm?id=9958.9963&amp;coll=DL&amp;dl=GUIDE">Dormand-Prince Method</ulink>
241         </para>
242         <para>
243             <ulink url="https://computation.llnl.gov/casc/sundials/documentation/documentation.html">Documentation Sundials</ulink>
244         </para>
245     </refsection>
246     <refsection>
247         <title>Histoire</title>
248         <revhistory>
249             <revision>
250                 <revnumber>5.4.1</revnumber>
251                 <revdescription>Dormand-Prince 4(5) ajouté</revdescription>
252             </revision>
253         </revhistory>
254     </refsection>
255 </refentry>