# odedc

solucionador de EDOs contínuas/discretas

## Seqüência de Chamamento

    yt=odedc(y0,nd,stdel,t0,t,f)

## 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 `yd_k` é embutido em uma função de tempo seccional constante `yd(t)` como segue:

    yd(t)=yd_k para t em
    [t_k=atraso+k*h,t_(k+1)=delay+(k+1)*h] (com atraso=h*delta).

As equações simuladas são agora:

    dyc/dt=f(t,yc(t),yd(t),0),  para t em [t_k,t_(k+1)]
    yc(t0)=y0c

e nos instantes `t_k` a variável discreta `yd` é atualizada por:

    yd(t_k+)=f(yc(t_k-),yd(t_k-),1)

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

    yd_k = f (t_k,yc(t_k-),yd(t_(k-1)),1)  (yc é de tempo contínuo: yc(t_k-)=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`.

Um exemplo para chamada de rotina externa é encontrado em `SCIDIR/default/fydot2.f`

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;
    plot2d1('onn',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,:)');
    xset("window",2);plot2d2("gnn",[t',t'],xcd(4:5,:)');
    xset("window",0);

## Ver Também

- ode
- link
- odeoptions
- csim
- external