<< numderivative Intégration - dérivation ode_discrete >>

Scilab Help >> Intégration - dérivation > ode

ode

solveur d'équations différentielles ordinaires

Syntaxe

y=ode(y0,t0,t,f)
[y,w,iw]=ode([type],y0,t0,t [,rtol [,atol]],f [,jac] [,w,iw])
[y,rd,w,iw]=ode("root",y0,t0,t [,rtol [,atol]],f [,jac],ng,g [,w,iw])
y=ode("discrete",y0,k0,kvect,f)

Paramètres

y0

vecteur ou matrice réelle (conditions initiales).

t0

réel (instant initial).

t

vecteur réel (instants où la solution est renvoyée).

f

fonction externe (fonction Scilab ou chaîne de caractères ou liste).

type

une des chaînes de caractères : "adams", "stiff", "rk", "rkf", "fix", "discrete", "root"

atol, rtol

tolérances absolue et relative sur les valeurs de la solution y (décimaux). Si atol ou rtol est un scalaire, sa valeur est utilisée pour chaque composante de y. Sinon, elle doit être un vecteur de taille size(y), et est appliquée aux composantes respectives de y.

jac

fonction externe (fonction Scilab, chaîne de caractères ou liste).

ng

entier

g

fonction externe (fonction Scilab, chaîne de caractères ou liste).

k0

entier (instant initial).

kvect

vecteur d'entiers.

y

vecteur ou matrice réel: la solution.

rd

vecteur de réels.

w, iw

vecteurs de réels. Voir les options de sortie de ode().

Description

ode est la fonction utilisée pour approcher la solution d'une équation différentielle ordinaire (EDO) explicite du premier ordre en temps, définie par : dy/dt=f(t,y) , y(t0)=y0. Il s'agit d'une interface vers diverses bibliothèques, en particulier ODEPACK. Le type du problème et la méthode utilisée dépendent de la valeur du premier argument optionnel type qui peut être égal à :

<aucun> :

le solveur lsoda du package ODEPACK est utilisé par défaut. Il choisit automatiquement entre un schéma prédicteur-correcteur d'Adams et un schéma adapté au systèmes raides (stiff) de type "Backward Differentiation Formula" (BDF). Initialement le schéma adapté aux système non raides est choisi puis la méthode adaptée est ensuite choisie dynamiquement.

"adams" :

Problèmes non raides. Le solveur lsode du package ODEPACK est utilisé (schéma d'Adams).

"stiff" :

Pour les systèmes raides. Le solveur lsode du package ODEPACK est utilisé avec le schéma BDF.

"rk" :

Schéma de Runge-Kutta adaptatif d'ordre 4 (RK4).

"rkf" :

Formules de Shampine et Watts basées sur les paires de Runge-Kutta Fehlberg d'ordre 4 et 5 (RKF45). Bien pour les problèmes non raides ou moyennement raides, lorsque le calcul du second membre n'est pas trop coûteux. Cette méthode est à éviter si l'on recherche une très grande précision.

"fix":

Identique à "rkf", mais l'interface est simplifiée, i.e. uniquement rtol et atol sont communiqués au solveur.

"root":

Solveur d'EDO avec recherche de racines. Le solveur lsodar du package ODEPACK est utilisé. C'est une variante de lsoda permettant la recherche d'une racine d'une fonction vectorielle donnée. Voir ode_root pour plus de détails.

"discrete":

Simulation en temps discret. Voir ode_discrete pour plus de détails.

Ici on ne décrit l'usage de ode que pour des EDO explicites.

Exemples

// ---------- EDO Simple  (external : fonction Scilab)
// dy/dt=y^2-y sin(t)+cos(t), y(0)=0
function ydot=f(t, y),ydot=y^2-y*sin(t)+cos(t),endfunction
y0=0;t0=0;t=0:0.1:%pi;
y=ode(y0,t0,t,f)
plot(t,y)

// ---------- EDO Simple  (external : code C)
ccode=['#include <math.h>'
       'void myode(int *n,double *t,double *y,double *ydot)'
       '{'
       '  ydot[0]=y[0]*y[0]-y[0]*sin(*t)+cos(*t);'
       '}']
mputl(ccode,TMPDIR+'/myode.c') //create the C file
cd TMPDIR
ilib_for_link('myode','myode.c',[],'c',[],'loader.sce');//compile
exec('loader.sce') //incremental linking
y0=0;t0=0;t=0:0.1:%pi;
y=ode(y0,t0,t,'myode');

// ---------- Simulation de dx/dt = A x(t) + B u(t) avec u(t)=sin(omega*t),
// x0=[1;0]
// solution x(t) desired at t=0.1, 0.2, 0.5 ,1.
// A and u function are passed to RHS function in a list.
// B and omega are passed as global variables
function xdot=linear(t, x, A, u),xdot=A*x+B*u(t),endfunction
function ut=u(t),ut=sin(omega*t),endfunction
A=[1 1;0 2];B=[1;1];omega=5;
ode([1;0],0,[0.1,0.2,0.5,1],list(linear,A,u))

// ----------Integration de l'équation différentielle de Riccati (état matriciel)
// Xdot=A'*X + X*A - X'*B*X + C , X(0)=Identity
// Solution at t=[1,2]
function Xdot=ric(t, X),Xdot=A'*X+X*A-X'*B*X+C,endfunction
A=[1,1;0,2]; B=[1,0;0,1]; C=[1,0;0,1];
t0=0;t=0:0.1:%pi;
X=ode(eye(A),0,t,ric)

// ---------- Calcul de exp(A)  (état matriciel)
A=[1,1;0,2];
function xdot=f(t, x),xdot=A*x;,endfunction
ode(eye(A),0,1,f)
ode("adams",eye(A),0,1,f)

// ----------  Calcul de exp(A)  (état matriciel, cas raide, jacobien fourni)
A=[10,0;0,-1];
function xdot=f(t, x),xdot=A*x,endfunction
function J=Jacobian(t, y),J=A,endfunction
ode("stiff",[0;1],0,1,f,Jacobian)

Voir aussi

Bibliographie

Alan C. Hindmarsh, lsode and lsodi, two new initial value ordinary differential equation solvers, acm-signum newsletter, vol. 15, no. 4 (1980), pp. 10-11.

Fonctions Utilisées

Les sous-programmes associés se trouvent dans le répertoire SCI/modules/differential_equations/src/fortran/: lsode.f lsoda.f lsodar.f


Report an issue
<< numderivative Intégration - dérivation ode_discrete >>