Differential_equations doc: warning fix
[scilab.git] / scilab / modules / differential_equations / help / pt_BR / ode.xml
1 <?xml version="1.0" encoding="ISO-8859-1"?>
2 <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="ode" xml:lang="en">
3     <refnamediv>
4         <refname>ode</refname>
5         <refpurpose>Solucionador de equações diferenciais ordinárias</refpurpose>
6     </refnamediv>
7     <refsynopsisdiv>
8         <title>Seqüência de Chamamento</title>
9         <synopsis>y=ode(y0,t0,t,f)
10             [y,w,iw]=ode([type],y0,t0,t [,rtol [,atol]],f [,jac] [,w,iw])
11             [y,rd,w,iw]=ode("root",y0,t0,t [,rtol [,atol]],f [,jac],ng,g [,w,iw])
12             y=ode("discrete",y0,k0,kvect,f)
13         </synopsis>
14     </refsynopsisdiv>
15     <refsection>
16         <title>Parâmetros</title>
17         <variablelist>
18             <varlistentry>
19                 <term>y0</term>
20                 <listitem>
21                     <para>matriz ou vetor de reais (condições iniciais).</para>
22                 </listitem>
23             </varlistentry>
24             <varlistentry>
25                 <term>t0</term>
26                 <listitem>
27                     <para>escalar real (tempo inicial).</para>
28                 </listitem>
29             </varlistentry>
30             <varlistentry>
31                 <term>t</term>
32                 <listitem>
33                     <para>vetor de reais (tempos nos quais a solução é
34                         computada).
35                     </para>
36                 </listitem>
37             </varlistentry>
38             <varlistentry>
39                 <term>f</term>
40                 <listitem>
41                     <para>função externa (função, lista ou string).</para>
42                 </listitem>
43             </varlistentry>
44             <varlistentry>
45                 <term>type</term>
46                 <listitem>
47                     <para>
48                         um dos strings seguintes: <literal>"adams"</literal>,
49                         <literal>"stiff"</literal>, <literal>"rk"</literal>,
50                         <literal>"rkf"</literal>, <literal>"fix"</literal>,
51                         <literal>"discrete"</literal>, <literal>"roots"</literal>.
52                     </para>
53                 </listitem>
54             </varlistentry>
55             <varlistentry>
56                 <term>rtol, atol</term>
57                 <listitem>
58                     <para>constantes reais ou vetores com o mesmo tamanho que
59                         <literal>y</literal>.
60                     </para>
61                 </listitem>
62             </varlistentry>
63             <varlistentry>
64                 <term>jac</term>
65                 <listitem>
66                     <para>função externa (função, lista ou string).</para>
67                 </listitem>
68             </varlistentry>
69             <varlistentry>
70                 <term>w, iw</term>
71                 <listitem>
72                     <para>vetores de reais</para>
73                 </listitem>
74             </varlistentry>
75             <varlistentry>
76                 <term>ng</term>
77                 <listitem>
78                     <para>inteiro</para>
79                 </listitem>
80             </varlistentry>
81             <varlistentry>
82                 <term>g</term>
83                 <listitem>
84                     <para>função externa (função, lista ou string).</para>
85                 </listitem>
86             </varlistentry>
87             <varlistentry>
88                 <term>k0</term>
89                 <listitem>
90                     <para>inteiro (tempo inicial).</para>
91                 </listitem>
92             </varlistentry>
93             <varlistentry>
94                 <term>kvect</term>
95                 <listitem>
96                     <para>vetor de inteiros.</para>
97                 </listitem>
98             </varlistentry>
99         </variablelist>
100     </refsection>
101     <refsection>
102         <title>Descrição</title>
103         <para>
104             <literal>ode</literal> é a função padrão para se resolver sistemas
105             de EDO explícitos definidos por: dy/dt=f(t,y) , y(t0)=y0. É uma interface
106             entre vários solucionadores, em particular a ODEPACK. O tipo de problema
107             resolvido e o método a ser utilizado dependem do primeiro argumento
108             opcional <literal>type</literal> que pode ser um dos strings
109             seguintes:
110         </para>
111         <variablelist>
112             <varlistentry>
113                 <term>&lt;not given&gt;:</term>
114                 <listitem>
115                     <para>
116                         O solucionador <literal>lsoda</literal> do pacote ODEPACK é
117                         chamado por padrão. Ele escolhe automaticamente entre o método
118                         preditor-corretor não-rígido de Adams e a Fórmula de Diferenciação
119                         Retroativa (FDR) rígida. Ele utiliza o método não rígido
120                         inicialmente e monitora os dados para decidir qual método
121                         utilizar.
122                     </para>
123                 </listitem>
124             </varlistentry>
125             <varlistentry>
126                 <term>"adams":</term>
127                 <listitem>
128                     <para>Este é para problemas não rígidos. O solucionador
129                         <literal>lsode</literal> do pacote ODEPACK é chamado e utiliza o
130                         método de Adams.
131                     </para>
132                 </listitem>
133             </varlistentry>
134             <varlistentry>
135                 <term>"stiff":</term>
136                 <listitem>
137                     <para>Este é para problemas rígidos. O solucionador
138                         <literal>lsode</literal> do pacote ODEPACK é chamado e é utilizado o
139                         método FDR.
140                     </para>
141                 </listitem>
142             </varlistentry>
143             <varlistentry>
144                 <term>"rk":</term>
145                 <listitem>
146                     <para>Método adaptativo de Runge-Kutta de ordem 4 (RK4).</para>
147                 </listitem>
148             </varlistentry>
149             <varlistentry>
150                 <term>"rkf":</term>
151                 <listitem>
152                     <para>O programa de Shampine e Watts baseado no par Runge-Kutta de
153                         Fehlberg de ordem 4 e 5 (RKF45) é utilizado. Este é utilizado para
154                         problemas não-rígidos e mediamente rígidos quando as computações de
155                         derivação não são custosas. Este método não é recomendado ser
156                         utilizado quando o usuário requer uma maior precisão.
157                     </para>
158                 </listitem>
159             </varlistentry>
160             <varlistentry>
161                 <term>"fix":</term>
162                 <listitem>
163                     <para>
164                         Mesmo solucionador que <literal>"rkf"</literal>, mas a
165                         interface do usuário é bem
166                         simples, i.e. apenas os parâmetros <literal>rtol</literal> e
167                         <literal>atol</literal> podem ser passados ao solucionador. Este é o
168                         método mais simples a se tentar.
169                     </para>
170                 </listitem>
171             </varlistentry>
172             <varlistentry>
173                 <term>"root":</term>
174                 <listitem>
175                     <para>Solucionador de EDOs com capacidade de encontrar raízes. O
176                         solucionador <literal>lsodar</literal> do pacote ODEPACK é
177                         utilizado. É uma variante do solucionador <literal>lsoda</literal>
178                         onde se acha raízes de uma dada função vetorial. Ver ajuda em
179                         <link linkend="ode_root">ode_root</link> para mais detalhes.
180                     </para>
181                 </listitem>
182             </varlistentry>
183             <varlistentry>
184                 <term>"discrete":</term>
185                 <listitem>
186                     <para>
187                         Simulação de tempo discreto. Ver ajuda em <link linkend="ode_discrete">ode_discrete</link> para
188                         mais detalhes.
189                     </para>
190                 </listitem>
191             </varlistentry>
192         </variablelist>
193         <para>
194             Nesta ajuda podemos apenas descrever o uso de <literal>ode</literal>
195             para sistemas padrões explícitos EDOs .
196         </para>
197         <itemizedlist>
198             <listitem>
199                 <para>
200                     A chamada mais simples a <literal>ode</literal> é:
201                     <literal>y=ode(y0,t0,t,f)</literal> onde <literal>y0</literal> é o
202                     vetor de condições iniciais, <literal>t0</literal> é o tempo inicial,
203                     <literal>t</literal> é o vetor de tempos onde a solução
204                     <literal>y</literal> é computada e <literal>y</literal> é a matriz de
205                     vetores soluções <literal>y=[y(t(1)),y(t(2)),...]</literal>.
206                 </para>
207                 <para>
208                     O argumento de entrada <literal>f</literal> define o lado
209                     direito da equação diferencial de primeira ordem: dy/dt=f(t,y). É uma
210                     função externa, isto é, uma função com sintaxe especificada, ou o nome
211                     de uma subrotina Fortran ou uma subfunção C (string) com seqüência de
212                     chamamento especificada, ou uma lista:
213                 </para>
214                 <itemizedlist>
215                     <listitem>
216                         <para>
217                             Se <literal>f</literal> for uma função do Scilab, a sua
218                             sintaxe deve ser <literal>ydot = f(t,y)</literal>, onde
219                             <literal>t</literal> é um escalar real (tempo) e
220                             <literal>y</literal> é um vetor de reais (estado).
221                             <literal>ydot</literal> é um vetor de reais (dy/dt)
222                         </para>
223                     </listitem>
224                     <listitem>
225                         <para>
226                             Se <literal>f</literal> é um string ele se refere ao nome de
227                             uma subrotina Fortran ou uma subfunção C, i.e. Se
228                             <literal>ode(y0,t0,t,"fex")</literal> for o comando, então a
229                             subrotina <literal>fex</literal> será chamada.
230                         </para>
231                         <para>A rotina Fortran deve ter a seguinte seqüência de
232                             chamamento: <literal>fex(n,t,y,ydot)</literal>, com n um inteiro,
233                             t um escalar de dupla precisão, y e ydot vetores de dupla
234                             precisão.
235                         </para>
236                         <para>
237                             A função C deve ter o seguinte protótipo: <literal>fex(int
238                                 *n,double *t,double *y,double *ydot)
239                             </literal>
240                         </para>
241                         <para>
242                             <literal>t</literal> é o tempo, <literal>y</literal> o
243                             estado e <literal>ydot</literal> a derivada do estado
244                             (dy/dt)
245                         </para>
246                         <para>Esta função externa pode ser construída em um SO de modo
247                             indpendente através de <link linkend="ilib_for_link">ilib_for_link</link> e ligada
248                             dinamicamente através da função do Scilab <link linkend="link">link</link>.
249                         </para>
250                     </listitem>
251                     <listitem>
252                         <para>
253                             O argumento <literal>f</literal> também pode ser uma lista
254                             com a seguinte estrutura:
255                             <literal>lst=list(realf,u1,u2,...un)</literal> onde
256                             <literal>realf</literal> é uma função do Scilab com a sintaxe:
257                             <literal>ydot = f(t,y,u1,u2,...,un)</literal>
258                         </para>
259                         <para>Esta sintaxe permite utilizar parâmetros como argumentos de
260                             <literal>realf</literal>.
261                         </para>
262                     </listitem>
263                 </itemizedlist>
264                 <para>
265                     A função <literal>f</literal> pode retornar uma matriz
266                     <literal>p x q</literal> ao invés de um vetor. Com esta notação de
267                     matriz, nos resolvemos o sistema <literal>n=p+q</literal> de EDOs
268                     <literal>dY/dt=F(t,Y)</literal> onde <literal>Y</literal> é uma matriz
269                     <literal>p x q</literal> matrix. Então, as condições iniciais,
270                     <literal>Y0</literal>, também devem ser uma matriz <literal>p x
271                         q
272                     </literal>
273                     eo resultado de <literal>ode</literal> é a matriz
274                     <literal>p x q(T+1)</literal>
275                     <literal>[Y(t_0),Y(t_1),...,Y(t_T)]</literal>.
276                 </para>
277             </listitem>
278             <listitem>
279                 <para>Argumentos de entrada opcionais podem ser fornecidos para o erro
280                     da solução: <literal>rtol</literal> e <literal>atol</literal> são
281                     limiares para os erros relativos e absolutos estimados. O erro
282                     estimado em <literal>y(i)</literal> é:
283                     <literal>rtol(i)*abs(y(i))+atol(i)</literal>
284                 </para>
285                 <para>e uma intergração é feita enquanto este erro é pequeno para
286                     todos os componentes do estado. Se <literal>rtol</literal> e/ou
287                     <literal>atol</literal> for uma constante <literal>rtol(i)</literal>
288                     e/ou <literal>atol(i)</literal> são ajustados para esta constante. Os
289                     valores padrões para <literal>rtol</literal> e <literal>atol</literal>
290                     são respectivamente <literal>rtol=1.d-5</literal> e
291                     <literal>atol=1.d-7</literal> para a maior parte dos solucionadores
292                     <literal>rtol=1.d-3</literal> e <literal>atol=1.d-4</literal> para
293                     <literal>"rfk"</literal> e <literal>"fix"</literal>.
294                 </para>
295             </listitem>
296             <listitem>
297                 <para>Para problemas rígidos, é melhor fornecer o Jacobiano da função
298                     do lado direito da equação como o argumento opcional
299                     <literal>jac</literal>. É uma função externa, istoé i.e. uma função
300                     com sintaxe especificada, ou o nome de uma subrotina Fortran ou uma
301                     subfunção C (string) com seqüência de chamamento especificada, ou uma
302                     lista.
303                 </para>
304                 <para>
305                     Se <literal>jac</literal> for uma função, a sintaxe deve ser
306                     <literal>J=jac(t,y)</literal>
307                 </para>
308                 <para>
309                     onde <literal>t</literal> é um escalar real (tempo),
310                     <literal>y</literal> é um vetor de reais (estado). A matriz resultante
311                     <literal>J</literal> deve fornecer df/dx i.e. <literal>J(k,i) =
312                         dfk/dxi
313                     </literal>
314                     com <literal>fk</literal> = k-ésimo componente de
315                     f.
316                 </para>
317                 <para>
318                     Se <literal>jac</literal> for um sting, ele se refere a uma
319                     subrotina Fortran, ou uma subfunção C, com as seguinte seqüência de
320                     chamamento:
321                 </para>
322                 <para>No caso Fortran:</para>
323                 <programlisting role=""><![CDATA[
324 subroutine fex(n,t,y,ml,mu,J,nrpd)
325 integer n,ml,mu,nrpd
326 double precision t,y(*),J(*)
327  ]]></programlisting>
328                 <para>No caso C:</para>
329                 <programlisting role=""><![CDATA[
330 void fex(int *n,double *t,double *y,int *ml,int *mu,double *J,int *nrpd,)
331  ]]></programlisting>
332                 <para>
333                     <literal>jac(n,t,y,ml,mu,J,nrpd)</literal>. Na maior parte dos
334                     casos, você não tem que se referir a <literal>ml</literal>,
335                     <literal>mu</literal> e <literal>nrpd</literal>.
336                 </para>
337                 <para>
338                     Se <literal>jac</literal> for uma lista, as mesmas convenções
339                     que para <literal>f</literal> se aplicam.
340                 </para>
341             </listitem>
342             <listitem>
343                 <para>
344                     Os argumentos opcionais <literal>w</literal> e
345                     <literal>iw</literal> e vetores para armazenamento de informações
346                     podem ser retornados pela rotina de integração (ver <link linkend="ode_optional_output">ode_optional_output</link> para
347                     detalhes). Queando esses vetores são fornecidos no lado direito de
348                     <literal>ode</literal>, a integração reinicia com os mesmos parâmetros
349                     da parada anteiror.
350                 </para>
351             </listitem>
352             <listitem>
353                 <para>Mais opções podem ser fornecidas a solucionadores ODEPACK
354                     utilizando-se a variável <literal>%ODEOPTIONS</literal>. Ver <link linkend="odeoptions">odeoptions</link>.
355                 </para>
356             </listitem>
357         </itemizedlist>
358     </refsection>
359     <refsection>
360         <title>Exemplos</title>
361         <programlisting role="example"><![CDATA[
362 // ----------  EDO simples de uma dimensão (função externa do Scilab)
363 // dy/dt=y^2-y sin(t)+cos(t), y(0)=0
364 function ydot=f(t,y),ydot=y^2-y*sin(t)+cos(t),endfunction
365 y0=0;t0=0;t=0:0.1:%pi;
366 y=ode(y0,t0,t,f)
367 plot(t,y)
368
369 // ---------- EDO simples de uma dimensão (função externa codificada em C)
370 ccode=['#include <math.h>'
371        'void myode(int *n,double *t,double *y,double *ydot)'
372        '{'
373        '  ydot[0]=y[0]*y[0]-y[0]*sin(*t)+cos(*t);'
374        '}']
375 mputl(ccode,TMPDIR+'/myode.c') //criando o arquivo C
376 ilib_for_link('myode','myode.c',[],'c',[],TMPDIR+'/loader.sce');//compilando
377 exec(TMPDIR+'/loader.sce') //linking incremental
378 y0=0;t0=0;t=0:0.1:%pi;
379 y=ode(y0,t0,t,'myode');
380
381 // ---------- Simulação de dx/dt = A x(t) + B u(t) com u(t)=sin(omega*t),
382 // x0=[1;0]
383 // solução x(t) desejada em t=0.1, 0.2, 0.5 ,1.
384 // A e a função u são passados para a função do lado direito em uma lista.
385 // B e omega são passados como variáveis globais
386 function xdot=linear(t,x,A,u),xdot=A*x+B*u(t),endfunction
387 function ut=u(t),ut=sin(omega*t),endfunction
388 A=[1 1;0 2];B=[1;1];omega=5;
389 ode([1;0],0,[0.1,0.2,0.5,1],list(linear,A,u))
390
391 // ---------- Integração com notação matricial da equação diferencial de Ricatti
392 // Xdot=A'*X + X*A - X'*B*X + C , X(0)=Identity
393 // Solução em t=[1,2]
394 function Xdot=ric(t,X),Xdot=A'*X+X*A-X'*B*X+C,endfunction
395 A=[1,1;0,2]; B=[1,0;0,1]; C=[1,0;0,1];
396 t0=0;t=0:0.1:%pi;
397 X=ode(eye(A),0,t,ric)
398
399 // ---------- Notação matricial, computação de exp(A)
400 A=[1,1;0,2];
401 function xdot=f(t,x),xdot=A*x;,endfunction
402 ode(eye(A),0,1,f)
403 ode("adams",eye(A),0,1,f)
404
405 // ---------- Notação de matriz, computação de exp(A) com matriz rígida, Jacobian fornecida
406 A=[10,0;0,-1];
407 function xdot=f(t,x),xdot=A*x,endfunction
408 function J=Jacobian(t,y),J=A,endfunction
409 ode("stiff",[0;1],0,1,f,Jacobian)
410  ]]></programlisting>
411     </refsection>
412     <refsection role="see also">
413         <title>Ver Também</title>
414         <simplelist type="inline">
415             <member>
416                 <link linkend="ode_discrete">ode_discrete</link>
417             </member>
418             <member>
419                 <link linkend="ode_root">ode_root</link>
420             </member>
421             <member>
422                 <link linkend="dassl">dassl</link>
423             </member>
424             <member>
425                 <link linkend="impl">impl</link>
426             </member>
427             <member>
428                 <link linkend="odedc">odedc</link>
429             </member>
430             <member>
431                 <link linkend="odeoptions">odeoptions</link>
432             </member>
433             <member>
434                 <link linkend="csim">csim</link>
435             </member>
436             <member>
437                 <link linkend="ltitr">ltitr</link>
438             </member>
439             <member>
440                 <link linkend="rtitr">rtitr</link>
441             </member>
442             <member>
443                 <link linkend="intg">intg</link>
444             </member>
445         </simplelist>
446     </refsection>
447     <refsection>
448         <title>Bibliografia</title>
449         <para>Alan C. Hindmarsh, lsode and lsodi, two new initial value ordinary
450             differential equation solvers, acm-signum newsletter, vol. 15, no. 4
451             (1980), pp. 10-11.
452         </para>
453     </refsection>
454     <refsection>
455         <title>Funções Utilizadas</title>
456         <para>As rotinas associadas podem ser encontradas no diretório
457             SCI/modules/differential_equations/src/fortran:
458         </para>
459         <para>lsode.f lsoda.f lsodar.f</para>
460     </refsection>
461 </refentry>