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