make doc-fr_FR was broken on Implicit Runge Kutta xml:id
[scilab.git] / scilab / modules / xcos / help / fr_FR / solvers / 4-ImplicitRK.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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  -->
15 <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="ImpRK">
16     <refnamediv>
17         <refname>Implicit Runge-Kutta 4(5)</refname>
18         <refpurpose>
19             <emphasis>Implicit Runge-Kutta</emphasis> est un solveur numérique fournissant une méthode implicite efficace et stable pour résoudre des Problèmes à Valeur Initiale d'Equations Différentielles Ordinarires (EDOs). Called by <link linkend="xcos">xcos</link>.
20         </refpurpose>
21     </refnamediv>
22     <refsection>
23         <title>Description</title>
24         <para>
25             <emphasis>Runge-Kutta</emphasis> est un solveur numérique fournissant une méthode explicite efficace pour résoudre des Problèmes à Valeur Initiale de la forme :
26         </para>
27         <para>
28             <latex>
29                 \begin{eqnarray}
30                 \dot{y} = f(t,y), \hspace{3 mm} y(t_0) = y_0, \hspace{3 mm} y \in R^N
31                 \end{eqnarray}
32             </latex>
33         </para>
34         <para>
35             <emphasis>CVode</emphasis> et <emphasis>IDA</emphasis> utilisent un pas variable dans l'intégration.
36         </para>
37         <para>
38             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.
39         </para>
40         <para>
41             Cette méthode étant implicite, elle peut être utilisée sur des problèmes raides.
42         </para>
43         <para>
44             C'est une amélioration de la méthode d'Euler implicite, qui approxime
45             <emphasis>
46                 y<subscript>n+1</subscript>
47             </emphasis>
48             en calculant
49             <emphasis>
50                 f(t<subscript>n</subscript>+h, y<subscript>n+1</subscript>)
51             </emphasis>
52             et tronquant le développement de Taylor.
53         </para>
54         <para>
55             Le schéma implémenté est inspiré de "Low-Dispersion Low-Dissipation Implicit Runge-Kutta Scheme" (lien en bas de page).
56         </para>
57         <para>
58             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>.
59         </para>
60         <para>
61             Une différence notable de <emphasis>Runge-Kutta implicite</emphasis> par rapport à <emphasis>Sundials</emphasis> est qu'il calcule jusqu'à la dérivée quatrième de <emphasis>y</emphasis>, alors que les autres n'utilisent que des combinaisons linéaires de <emphasis>y</emphasis> et <emphasis>y'</emphasis>.
62         </para>
63         <para>
64             Ici, la valeur suivante
65             <emphasis>
66                 y<subscript>n+1</subscript>
67             </emphasis>
68             est déterminée par la valeur actuelle
69             <emphasis>
70                 y<subscript>n</subscript>
71             </emphasis>
72             plus la moyenne pondérée de trois increments, 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>. Ils sont distribués de manière à peu près égale sur l'intervalle.
73             <itemizedlist>
74                 <listitem>
75                     <emphasis>k1</emphasis> est l'incrément basé sur la pente au début de l'intervalle, utilisant
76                     <emphasis>
77                         y<subscript>n</subscript>+ a11*h*k1,
78                     </emphasis>
79                     ,
80                 </listitem>
81                 <listitem>
82                     <emphasis>k2</emphasis> est l'incrément basé sur la pente près du milieu de l'intervalle, utilisant
83                     <emphasis>
84                         y<subscript>n</subscript> + a21*h*k1 + a22*h*k2,
85                     </emphasis>
86                     ,
87                 </listitem>
88                 <listitem>
89                     <emphasis>k3</emphasis> est l'incrément basé sur la pente trois quarts de l'intervalle, utilisant
90                     <emphasis>
91                         y<subscript>n</subscript> + a31*h*k1 + a32*h*k2 + a33*h*k3.
92                     </emphasis>
93                 </listitem>
94             </itemizedlist>
95         </para>
96         <para>
97             On peut voir que le calcul d'un <emphasis>ki</emphasis> requiert <emphasis>ki</emphasis>, nécéssitant ainsi l'utilisation d'un solveur non linéraire (ici, itérations point-fixes).
98         </para>
99         <para>
100             D'abord, on initialise
101             <emphasis>
102                 k0 = h * f(t<subscript>n</subscript>, y<subscript>n</subscript>)
103             </emphasis>
104             comme première estimation pour tous les <emphasis>ki</emphasis>, pour obtenir de nouveaux <emphasis>ki</emphasis> et une première valeur pour
105             <emphasis>
106                 y<subscript>n+1</subscript>
107             </emphasis>
108             .
109         </para>
110         <para>
111             Ensuite, on sauve les valeurs et on recalcule
112             <emphasis>
113                 y<subscript>n+1</subscript>
114             </emphasis>
115             avec ces nouveaux <emphasis>ki</emphasis>.
116         </para>
117         <para>
118             Puis on compare les deux
119             <emphasis>
120                 y<subscript>n+1</subscript>
121             </emphasis>
122             et on le recalcule jusqu'à ce que son écart avec le dernier soit inférieur au paramètre de simulation <emphasis>reltol</emphasis>.
123         </para>
124         <para>
125             Ce processus ajoute un temps de calcul significatif à la méthode, mais améliore grandement la stabilité.
126         </para>
127         <para>
128             On peut voir qu'avec les <emphasis>ki</emphasis>, on progresse dans les dérivées de
129             <emphasis>
130                 y<subscript>n</subscript>
131             </emphasis>
132             . Donc avec <emphasis>k3</emphasis>, on approxime
133             <emphasis>
134                 y<superscript>(3)</superscript><subscript>n</subscript>
135             </emphasis>
136             , faisant donc une erreur en
137             <emphasis>
138                 O(h<superscript>4</superscript>)
139             </emphasis>
140             . Mais un choix judicieux des coefficients du calcul des <emphasis>ki</emphasis> (notamment
141             <emphasis>
142                 a<subscript>ij</subscript>
143             </emphasis>
144             ) nous fait gagner un ordre, produisant ainsi une erreur par pas de temps en
145             <emphasis>
146                 O(h<superscript>5</superscript>)
147             </emphasis>
148             .
149         </para>
150         <para>
151             L'erreur totale est donc
152             <emphasis>
153                 nombre de pas * O(h<superscript>5</superscript>)
154             </emphasis>
155             . Et puisque par définition <emphasis>nombre de pas = taille de l'intervalle / h</emphasis>, l'erreur totale est en
156             <emphasis>
157                 O(h<superscript>4</superscript>)
158             </emphasis>
159             .
160         </para>
161         <para>
162             Cette analyse d'erreur a baptisé la méthode <emphasis>Runge-Kutta Implicite 4(5)</emphasis>:
163             <emphasis>
164                 O(h<superscript>5</superscript>)
165             </emphasis>
166             par pas,
167             <emphasis>
168                 O(h<superscript>4</superscript>)
169             </emphasis>
170             au total.
171         </para>
172         <para>
173             Bien que le solveur fonctionne bien pour <link linkend="Simulatemenu_Menu_entries">max step size</link> jusqu'à
174             <emphasis>
175                 10<superscript>-3</superscript>
176             </emphasis>
177             , es erreurs d'arrondi surviennent parfois quand l'on approche
178             <emphasis>
179                 4*10<superscript>-4</superscript>
180             </emphasis>
181             . En effet, le scindage de l'intervalle ne peut pas être effectué correctement et l'on obtient des résultats imprévisibles.
182         </para>
183     </refsection>
184     <refsection>
185         <title>Examples</title>
186         <para>
187             <link type="scilab" linkend="scilab.xcos/xcos/examples/solvers/ODE_Example.zcos">
188                 <inlinemediaobject>
189                     <imageobject>
190                         <imagedata align="center" fileref="../../../examples/solvers/ODE_Example.zcos" valign="middle"/>
191                     </imageobject>
192                 </inlinemediaobject>
193             </link>
194             <scilab:image><![CDATA[
195 loadScicos();
196 loadXcosLibs();
197 importXcosDiagram(SCI + "/modules/xcos/examples/solvers/ODE_Example.zcos");
198 scs_m.props.tol(2) = 10^-5;
199 scs_m.props.tol(6) = 7;
200 scs_m.props.tol(7) = 10^-2;
201 try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
202 ]]></scilab:image>
203         </para>
204         <para>
205             Le bloc intégrale retourne son état continu, on peut l'évaluer avec <emphasis>RK implicite</emphasis> en lançant l'exemple :
206         </para>
207         <para>
208             <programlisting language="example"><![CDATA[
209       // Import du diagramme et réglage du temps final
210       loadScicos();
211       loadXcosLibs();
212       importXcosDiagram("SCI/modules/xcos/examples/solvers/ODE_Example.zcos");
213       scs_m.props.tf = 5000;
214
215       // Sélection de RK implicite et réglage de la précision
216       scs_m.props.tol(2) = 10^-10;
217       scs_m.props.tol(6) = 7;
218       scs_m.props.tol(7) = 10^-2;
219
220       // Lancement du chrono, de la simulation et affichage du temps
221       tic();
222       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
223       t = toc();
224       disp(t, "Temps pour Runge-Kutta implicite :");
225       ]]></programlisting>
226         </para>
227         <para>
228             La console Scilab affiche :
229             <screen><![CDATA[
230 Temps pour Runge-Kutta implicite :
231  8.911
232             ]]></screen>
233         </para>
234         <para>
235             Maintenant, dans le script suivant, on compare la différence de temps entre <emphasis>RK implicite</emphasis> et <emphasis>CVode</emphasis> en lançant l'exemple avec les cinq solveurs tour à tour :
236             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integImpRK.sce">
237                 Ouverture du script
238             </link>
239         </para>
240         <para>
241             <screen><![CDATA[
242 Temps pour BDF / Newton :
243  18.894
244
245 Temps pour BDF / Functional :
246  18.382
247
248 Temps pour Adams / Newton :
249  10.368
250
251 Temps pour Adams / Functional :
252  9.815
253
254 Temps pour Runge-Kutta implicite :
255  6.652
256             ]]></screen>
257         </para>
258         <para>
259             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>RK implicite</emphasis> est plus rapide.
260         </para>
261     </refsection>
262     <refsection>
263         <title>Voir Aussi</title>
264         <simplelist type="inline">
265             <member>
266                 <link linkend="LSodar">LSodar</link>
267             </member>
268             <member>
269                 <link linkend="CVode">CVode</link>
270             </member>
271             <member>
272                 <link linkend="IDA">IDA</link>
273             </member>
274             <member>
275                 <link linkend="RK">Runge-Kutta 4(5)</link>
276             </member>
277             <member>
278                 <link linkend="DoPri">Dormand-Prince 4(5)</link>
279             </member>
280             <member>
281                 <link linkend="DDaskr">DDaskr</link>
282             </member>
283             <member>
284                 <link linkend="Comparaisons">Comparaisons</link>
285             </member>
286             <member>
287                 <link linkend="ode_discrete">ode_discrete</link>
288             </member>
289             <member>
290                 <link linkend="ode_root">ode_root</link>
291             </member>
292             <member>
293                 <link linkend="odedc">odedc</link>
294             </member>
295             <member>
296                 <link linkend="impl">impl</link>
297             </member>
298         </simplelist>
299     </refsection>
300     <refsection>
301         <title>Bibliographie</title>
302         <para>
303             Journal of Computational Physics, Volume 233, Janvier 2013, Pages 315-323 <ulink url="http://dl.acm.org/citation.cfm?id=2397727.2397975&amp;coll=DL&amp;dl=GUIDE&amp;CFID=295003167&amp;CFTOKEN=37159263">A low-dispersion and low-dissipation implicit Runge-Kutta scheme</ulink>
304         </para>
305         <para>
306             <ulink url="https://computation.llnl.gov/casc/sundials/documentation/documentation.html">Documentation Sundials</ulink>
307         </para>
308     </refsection>
309     <refsection>
310         <title>Histoire</title>
311         <revhistory>
312             <revision>
313                 <revnumber>5.4.1</revnumber>
314                 <revdescription>Runge-Kutta Implicite 4(5) ajouté</revdescription>
315             </revision>
316         </revhistory>
317     </refsection>
318 </refentry>