odedc

Parâmetros

y0

vetor coluna de reais (condições iniciais), y0=[y0c;y0d] onde y0d tem nd componentes.

nd

inteiro, dimensão de y0d

stdel

vetor de reais com uma ou duas entradas, stdel=[h,delta] (com delta=0 como valor padrão).

t0

escalar real (tempo inicial).

t

vetor (linha de reais), instantes onde yt é calculado .

f

função externa i.e. função, string ou lista com seqüência de chamamento: yp=f(t,yc,yd,flag).

Descrição

y = odedc([y0c;y0d], nd, [h,delta], t0, t, f) computa a solução de um sistema misto contínuo/discreto. O estado de sistema discreto ydk é embutido em uma função de tempo seccional constante yd(t) como segue: yd(t) = ydk para t em [tk = h*(delta+k) , tk+1 = h*(delta+k+1) ).

As equações simuladas são agora para t em [ t_k , t_k+1 ):

dyc/dt = f(t, yc(t), yd(t), 0)
yc(t0) = y0c

e nos instantes tdk a variável discreta yd é atualizada por

yd(tk+) = f(yc(tk-), yd(tk-), 1).

Note que, utilizando a definição de yd(t), a última equação fornece

ydk = f(tk, yc(tk-), yd(tk-1), 1)

(yc é de tempo contínuo : yc(tk-) = yc(tk)).

Os parâmetros de chamada de f são fixados: ycd = f(t,yc,yd,flag); esta função deve retornar a derivada do vetor yc se flag=0 ou a atualização de yd se flag=1.

ycd = dot(yc) deve ser um vetor de mesma dimensão que yc se flag=0 e ycd = update(yd) deve ser um vetor com a mesma dimensão que yd se flag=1.

t é um vetor de constantes onde a solução y é computada.

y é o vetor y = [y(t(1)), y(t(2)),...].

Esta função pode ser chamada com os mesmo parâmetro opcionais da função ode (desde que nd e stdel sejam dados na seqüência de chamamento como segundo e terceiro parâmetros). Em particular, flags de integração e tolerâncias podem ser ajustadas. Parâmetros opcionais podem ser ajustados pela função odeoptions.

Rotinas externas podem ser ligadas dinamicamente (ver link).

Exemplos

//sistema linear com entrada alternante
deff('xdu = phis(t,x,u,flag)','if flag==0 then xdu = A*x + B*u; else xdu = 1-u; end');
x0 = [1;1]; A = [-1,2;-2,-1]; B = [1;2]; u = 0; nu = 1; stdel = [1,0]; u0 = 0; t = 0:0.05:10;
xu = odedc([x0;u0],nu,stdel,0,t,phis);x=xu(1:2,:);u=xu(3,:);
nx = 2;
plot2d(t, x', [1:nx],'161')
plot2d2('onn',t',u',[nx+1:nx+nu],'000');

//função externa FORTRAN (ver fydot2.f):
norm(xu-odedc([x0;u0],nu,stdel,0,t,'phis'),1)

//feedback (resposta) amostrado
//
//        |     xcdot=fc(t,xc,u)
//  (sistema)   |
//        |     y=hc(t,xc)
//
//
//        |     xd+=fd(xd,y)
//  (feedback) |
//        |     u=hd(t,xd)
//
deff('xcd=f(t,xc,xd,iflag)',...
  ['if iflag==0 then '
   '  xcd=fc(t,xc,e(t)-hd(t,xd));'
   'else '
   '  xcd=fd(xd,hc(t,xc));'
   'end']);
A = [-10,2,3;4,-10,6;7,8,-10];
B = [1;1;1];C=[1,1,1];
Ad = [1/2,1;0,1/20];
Bd = [1;1];Cd=[1,1];
deff('st = e(t)','st = sin(3*t)')
deff('xdot=fc(t,x,u)', 'xdot=A*x+B*u')
deff('y = hc(t,x)','y = C*x')
deff('xp = fd(x,y)','xp = Ad*x + Bd*y')
deff('u = hd(t,x)','u = Cd*x')
h = 0.1; t0 = 0; t = 0:0.1:2;
x0c = [0;0;0]; x0d = [0;0]; nd = 2;
xcd = odedc([x0c;x0d],nd,h,t0,t,f);
norm(xcd-odedc([x0c;x0d],nd,h,t0,t,'fcd1')) // cálculo rápido (ver fydot2.f)
plot2d([t',t',t'],xcd(1:3,:)');
scf(2);
plot2d2("gnn",[t',t'],xcd(4:5,:)');
scf(0);

Ver Também

• ode — Solucionador de equações diferenciais ordinárias
• link — dynamic linker
• odeoptions — ajusta opções para solucionadores de EDO
• csim — simulation (time response) of linear system
• external — objeto Scilab, função ou rotina externa