Differential_equations help: fix dae tolerances 98/12598/4
Paul BIGNIER [Thu, 19 Sep 2013 13:48:24 +0000 (15:48 +0200)]
When the user gives only one tolerance, the gateway and the source file take it as the absolute tolerance,
but the help page took it as the relative tolerance.

Added french doc for dae.

Change-Id: I09d9cd554776637b3098b0b5a7078ced99a3b1b1

scilab/modules/differential_equations/help/en_US/dae.xml
scilab/modules/differential_equations/help/fr_FR/dae.xml [new file with mode: 0644]

index a6deec6..9762ad2 100644 (file)
     <refsynopsisdiv>
         <title>Calling Sequence</title>
         <synopsis> y = dae(initial, t0, t, res)
-            [y [,hd]] = dae(initial, t0, t [,rtol, [atol]], res [,jac] [,hd])
+            [y [,hd]] = dae(initial, t0, t [[,rtol], atol], res [,jac] [,hd])
             [y, rd] = dae("root", initial, t0, t, res, ng, surface)
-            [y, rd [,hd]] = dae("root", initial, t0, t [,rtol, [atol]], res [,jac], ng, surface [,hd])
+            [y, rd [,hd]] = dae("root", initial, t0, t [[,rtol], atol], res [,jac], ng, surface [,hd])
             [y, rd] = dae("root2", initial, t0, t, res, ng, surface)
-            [y, rd [,hd]] = dae("root2", initial, t0, t [,rtol, [atol]], res [,jac], ng, surface [, psol, pjac] [, hd])
+            [y, rd [,hd]] = dae("root2", initial, t0, t [[,rtol], atol], res [,jac], ng, surface [, psol, pjac] [, hd])
         </synopsis>
     </refsynopsisdiv>
     <refsection>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>rtol</term>
+                <term>atol</term>
                 <listitem>
-                    <para>
-                        a real scalar or a column vector of same size as
-                        <literal>x0</literal>, the relative error
-                        tolerance of solution. If <literal>rtol</literal> is a vector the
+                    <para>a real scalar or a column vector of same size as
+                        <literal>x0</literal>, the absolute error
+                        tolerance of solution. If <literal>atol</literal> is a vector the
                         tolerances are specified for each component of the state.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>atol</term>
+                <term>rtol</term>
                 <listitem>
-                    <para>a real scalar or a column vector of same size as
-                        <literal>x0</literal>, the absolute error
-                        tolerance of solution. If <literal>atol</literal> is a vector the
+                    <para>
+                        a real scalar or a column vector of same size as
+                        <literal>x0</literal>, the relative error
+                        tolerance of solution. If <literal>rtol</literal> is a vector the
                         tolerances are specified for each component of the state.
                     </para>
                 </listitem>
@@ -86,7 +86,7 @@
                 <term>res</term>
                 <listitem>
                     <para>
-                        an <link linkend="external" role="" version="">external</link> function computes the value of
+                        an <link linkend="external" role="" version="">external</link> function, computes the value of
                         <literal>g(t,y,ydot)</literal>. It may be
                     </para>
                     <variablelist>
@@ -140,8 +140,8 @@ r=res(t,y,ydot,p1,p2,...)
                             <term>a character string</term>
                             <listitem>
                                 <para>
-                                    it must refer to the name of a C or fortran routine,
-                                    assuming that &lt;<literal>r_name</literal>&gt; is the given name.
+                                    it must refer to the name of a C or Fortran routine.
+                                    Assuming that &lt;<literal>r_name</literal>&gt; is the given name,
                                 </para>
                                 <itemizedlist>
                                     <listitem>
@@ -161,7 +161,9 @@ r=res(t,y,ydot,p1,p2,...)
                                         </para>
                                     </listitem>
                                     <listitem>
-                                        <para>The C calling sequence must be</para>
+                                        <para>
+                                            The C calling sequence must be
+                                        </para>
                                         <para>
                                             <literal>C2F(&lt;r_name&gt;)(double *t, double *x, double
                                                 *xdot, double *res, integer *ires, double *rpar, integer
@@ -224,7 +226,7 @@ r=res(t,y,ydot,p1,p2,...)
                 <term>jac</term>
                 <listitem>
                     <para>
-                        an <link linkend="external">external</link> computes the value of
+                        an <link linkend="external">external</link>, computes the value of
                         <literal>dg/dx+cj*dg/dxdot</literal> for a given value of parameter
                         <literal>cj</literal>. It may be
                     </para>
@@ -265,8 +267,8 @@ r=jac(t,x,xdot,p1,p2,...)
                         <varlistentry>
                             <term>a character string</term>
                             <listitem>
-                                <para>it must refer to the name of a C or fortran routine
-                                    assuming that &lt;j_name&gt; is the given name.
+                                <para>it must refer to the name of a C or Fortran routine.
+                                    Assuming that &lt;j_name&gt; is the given name,
                                 </para>
                                 <itemizedlist>
                                     <listitem>
@@ -288,7 +290,9 @@ r=jac(t,x,xdot,p1,p2,...)
                                         </para>
                                     </listitem>
                                     <listitem>
-                                        <para>The C calling sequence must be</para>
+                                        <para>
+                                            The C calling sequence must be
+                                        </para>
                                         <para>
                                             <literal>C2F(&lt;j_name&gt;)(double *t, double *x, double
                                                 *xdot, double *r, double *cj, integer *ires, double *rpar, integer *ipar)
@@ -310,7 +314,7 @@ r=jac(t,x,xdot,p1,p2,...)
                 <term>surface</term>
                 <listitem>
                     <para>
-                        an <link linkend="external">external</link> computes the value of the column vector
+                        an <link linkend="external">external</link>, computes the value of the column vector
                         <literal>surface(t,x)</literal> with <literal>ng</literal>
                         components. Each component defines a surface.
                     </para>
@@ -345,15 +349,13 @@ r=surface(t,x,p1,p2,...)
                         <varlistentry>
                             <term>a character string</term>
                             <listitem>
-                                <para>it must refer to the name of a C or fortran routine.
+                                <para>it must refer to the name of a C or Fortran routine.
                                     Assuming that &lt;s_name&gt; is the given name,
                                 </para>
                                 <itemizedlist>
                                     <listitem>
                                         <para>
-                                            <literal>The Fortran calling sequence must
-                                                be
-                                            </literal>
+                                            The Fortran calling sequence must be
                                         </para>
                                         <para>
                                             <literal>&lt;s_name&gt;(nx, t, x, ng, r, rpar,
@@ -370,7 +372,9 @@ r=surface(t,x,p1,p2,...)
                                         </para>
                                     </listitem>
                                     <listitem>
-                                        <para>The C calling sequence must be</para>
+                                        <para>
+                                            The C calling sequence must be
+                                        </para>
                                         <para>
                                             <literal>C2F(&lt;s_name&gt;)(double *t, double *x, double
                                                 *xdot, double *r, double *cj, integer *ires, double *rpar, integer *ipar)
@@ -382,7 +386,7 @@ r=surface(t,x,p1,p2,...)
                                     where <literal>t, x, rpar, ipar</literal> have similar
                                     definition as above, <literal>ng</literal> is the number of
                                     surfaces, <literal>nx</literal> the dimension of the state and
-                                    r is the results array.
+                                    <literal>r</literal> is the results array.
                                 </para>
                             </listitem>
                         </varlistentry>
@@ -435,7 +439,7 @@ r=surface(t,x,p1,p2,...)
                         </literal>
                         ,
                         each column is the vector <literal>[t;x(t);xdot(t)]</literal> where
-                        <literal>t</literal> is time index for which the solution had been
+                        <literal>t</literal> is time index for which the solution has been
                         computed. Else <literal>y</literal> is the vector
                         <literal>[x(t);xdot(t)]</literal>.
                     </para>
@@ -465,7 +469,7 @@ x(t0) = x0 and xdot(t0) = xdot0
             <literal>g(t,x0,xdot0)=0</literal>.
         </para>
         <para>
-            if <literal>xdot0</literal> is given in the <emphasis>initial</emphasis>
+            If <literal>xdot0</literal> is given in the <emphasis>initial</emphasis>
             argument it may be either a compatible derivative
             satisfying <literal>g(t,x0,xdot0)=0</literal> or an approximate value. In the latter case
             <link linkend="daeoptions">%DAEOPTIONS</link>(7) must be set to 1.
diff --git a/scilab/modules/differential_equations/help/fr_FR/dae.xml b/scilab/modules/differential_equations/help/fr_FR/dae.xml
new file mode 100644 (file)
index 0000000..78a57d9
--- /dev/null
@@ -0,0 +1,740 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises - Paul Bignier : added "roots2" (daskr)
+ * Copyright (C) 2008 - INRIA
+ * ...
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="dae" xml:lang="en">
+    <refnamediv>
+        <refname>dae</refname>
+        <refpurpose>Solveur de système d'Equations Différentielles Algébriques</refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Séquence d'appel</title>
+        <synopsis> y = dae(initial, t0, t, res)
+            [y [,hd]] = dae(initial, t0, t [[,rtol], atol], res [,jac] [,hd])
+            [y, rd] = dae("root", initial, t0, t, res, ng, surface)
+            [y, rd [,hd]] = dae("root", initial, t0, t [[,rtol], atol], res [,jac], ng, surface [,hd])
+            [y, rd] = dae("root2", initial, t0, t, res, ng, surface)
+            [y, rd [,hd]] = dae("root2", initial, t0, t [[,rtol], atol], res [,jac], ng, surface [, psol, pjac] [, hd])
+        </synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Paramètres</title>
+        <variablelist>
+            <varlistentry>
+                <term>initial</term>
+                <listitem>
+                    <para>
+                        vecteur colonne. Peut valoir <literal>x0</literal> ou
+                        <literal>[x0;xdot0]</literal>, où <literal>x0</literal> est la
+                        valeur de l'état au temps initial <literal>t0</literal> et
+                        <literal>xdot0</literal> est la valeur (ou une estimation)
+                        de l'état dérivé au temps initial (voir ci-après).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t0</term>
+                <listitem>
+                    <para>réel, le temps initial.</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>scalaire ou vecteur réel. Les instants auxquels la solution est voulue.
+                        La solution peut s'obtenir à chaque étape de dae en initialisant
+                        <literal>
+                            <link linkend="daeoptions">%DAEOPTIONS</link>(2)=1
+                        </literal>
+                        .
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>atol</term>
+                <listitem>
+                    <para>
+                        un scalaire ou vecteur colonne réel de même taille que
+                        <literal>x0</literal>, la tolérance absolue de la solution.
+                        Si <literal>atol</literal> est un vecteur, les tolérances
+                        sont spécifiées pour chaque composante de l'état.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>rtol</term>
+                <listitem>
+                    <para>
+                        un scalaire ou vecteur colonne réel de même taille que
+                        <literal>x0</literal>, la tolérance relative de la solution.
+                        Si <literal>atol</literal> est un vecteur, les tolérances
+                        sont spécifiées pour chaque composante de l'état.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>res</term>
+                <listitem>
+                    <para>
+                        une fonction <link linkend="external" role="" version="">external</link>, calcule la valeur de
+                        <literal>g(t,y,ydot)</literal>. Peut être
+                    </para>
+                    <variablelist>
+                        <varlistentry>
+                            <term>une fonction Scilab</term>
+                            <listitem>
+                                <para>Dans ce cas, sa séquence d'appel doit être
+                                    <literal>[r,ires]=res(t,x,xdot)</literal> et
+                                    <literal>res</literal> doit retourner le résidu
+                                    <literal>r=g(t,x,xdot)</literal> et un drapeau d'erreur
+                                    <literal>ires</literal>.
+                                </para>
+                                <para>
+                                    <literal>ires = 0</literal> si
+                                    <literal>res</literal> est bien parvenu à calculer
+                                    <literal>r</literal>.
+                                </para>
+                                <para>
+                                    <literal>ires = -1</literal> si le résidu est
+                                    localement non-défini pour <literal>g(t,x,xdot)</literal>.
+                                </para>
+                                <para>
+                                    <literal>ires =-2</literal> si le paramètres ne sont pas admissibles.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>une liste</term>
+                            <listitem>
+                                <para>
+                                    Cette forme d'<link linkend="external">external</link> sert à passer des paramètres à la fonction.
+                                    Elle doit se présenter comme suit:
+                                </para>
+                                <programlisting role="no-scilab-exec"><![CDATA[
+list(res,p1,p2,...)
+ ]]></programlisting>
+                                <para>où la séquence d'appel de la fonction
+                                    <literal>res</literal> est
+                                </para>
+                                <programlisting role="no-scilab-exec"><![CDATA[
+r=res(t,y,ydot,p1,p2,...)
+ ]]></programlisting>
+                                <para>
+                                    <literal>res</literal> retourne toujours le résidu comme fonction de
+                                    <literal>(t,x,xdot,x1,x2,...)</literal>, et
+                                    <literal>p1, p2,...</literal> sont des paramètres de la fonction.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>une chaîne de caractères</term>
+                            <listitem>
+                                <para>
+                                    Elle doit se référer au nom d'une routine C ou Fortran.
+                                    Supposant que &lt;<literal>r_name</literal>&gt; est le nom donné,
+                                </para>
+                                <itemizedlist>
+                                    <listitem>
+                                        <para>
+                                            La séquence d'appel en Fortran doit être
+                                        </para>
+                                        <para>
+                                            <literal>&lt;r_name&gt;(t,x,xdot,res,ires,rpar,ipar)</literal>
+                                        </para>
+                                        <para>
+                                            <literal>double precision
+                                                t,x(*),xdot(*),res(*),rpar(*)
+                                            </literal>
+                                        </para>
+                                        <para>
+                                            <literal>integer ires,ipar(*)</literal>
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            La séquence d'appel en C doit être
+                                        </para>
+                                        <para>
+                                            <literal>C2F(&lt;r_name&gt;)(double *t, double *x, double
+                                                *xdot, double *res, integer *ires, double *rpar, integer
+                                                *ipar)
+                                            </literal>
+                                        </para>
+                                    </listitem>
+                                </itemizedlist>
+                                <para>où</para>
+                                <itemizedlist>
+                                    <listitem>
+                                        <para>
+                                            <literal>t</literal> est la valeur actuelle du temps
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            <literal>x</literal> est la valeur de l'état
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            <literal>xdot</literal> est la valeur de l'état dérivé
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            <literal>res</literal> la valeur du résidu
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            <literal>ires</literal> indicateur de complétion
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            <literal>rpar</literal> est un vecteur de paramètres nécéssaires
+                                            mais non initialisables par <literal>dae</literal>.
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            <literal>ipar</literal> est un vecteur de paramètres entiers
+                                            nécéssaires mais non initialisables par <literal>dae</literal>
+                                        </para>
+                                    </listitem>
+                                </itemizedlist>
+                            </listitem>
+                        </varlistentry>
+                    </variablelist>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>jac</term>
+                <listitem>
+                    <para>
+                        une fonction <link linkend="external">external</link>, calcule la valeur de
+                        <literal>dg/dx+cj*dg/dxdot</literal> pour un paramètre
+                        <literal>cj</literal> donné. Elle peut être:
+                    </para>
+                    <variablelist>
+                        <varlistentry>
+                            <term>une fonction Scilab</term>
+                            <listitem>
+                                <para>Sa séquence d'appel doit être
+                                    <literal>r=jac(t,x,xdot,cj)</literal> et la fonction
+                                    <literal>jac</literal> doit retourner
+                                    <literal>r=dg(t,x,xdot)/dy+cj*dg(t,x,xdot)/dxdot</literal>
+                                    où <literal>cj</literal> est un scalaire réel.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>une liste</term>
+                            <listitem>
+                                <para>
+                                    Cette forme d'<link linkend="external">external</link> est utilisée pour passer des paramètres à la fonction.
+                                    Elle doit se présenter comme suit :
+                                </para>
+                                <programlisting role="no-scilab-exec"><![CDATA[
+list(jac,p1,p2,...)
+ ]]></programlisting>
+                                <para>où la séquence d'appel de la fonction
+                                    <literal>jac</literal> est
+                                </para>
+                                <programlisting role="no-scilab-exec"><![CDATA[
+r=jac(t,x,xdot,p1,p2,...)
+ ]]></programlisting>
+                                <para>
+                                    <literal>jac</literal> retourne toujours
+                                    <literal>dg/dx+cj*dg/dxdot</literal> comme fonction de
+                                    <literal>(t,x,xdot,cj,p1,p2,...)</literal>.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>une chaîne de caractères</term>
+                            <listitem>
+                                <para>elle doit se référer au nom d'une routine C ou Fortran.
+                                    Supposant que &lt;j_name&gt; est le nom donné,
+                                </para>
+                                <itemizedlist>
+                                    <listitem>
+                                        <para>
+                                            La séquence d'appel en Fortran doit être
+                                        </para>
+                                        <para>
+                                            <literal>&lt;j_name&gt;(t, x, xdot, r, cj, ires,
+                                                rpar, ipar)
+                                            </literal>
+                                        </para>
+                                        <para>
+                                            double precision <literal>t, x(*), xdot(*), r(*),
+                                                ci, rpar(*)
+                                            </literal>
+                                        </para>
+                                        <para>
+                                            integer <literal>ires, ipar(*)</literal>
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            La séquence d'appel en C doit être
+                                        </para>
+                                        <para>
+                                            <literal>C2F(&lt;j_name&gt;)(double *t, double *x, double
+                                                *xdot, double *r, double *cj, integer *ires, double *rpar, integer *ipar)
+                                            </literal>
+                                        </para>
+                                    </listitem>
+                                </itemizedlist>
+                                <para>
+                                    où <literal>t, x, xdot, ires, rpar, ipar</literal>
+                                    ont la même définition qu'au-dessus, <literal>r</literal>
+                                    est la valeur du résultat
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                    </variablelist>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>surface</term>
+                <listitem>
+                    <para>
+                        une fonction <link linkend="external">external</link>, calcule a valeur du vecteur colonne
+                        <literal>surface(t,x)</literal> à <literal>ng</literal> éléments.
+                        Chaque élément définit une surface. Elle peut être
+                    </para>
+                    <variablelist>
+                        <varlistentry>
+                            <term>une fonction Scilab</term>
+                            <listitem>
+                                <para>Sa séquence d'appel doit être
+                                    <literal>r=surface(t,x)</literal>, cette fonction doit retourner
+                                    un vecteur colonne à <literal>ng</literal> éléments.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>une liste</term>
+                            <listitem>
+                                <para>
+                                    Cette forme d'<link linkend="external">external</link> est utilisé pour
+                                    passer des paramètres à la fonction.
+                                    Elle doit se présenter comme suit :
+                                </para>
+                                <programlisting role="no-scilab-exec"><![CDATA[
+list(surface,p1,p2,...)
+ ]]></programlisting>
+                                <para>où la qéquence d'appel de la fonction
+                                    <literal>surface</literal> est
+                                </para>
+                                <programlisting role="no-scilab-exec"><![CDATA[
+r=surface(t,x,p1,p2,...)
+ ]]></programlisting>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>une chaîne de caractères</term>
+                            <listitem>
+                                <para>elle doit se référer au nom d'une routine C ou Fortran.
+                                    Supposant que &lt;s_name&gt; est le nom donné,
+                                </para>
+                                <itemizedlist>
+                                    <listitem>
+                                        <para>
+                                            La séquence d'appel en Fortran doit être
+                                        </para>
+                                        <para>
+                                            <literal>&lt;s_name&gt;(nx, t, x, ng, r, rpar,
+                                                ipar)
+                                            </literal>
+                                        </para>
+                                        <para>
+                                            <literal>double precision t, x(*), r(*),
+                                                rpar(*)
+                                            </literal>
+                                        </para>
+                                        <para>
+                                            <literal>integer nx, ng,ipar(*)</literal>
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            La séquence d'appel en C doit être
+                                        </para>
+                                        <para>
+                                            <literal>C2F(&lt;s_name&gt;)(double *t, double *x, double
+                                                *xdot, double *r, double *cj, integer *ires, double *rpar, integer *ipar)
+                                            </literal>
+                                        </para>
+                                    </listitem>
+                                </itemizedlist>
+                                <para>
+                                    où <literal>t, x, rpar, ipar</literal> ont les mêmes définitions qu'au-dessus,
+                                    <literal>ng</literal> est le nombre de surfaces,
+                                    <literal>nx</literal> est la dimension de l'état et
+                                    <literal>r</literal> est le vecteur résultat.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                    </variablelist>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>rd</term>
+                <listitem>
+                    <para>
+                        un vecteur à deux entrées <literal>[times num]</literal> où
+                        <literal>times</literal> est la valeur des temps auquel les surfaces sont traversées,
+                        <literal>num</literal> est le nombre de surfaces traversées.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>pjac</term>
+                <listitem>
+                    <para>
+                        external (fonction, liste or chaîne de caractères). Voir <link linkend="daskr">daskr</link>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>psol</term>
+                <listitem>
+                    <para>
+                        external (fonction, liste or chaîne de caractères). Voir <link linkend="daskr">daskr</link>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>hd</term>
+                <listitem>
+                    <para>vecteur réel, stocke en sortie le contexte de
+                        <literal>dae</literal>. Peut être utilisé comme paramètre d'entrée
+                        pour reprendre l'intégration (reprise à chaud).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>y</term>
+                <listitem>
+                    <para>
+                        matrice réelle. Si
+                        <literal>
+                            <link linkend="daeoptions">%DAEOPTIONS</link>(2)=1
+                        </literal>
+                        ,
+                        chaque colonne est le vecteur <literal>[t;x(t);xdot(t)]</literal> où
+                        <literal>t</literal> est le temps auquel la solution à été calculée.
+                        Sinon <literal>y</literal> est le vecteur
+                        <literal>[x(t);xdot(t)]</literal>.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            La fonction <literal>dae</literal> est une gateway construite sur les solveurs
+            <link linkend="dassl">dassl</link>, <link linkend="dasrt">dasrt</link>
+            et <link linkend="daskr">daskr</link>
+            destinés à l'intégration implicite d'équations différentielles.
+        </para>
+        <para>
+            L'option <literal>"root"</literal> appelle la routine <link linkend="dasrt">dasrt</link>,
+            et <literal>"root2"</literal> appelle <link linkend="dasrt">daskr</link>.
+        </para>
+        <programlisting role="no-scilab-exec"><![CDATA[
+g(t, x, xdot) = 0
+x(t0) = x0 and xdot(t0) = xdot0
+ ]]></programlisting>
+        <para>
+            Si <literal>xdot0</literal> n'est pas donné en paramètre initial,
+            <literal>dae</literal> tente de la calculer en résolvant
+            <literal>g(t,x0,xdot0)=0</literal>.
+        </para>
+        <para>
+            Si <literal>xdot0</literal> est donné en paramètre initial, il peut soit
+            satifaire <literal>g(t,x0,xdot0)=0</literal>, soit en être une approximation.
+            Dans le dernier cas,
+            <link linkend="daeoptions">%DAEOPTIONS</link>(7) doit être initialisé à 1.
+        </para>
+        <para>Des exemples détaillés utilisant des externals codées en C et en Scilab se trouvent dans
+            <literal>modules/differential_equations/tests/unit_tests/dassldasrt.tst</literal> et
+            <literal>modules/differential_equations/tests/unit_tests/daskr.tst</literal>
+        </para>
+    </refsection>
+    <refsection>
+        <title>Exemples</title>
+        <para>
+            Exemple #1: dassl (pas de traversée de surface)
+        </para>
+        <programlisting role="example"><![CDATA[
+// Exemple avec du code Scilab
+--------------------------------------------------
+function [r, ires] = chemres(t, y, yd)
+    r(1) = -0.04*y(1) + 1d4*y(2)*y(3) - yd(1);
+    r(2) =  0.04*y(1) - 1d4*y(2)*y(3) - 3d7*y(2)*y(2) - yd(2);
+    r(3) =       y(1) +     y(2)      + y(3)-1;
+    ires =  0;
+endfunction
+
+function pd = chemjac(x, y, yd, cj)
+    pd = [-0.04-cj , 1d4*y(3)               , 1d4*y(2);
+           0.04    ,-1d4*y(3)-2*3d7*y(2)-cj ,-1d4*y(2);
+           1       , 1                      , 1       ]
+endfunction
+
+x0 = [1; 0; 0];
+xd0 = [-0.04; 0.04; 0];
+t = [1.d-5:0.02:.4, 0.41:.1:4, 40, 400, 4000, 40000, 4d5, 4d6, 4d7, 4d8, 4d9, 4d10];
+
+y = dae([x0, xd0], 0, t, chemres); // Retourne les points d'observation demandés
+
+%DAEOPTIONS = list([], 1, [], [], [], 0, 0); // Demande à dae les points à retourner
+y = dae([x0, xd0], 0, 4d10, chemres); // Sans jacobian
+y = dae([x0, xd0], 0, 4d10, chemres, chemjac); // Avec jacobien
+ ]]></programlisting>
+        <para>
+            Exemple #2: dasrt ("root")
+        </para>
+        <programlisting role="example"><![CDATA[
+// Exemple avec du code C (compilateur C requis)
+--------------------------------------------------
+bOK = haveacompiler();
+if bOK <> %t
+    [btn] = messagebox(["Vous avez besoin nd'un compilateur C pour cet exemple."; "Arrêt de l'exécution."], "Problème de Software", 'info');
+    return
+end
+
+//-1- Crée les codes C dans TMPDIR - équation de Vanderpol, forme implicite
+code = ['#include <math.h>'
+      'void res22(double *t, double *y, double *yd, double *res, int *ires, double *rpar, int *ipar)'
+      '{res[0] = yd[0] - y[1];'
+      ' res[1] = yd[1] - (100.0*(1.0 - y[0]*y[0])*y[1] - y[0]);}'
+      ' '
+      'void jac22(double *t, double *y, double *yd, double *pd, double *cj, double *rpar, int *ipar)'
+      '{pd[0] = *cj - 0.0;'
+      ' pd[1] =     - (-200.0*y[0]*y[1] - 1.0);'
+      ' pd[2] =     - 1.0;'
+      ' pd[3] = *cj - (100.0*(1.0 - y[0]*y[0]));}'
+      ' '
+      'void gr22(int *neq, double *t, double *y, int *ng, double *groot, double *rpar, int *ipar)'
+      '{ groot[0] = y[0];}']
+previous_dir = pwd();
+cd TMPDIR;
+mputl(code, 't22.c')
+
+//-2- Compile et charge
+ilib_for_link(['res22' 'jac22' 'gr22'], 't22.c', [], 'c', [], 't22loader.sce');
+exec('t22loader.sce')
+
+//-3- Exécute
+rtol = [1.d-6; 1.d-6];
+atol = [1.d-6; 1.d-4];
+t0 = 0; t = [20:20:200];
+y0 = [2; 0]; y0d = [0; -2];
+ng = 1;
+
+// Simulation simple
+t = 0:0.003:300;
+yy = dae([y0, y0d], t0, t, atol, rtol, 'res22', 'jac22');
+clf(); plot(yy(1, :), yy(2, :))
+// Trouve le premier point où yy(1) = 0
+[yy, nn, hotd] = dae("root", [y0, y0d], t0, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22');
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+
+// Reprise à chaud pour le point suivant
+t01 = nn(1);
+[pp, qq] = size(yy);
+y01 = yy(2:3, qq); y0d1 = yy(3:4, qq);
+[yy, nn, hotd] = dae("root", [y01, y0d1], t01, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22', hotd);
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+cd(previous_dir);
+ ]]></programlisting>
+        <scilab:image><![CDATA[
+code = ['#include <math.h>'
+      'void res22(double *t, double *y, double *yd, double *res, int *ires, double *rpar, int *ipar)'
+      '{res[0] = yd[0] - y[1];'
+      ' res[1] = yd[1] - (100.0*(1.0 - y[0]*y[0])*y[1] - y[0]);}'
+      ' '
+      'void jac22(double *t, double *y, double *yd, double *pd, double *cj, double *rpar, int *ipar)'
+      '{pd[0] = *cj - 0.0;'
+      ' pd[1] =     - (-200.0*y[0]*y[1] - 1.0);'
+      ' pd[2] =     - 1.0;'
+      ' pd[3] = *cj - (100.0*(1.0 - y[0]*y[0]));}'
+      ' '
+      'void gr22(int *neq, double *t, double *y, int *ng, double *groot, double *rpar, int *ipar)'
+      '{ groot[0] = y[0];}']
+previous_dir = pwd();
+cd TMPDIR;
+mputl(code, 't22.c')
+ilib_for_link(['res22' 'jac22' 'gr22'], 't22.c', [], 'c', [], 't22loader.sce');
+exec('t22loader.sce')
+rtol = [1.d-6; 1.d-6];
+atol = [1.d-6; 1.d-4];
+t0 = 0; t = [20:20:200];
+y0 = [2; 0]; y0d = [0; -2];
+ng = 1;
+t = 0:0.003:300;
+yy = dae([y0, y0d], t0, t, atol, rtol, 'res22', 'jac22');
+clf(); plot(yy(1, :), yy(2, :))
+[yy, nn, hotd] = dae("root", [y0, y0d], t0, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22');
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+t01 = nn(1);
+[pp, qq] = size(yy);
+y01 = yy(2:3, qq);
+y0d1 = yy(3:4, qq);
+[yy, nn, hotd] = dae("root", [y01, y0d1], t01, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22', hotd);
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+cd(previous_dir);
+ ]]></scilab:image>
+        <para>
+            Exemple #3: daskr ("root2"), avec les routines 'psol' et 'pjac' par défaut
+        </para>
+        <programlisting role="example"><![CDATA[
+// Exemple avec du code C (compilateur C requis)
+--------------------------------------------------
+bOK = haveacompiler();
+if bOK <> %t
+    [btn] = messagebox(["Vous avez besoin nd'un compilateur C pour cet exemple."; "Arrêt de l'exécution."], "Problème de Software", 'info');
+    return
+end
+
+//-1- Crée les codes C dans TMPDIR - équation de Vanderpol, forme implicite
+code = ['#include <math.h>'
+      'void res22(double *t, double *y, double *yd, double *res, int *ires, double *rpar, int *ipar)'
+      '{res[0] = yd[0] - y[1];'
+      ' res[1] = yd[1] - (100.0*(1.0 - y[0]*y[0])*y[1] - y[0]);}'
+      ' '
+      'void jac22(double *t, double *y, double *yd, double *pd, double *cj, double *rpar, int *ipar)'
+      '{pd[0] = *cj - 0.0;'
+      ' pd[1] =     - (-200.0*y[0]*y[1] - 1.0);'
+      ' pd[2] =     - 1.0;'
+      ' pd[3] = *cj - (100.0*(1.0 - y[0]*y[0]));}'
+      ' '
+      'void gr22(int *neq, double *t, double *y, int *ng, double *groot, double *rpar, int *ipar)'
+      '{ groot[0] = y[0];}']
+previous_dir = pwd();
+cd TMPDIR;
+mputl(code, 't22.c')
+
+//-2- Compile et charge
+ilib_for_link(['res22' 'jac22' 'gr22'], 't22.c', [], 'c', [], 't22loader.sce');
+exec('t22loader.sce')
+
+//-3- Exécute
+rtol = [1.d-6; 1.d-6];
+atol = [1.d-6; 1.d-4];
+t0 = 0; t = [20:20:200];
+y0 = [2; 0]; y0d = [0; -2];
+ng = 1;
+
+// Simulation simple
+t = 0:0.003:300;
+yy = dae([y0, y0d], t0, t, atol, rtol, 'res22', 'jac22');
+clf(); plot(yy(1, :), yy(2, :))
+// Trouve le premier point où yy(1) = 0
+%DAEOPTIONS = list([] , 0, [], [], [], 0, [], 1, [], 0, 1, [], [], 1);
+[yy, nn, hotd] = dae("root2", [y0, y0d], t0, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22', 'psol1', 'pjac1');
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+
+// Reprise à chaud pour le point suivant
+t01 = nn(1);
+[pp, qq] = size(yy);
+y01 = yy(2:3, qq); y0d1 = yy(3:4, qq);
+[yy, nn, hotd] = dae("root2", [y01, y0d1], t01, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22', 'psol1', 'pjac1', hotd);
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+cd(previous_dir);
+ ]]></programlisting>
+        <scilab:image><![CDATA[
+code = ['#include <math.h>'
+      'void res22(double *t, double *y, double *yd, double *res, int *ires, double *rpar, int *ipar)'
+      '{res[0] = yd[0] - y[1];'
+      ' res[1] = yd[1] - (100.0*(1.0 - y[0]*y[0])*y[1] - y[0]);}'
+      ' '
+      'void jac22(double *t, double *y, double *yd, double *pd, double *cj, double *rpar, int *ipar)'
+      '{pd[0] = *cj - 0.0;'
+      ' pd[1] =     - (-200.0*y[0]*y[1] - 1.0);'
+      ' pd[2] =     - 1.0;'
+      ' pd[3] = *cj - (100.0*(1.0 - y[0]*y[0]));}'
+      ' '
+      'void gr22(int *neq, double *t, double *y, int *ng, double *groot, double *rpar, int *ipar)'
+      '{ groot[0] = y[0];}']
+previous_dir = pwd();
+cd TMPDIR;
+mputl(code, 't22.c')
+ilib_for_link(['res22' 'jac22' 'gr22'], 't22.c', [], 'c', [], 't22loader.sce');
+exec('t22loader.sce')
+rtol = [1.d-6; 1.d-6];
+atol = [1.d-6; 1.d-4];
+t0 = 0; t = [20:20:200];
+y0 = [2; 0]; y0d = [0; -2];
+ng = 1;
+t = 0:0.003:300;
+yy = dae([y0, y0d], t0, t, atol, rtol, 'res22', 'jac22');
+clf(); plot(yy(1, :), yy(2, :))
+%DAEOPTIONS = list([], 0, [], [], [], 0, [], 1, [], 0, 1, [], [], 1);
+[yy, nn, hotd] = dae("root2", [y0, y0d], t0, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22', 'psol1', 'pjac1');
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+t01 = nn(1);
+[pp, qq] = size(yy);
+y01 = yy(2:3, qq);
+y0d1 = yy(3:4, qq);
+[yy, nn, hotd] = dae("root2", [y01, y0d1], t01, 300, atol, rtol, 'res22', 'jac22', ng, 'gr22', 'psol1', 'pjac1', hotd);
+plot(yy(1, 1), yy(2, 1), 'r+')
+xstring(yy(1, 1)+0.1, yy(2, 1), string(nn(1)));
+cd(previous_dir);
+ ]]></scilab:image>
+    </refsection>
+    <refsection role="see also">
+        <title>Voir aussi</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="ode">ode</link>
+            </member>
+            <member>
+                <link linkend="daeoptions">daeoptions</link>
+            </member>
+            <member>
+                <link linkend="dassl">dassl</link>
+            </member>
+            <member>
+                <link linkend="dasrt">dasrt</link>
+            </member>
+            <member>
+                <link linkend="daskr">daskr</link>
+            </member>
+            <member>
+                <link linkend="impl">impl</link>
+            </member>
+            <member>
+                <link linkend="fort">fort</link>
+            </member>
+            <member>
+                <link linkend="link">link</link>
+            </member>
+            <member>
+                <link linkend="external">external</link>
+            </member>
+        </simplelist>
+    </refsection>
+</refentry>