<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Scilab ( https://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 2013 - Scilab Enterprises - Paul Bignier : added "roots2" (daskr)
 * Copyright (C) 2008 - INRIA
 * ...
 *
 * Copyright (C) 2012 - 2016 - Scilab Enterprises
 *
 * This file is hereby licensed under the terms of the GNU GPL v2.0,
 * pursuant to article 5.3.4 of the CeCILL v.2.1.
 * This file was originally licensed under the terms of the CeCILL v2.1,
 * and continues to be available under such terms.
 * For more information, see the COPYING file which you should have received
 * along with this program.
 *
 -->
<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="fr">
    <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(y0, t0, t, res)
            [y [,hd]] = dae(y0, t0, t [[,rtol], atol], res [,jac] [,hd])
            [y, rd] = dae("root", y0, t0, t, res, ng, surface)
            [y, rd [,hd]] = dae("root", y0, t0, t [[,rtol], atol], res [,jac], ng, surface [,hd])
            [y, rd] = dae("root2", y0, t0, t, res, ng, surface)
            [y, rd [,hd]] = dae("root2", y0, t0, t [[,rtol], atol], res [,jac], ng, surface [, psol, pjac] [, hd])
        </synopsis>
    </refsynopsisdiv>
    <refsection>
        <title>Paramètres</title>
        <variablelist>
            <varlistentry>
                <term>y0</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>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>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>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>
                                <screen><![CDATA[
list(res, p1, p2,...)
]]></screen>
                                <para>où la séquence d'appel de la fonction
                                    <literal>res</literal> est
                                </para>
                                <screen><![CDATA[
r = res(t, y, ydot, p1, p2,...)
]]></screen>
                                <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>
                                <screen><![CDATA[
list(jac,p1,p2,...)
]]></screen>
                                <para>où la séquence d'appel de la fonction
                                    <literal>jac</literal> est
                                </para>
                                <screen><![CDATA[
r = jac(t,x,xdot,p1,p2,...)
]]></screen>
                                <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>
                                <screen><![CDATA[
list(surface, p1, p2,...)
]]></screen>
                                <para>où la qéquence d'appel de la fonction
                                    <literal>surface</literal> est
                                </para>
                                <screen><![CDATA[
r = surface(t, x, p1, p2,...)
]]></screen>
                            </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>psol</term>
                <listitem>
                    <para>
                        external (fonction, liste or chaîne de caractères).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>pjac</term>
                <listitem>
                    <para>
                        external (fonction, liste or chaîne de caractères).
                    </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> résout l'équation différentielle algébrique et renvoie l'évolution 
            de y à des moments donnés
        </para>
        <screen><![CDATA[
g(t, x, xdot) = 0
x(t0) = x0 and xdot(t0) = xdot0
]]></screen>
        <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: utilise le solveur dasrt avec "root"
        </para>
        <programlisting role="example"><![CDATA[
// Exemple avec du code C (compilateur C requis)
//--------------------------------------------------
bOK = haveacompiler();
if bOK <> %t
    [btn] = messagebox(["Vous avez besoin d''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 localized="false"><![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: utilise le solveur daskr avec le mot-clé "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 d''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="dae_root">dae_root</link>
            </member>
            <member>
                <link linkend="ode">ode</link>
            </member>
            <member>
                <link linkend="daeoptions">daeoptions</link>
            </member>
            <member>
                <link linkend="impl">impl</link>
            </member>
            <member>
                <link linkend="call">call</link>
            </member>
            <member>
                <link linkend="link">link</link>
            </member>
            <member>
                <link linkend="external">external</link>
            </member>
        </simplelist>
    </refsection>
    <refsection>
        <title>History</title>
        <revhistory>
            <revision>
                <revnumber>2024.1.0</revnumber>
                <revremark>
                    dassl, dasrt and daskr deviennent des fonctions internes.
                </revremark>
            </revision>
        </revhistory>
    </refsection>
</refentry>
