doc/info/pt_BR/contrib_ode.texi

   1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
   2 @c /contrib_ode.texi/1.5/Sat Jun  2 00:13:11 2007//
   3 @menu
   4 * Introdução a contrib_ode::
   5 * Funções e Variáveis Definidas para contrib_ode::
   6 * Possibilidades de melhorias em contrib_ode::
   7 * Casos de teste para contrib_ode::
   8 * Referências bibliográficas para contrib_ode::
   9 @end menu
  10
  11 @node Introdução a contrib_ode, Funções e Variáveis Definidas para contrib_ode, contrib_ode, contrib_ode
  12
  13 @section Introdução a contrib_ode
  14
  15 O resolvedor de equações diferenciais ordinárias (EDO) do MAXIMA, o @code{ode2}, resolve
  16 EDO's elementares de primeira e segunda ordem.  A função
  17 @code{contrib_ode} extende @code{ode2} com métodos adicionais para EDO's lineares
  18 e EDO's não lineares de primeira ordem e EDO's lineares homogêneas de segunda ordem.
  19 O código está ainda em desenvolvimemto e a seq@"{u}ência de chamada da função pode mudar
  20 em futuras versões.  Uma vez que o código estiver estabilizado essa função pode ser
  21 movida do diretório contrib e integrada dentro do MAXIMA.
  22
  23 Esse pacote deve torna-se disponível para uso com o comando @code{load("contrib_ode")}
  24 em primeiro lugar.
  25
  26 A convenção de chamada para @code{contrib_ode} é idêntica a @code{ode2}.
  27 Toma
  28 três argumentos: uma EDO (somente o lado esquerdo precisa ser fornecido se o
  29 lado direito for 0), a variável dependente, e a variável
  30 independente.  Quando @code{contrib_ode} obtiver sucesso, retorna uma lista de soluções.
  31
  32 A forma de retorno da lista de solução difere de @code{ode2}.
  33 Como equações não lineares podem ter múltiplas soluções,
  34 @code{contrib_ode} retorna uma lista de soluções.  Cada solução pode
  35 ter várias formas:
  36 @itemize @bullet
  37 @item
  38 uma solução explícita para a variável dependente,
  39
  40 @item
  41 uma solução implícita para a variável dependente,
  42
  43 @item
  44 uma solução paramétrica em termos de variável %t, ou
  45
  46 @item
  47 uma transfrmação em outra EDO na variável %u.
  48
  49 @end itemize
  50
  51 @code{%c} é usado para representar a constante de integração para equações de primeira ordem.
  52 @code{%k1} e @code{%k2} são constantes para equações de segunda ordem.
  53 Se @code{contrib_ode}
  54 não puder obter uma solução por qualquer razão, @code{false} é retornado, após
  55 talvez mostrar uma mensagem de erro.
  56
  57 Isso é necessário para retornar uma lista de soluções, como mesmo EDO's de primeira
  58 ordem não lineares podem ter soluções multiplas.  Por exemplo:
  59
  60 @c ===beg===
  61 @c load("contrib_ode")$
  62 @c eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0;
  63 @c contrib_ode(eqn,y,x);
  64 @c method;
  65 @c ===end===
  66 @example
  67 (%i1) load("contrib_ode")$
  68
  69 (%i2) eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0;
  70
  71                     dy 2             dy
  72 (%o2)            x (--)  - (x y + 1) -- + y = 0
  73                     dx               dx
  74 (%i3) contrib_ode(eqn,y,x);
  75
  76                                              x
  77 (%o3)             [y = log(x) + %c, y = %c %e ]
  78 (%i4) method;
  79
  80 (%o4)                        factor
  81 @end example
  82
  83 EDO's não lineares podem ter soluções singulares sem constantes de
  84 integração, como na segunda solução do seguinte exemplo:
  85
  86 @c ===beg===
  87 @c load("contrib_ode")$
  88 @c eqn:'diff(y,x)^2+x*'diff(y,x)-y=0;
  89 @c contrib_ode(eqn,y,x);
  90 @c method;
  91 @c ===end===
  92 @example
  93 (%i1) load("contrib_ode")$
  94
  95 (%i2) eqn:'diff(y,x)^2+x*'diff(y,x)-y=0;
  96
  97                        dy 2     dy
  98 (%o2)                 (--)  + x -- - y = 0
  99                        dx       dx
 100 (%i3) contrib_ode(eqn,y,x);
 101
 102                                            2
 103                                  2        x
 104 (%o3)              [y = %c x + %c , y = - --]
 105                                           4
 106 (%i4) method;
 107
 108 (%o4)                       clairault
 109 @end example
 110
 111
 112 A seguinte EDO possui duas soluções paramétricas em termos da variável
 113 fictícia %t.  Nesse caso as soluções paramétricaspodem ser manipuladas
 114 para fornecer soluções explícitas.
 115
 116 @c ===beg===
 117 @c load("contrib_ode")$
 118 @c eqn:'diff(y,x)=(x+y)^2;
 119 @c contrib_ode(eqn,y,x);
 120 @c method;
 121 @c ===end===
 122 @example
 123 (%i1) load("contrib_ode")$
 124
 125 (%i2) eqn:'diff(y,x)=(x+y)^2;
 126
 127                           dy          2
 128 (%o2)                     -- = (y + x)
 129                           dx
 130 (%i3) contrib_ode(eqn,y,x);
 131
 132 (%o3) [[x = %c - atan(sqrt(%t)), y = - x - sqrt(%t)],
 133                      [x = atan(sqrt(%t)) + %c, y = sqrt(%t) - x]]
 134 (%i4) method;
 135
 136 (%o4)                       lagrange
 137 @end example
 138
 139 O seguinte exemplo (Kamke 1.112) demonstra uma solução implícita.
 140
 141 @c ===beg===
 142 @c load("contrib_ode")$
 143 @c assume(x>0,y>0);
 144 @c eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y;
 145 @c contrib_ode(eqn,y,x);
 146 @c method;
 147 @c ===end===
 148 @example
 149 (%i1) load("contrib_ode")$
 150
 151 (%i2) assume(x>0,y>0);
 152
 153 (%o2)                    [x > 0, y > 0]
 154 (%i3) eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y;
 155
 156                      dy           2    2
 157 (%o3)              x -- - x sqrt(y  + x ) - y
 158                      dx
 159 (%i4) contrib_ode(eqn,y,x);
 160
 161                                   y
 162 (%o4)                  [x - asinh(-) = %c]
 163                                   x
 164 (%i5) method;
 165
 166 (%o5)                          lie
 167 @end example
 168
 169
 170
 171 A seguinte equação de Riccati é transformada em uma EDO linear
 172 de segunda ordem na variável %u.  MAXIMA não está apto a
 173 resolver a nova EDO, de forma que essa nova EDO é retornada sem avaliação.
 174 @c ===beg===
 175 @c load("contrib_ode")$
 176 @c eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2;
 177 @c contrib_ode(eqn,y,x);
 178 @c method;
 179 @c ===end===
 180 @example
 181 (%i1) load("contrib_ode")$
 182
 183 (%i2) eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2;
 184
 185                     2 dy      2  2      n
 186 (%o2)              x  -- = c x  y  + b x  + a
 187                       dx
 188 (%i3) contrib_ode(eqn,y,x);
 189
 190                d%u
 191                ---                            2
 192                dx        2     n - 2   a     d %u
 193 (%o3)  [[y = - ----, %u c  (b x      + --) + ---- c = 0]]
 194                %u c                     2      2
 195                                        x     dx
 196 (%i4) method;
 197
 198 (%o4)                        riccati
 199 @end example
 200
 201
 202 Para EDO's de primeira ordem @code{contrib_ode} chama @code{ode2}.  @code{ode2} tenta então os
 203 seguintes métodos: fatoração, Clairault, Lagrange, Riccati,
 204 Abel e os métodos de simetria de Lie.  O método de Lie não é tentado
 205 sobre equações de Abel se o método de Abel falhar, mas é tendado
 206 se o método de Riccati uma EDO de segunda ordem não resolvida.
 207
 208 Para EDO's de segunda ordem @code{contrib_ode} chama @code{ode2} e em seguida @code{odelin}.
 209
 210 Rastros extensivos de depuração mensagens são mostradas se o comando
 211 @code{put('contrib_ode,true,'verbose)} for executado.
 212
 213 @node Funções e Variáveis Definidas para contrib_ode, Possibilidades de melhorias em contrib_ode, Introdução a contrib_ode, contrib_ode
 214 @section Funções e Variáveis Definidas para contrib_ode
 215
 216 @deffn {Função} contrib_ode (@var{eqn}, @var{y}, @var{x})
 217
 218 Retorna uma lista de soluções da EDO @var{eqn} com
 219 variável independente @var{x} e variável dependente @var{y}.
 220
 221 @end deffn
 222
 223 @deffn {Função} odelin (@var{eqn}, @var{y}, @var{x})
 224
 225 @code{odelin} resolve EDO's lineares homogêneas de primeira e
 226 segunda ordem com
 227 variável independente @var{x} e variável dependente @var{y}.
 228 @code{odelin} retorna um conjunto solução fundamental da EDO.
 229
 230 para EDO's de segunda ordem, @code{odelin} usa um método, devido a Bronstein
 231 e Lafaille, que busca por soluções em termos de funções
 232 especiais dadas.
 233
 234 @c ===beg===
 235 @c load("contrib_ode")$
 236 @c odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x);
 237 @c ===end===
 238 @example
 239 (%i1) load("contrib_ode");
 240
 241 (%i2) odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x);
 242 ...trying factor method
 243 ...solving 7 equations in 4 variables
 244 ...trying the Bessel solver
 245 ...solving 1 equations in 2 variables
 246 ...trying the F01 solver
 247 ...solving 1 equations in 3 variables
 248 ...trying the spherodial wave solver
 249 ...solving 1 equations in 4 variables
 250 ...trying the square root Bessel solver
 251 ...solving 1 equations in 2 variables
 252 ...trying the 2F1 solver
 253 ...solving 9 equations in 5 variables
 254        gauss_a(- 6, - 2, - 3, - x)  gauss_b(- 6, - 2, - 3, - x)
 255 (%o2) @{---------------------------, ---------------------------@}
 256                     4                            4
 257                    x                            x
 258
 259 @end example
 260
 261 @end deffn
 262
 263 @deffn {Função} ode_check (@var{eqn}, @var{sol})
 264
 265 Retorna o valor da EDO @var{eqn} após substituir uma
 266 possível solução @var{sol}.  O valor é igual a
 267 zero se @var{sol} for uma solução of @var{eqn}.
 268
 269 @c ===beg===
 270 @c load("contrib_ode")$
 271 @c eqn:'diff(y,x,2)+(a*x+b)*y;
 272 @c ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b)
 273 @c          +bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)];
 274 @c ode_check(eqn,ans[1]);
 275 @c ===end===
 276 @example
 277 (%i1) load("contrib_ode")$
 278
 279 (%i2) eqn:'diff(y,x,2)+(a*x+b)*y;
 280
 281                          2
 282                         d y
 283 (%o2)                   --- + (a x + b) y
 284                           2
 285                         dx
 286 (%i3) ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b)
 287          +bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)];
 288
 289                                   3/2
 290                     1  2 (a x + b)
 291 (%o3) [y = bessel_y(-, --------------) %k2 sqrt(a x + b)
 292                     3       3 a
 293                                           3/2
 294                             1  2 (a x + b)
 295                  + bessel_j(-, --------------) %k1 sqrt(a x + b)]
 296                             3       3 a
 297 (%i4) ode_check(eqn,ans[1]);
 298
 299 (%o4)                           0
 300 @end example
 301
 302 @end deffn
 303
 304 @defvr {Variável global} @code{method}
 305
 306 A variável @code{method} é escolhida para o método que resolver com sucesso
 307 uma dada EDO.
 308
 309 @end defvr
 310
 311 @defvr {Variável} @code{%c}
 312
 313 @code{%c} é a constante de integração para EDO's de primeira ordem.
 314
 315 @end defvr
 316
 317 @defvr {Variável} @code{%k1}
 318
 319 @code{%k1} é a primeira constante de integração para EDO's de segunda ordem.
 320
 321 @end defvr
 322
 323 @defvr {Variável} @code{%k2}
 324
 325 @code{%k2} é a segunda constante de integração para EDO's de segunda ordem.
 326
 327 @end defvr
 328
 329 @deffn {Função} gauss_a (@var{a}, @var{b}, @var{c}, @var{x})
 330
 331 @code{gauss_a(a,b,c,x)} e @code{gauss_b(a,b,c,x)} são funções
 332 hipergeométricas 2F1.  Elas represetnam quaisquer duas soluções
 333 independentes da equação diferencial hipergeométrica
 334 @code{x(1-x) diff(y,x,2) + [c-(a+b+1)x diff(y,x) - aby = 0} (A&S 15.5.1).
 335
 336 O único uso dessas funções é em soluções de EDO's retornadas por
 337 @code{odelin} e @code{contrib_ode}.  A definição e o uso dessas
 338 funções pode mudar em futuras versões do maxima.
 339
 340 Veja também @code{gauss_b}, @code{dgauss_a} e @code{gauss_b}.
 341
 342 @end deffn
 343
 344 @deffn {Função} gauss_b (@var{a}, @var{b}, @var{c}, @var{x})
 345 Veja @code{gauss_a}.
 346 @end deffn
 347
 348 @deffn {Função} dgauss_a (@var{a}, @var{b}, @var{c}, @var{x})
 349 A derivada em relação a x de @code{gauss_a(a,b,c,x)}.
 350 @end deffn
 351
 352 @deffn {Função} dgauss_b (@var{a}, @var{b}, @var{c}, @var{x})
 353 A derivada em relação a x de @code{gauss_b(a,b,c,x)}.
 354 @end deffn
 355
 356
 357 @deffn {Função} kummer_m (@var{a}, @var{b}, @var{x})
 358
 359 A função  M de Kummer, como definida em Abramowitz e Stegun,
 360 @i{Handbook of Mathematical Functions}, Section 13.1.2.
 361
 362 O único uso dessas funções é em soluções de EDO's retornadas por
 363 @code{odelin} e @code{contrib_ode}.  A definição e o uso dessas
 364 funções pode mudar em futuras versões do maxima.
 365
 366 Veja também @code{kummer_u}, @code{dkummer_m} e @code{dkummer_u}.
 367 @end deffn
 368
 369 @deffn {Função} kummer_u (@var{a}, @var{b}, @var{x})
 370
 371 A função U de Kummer, como definida em Abramowitz e Stegun,
 372 @i{Handbook of Mathematical Functions}, Section 13.1.3.
 373
 374 Veja @code{kummer_m}.
 375 @end deffn
 376
 377 @deffn {Função} dkummer_m (@var{a}, @var{b}, @var{x})
 378 A derivada com relação a x de @code{kummer_m(a,b,x)}.
 379 @end deffn
 380
 381 @deffn {Função} dkummer_u (@var{a}, @var{b}, @var{x})
 382 A derivada com relação a x de  @code{kummer_u(a,b,x)}.
 383 @end deffn
 384
 385
 386
 387 @node Possibilidades de melhorias em contrib_ode, Casos de teste para contrib_ode, Funções e Variáveis Definidas para contrib_ode, contrib_ode
 388 @section Possibilidades de melhorias em contrib_ode
 389
 390
 391 Essas rotinas aida estão sendo aperfeiçoadas.  É necessário ainda:
 392
 393 @itemize @bullet
 394
 395 @item
 396 Extender o método FACTOR @code{ode1_factor} para trabalhar com raízes multiplas.
 397
 398 @item
 399 Extender o método FACTOR  @code{ode1_factor} para tentar resolver fatores
 400   de mais alta ordem.  Atualmente somente tenta resolver fatores lineares.
 401
 402 @item
 403 Corrigir a rotina de LAGRANGE @code{ode1_lagrange} para preferiraízes reais a
 404   raízes complexas.
 405
 406 @item
 407 Aumentar a quantidade de métodos adicionais para equações de Riccati.
 408
 409 @item
 410 Melhorar a detecção de equações de Abel do segundo tipo.  O modelo
 411   existente de coincidência é fraco.
 412
 413 @item
 414 Trabalho sobre a rotina do grupo de simetria de Lie @code{ode1_lie}.  Existem poucos porém
 415   grandes problemas com essa rotina: algumas partes precisam de implementação; alguns casos de teste
 416   parecem executar indefinidamente; outros casos de teste abortam inesplicavelmente; outros ainda retorna "soluções"
 417   muito complexas.  Seria surpreendente se estivesse pronto para se liberar uma versão estável.
 418
 419 @item
 420 Adicionar mais casos de teste.
 421
 422 @end itemize
 423
 424 @node Casos de teste para contrib_ode, Referências bibliográficas para contrib_ode, Possibilidades de melhorias em contrib_ode, contrib_ode
 425 @section Casos de teste para contrib_ode
 426
 427
 428 Asrotinas foram tesadas sobre aproximadamente mil casos de teste
 429 por Murphy,
 430 Kamke, Zwillinger e outros.  Esses testes estão incluídos no subdiretório de testes.
 431
 432 @itemize @bullet
 433 @item
 434 A rotina de Clairault @code{ode1_clairault} encontra todas as soluções conhecidas,
 435   incluindo soluções singulares, das equações de Clairault em Murphy e
 436   Kamke.
 437
 438 @item
 439 As outras rotinas muitas vezes retornam uma solução simples quando existem
 440   multiplas soluções.
 441
 442 @item
 443 Algumas das "soluções" de @code{ode1_lie} são extremamente complexas e
 444   impossíveis de verificar.
 445
 446 @item
 447 Existe algumas interrupções inexplicávies de execução.
 448
 449 @end itemize
 450
 451 @node Referências bibliográficas para contrib_ode, ,Casos de teste para contrib_ode, contrib_ode
 452 @section Referências bibliográficas para contrib_ode
 453
 454
 455 @enumerate
 456 @item
 457 E Kamke, Differentialgleichungen Losungsmethoden und Losungen, Vol 1,
 458     Geest & Portig, Leipzig, 1961
 459
 460 @item
 461 G M Murphy, Ordinary Differential Equations and Their Solutions,
 462     Van Nostrand, New York, 1960
 463
 464 @item
 465 D Zwillinger, Handbook of Differential Equations, 3rd edition,
 466     Academic Press, 1998
 467
 468 @item
 469 F Schwarz, Symmetry Analysis of Abel's Equation, Studies in
 470     Applied Mathematics, 100:269-294 (1998)
 471
 472 @item
 473 F Schwarz, Algorithmic Solution of Abel's Equation,
 474     Computing 61, 39-49 (1998)
 475
 476 @item
 477 E. S. Cheb-Terrab, A. D. Roche, Symmetries and First Order
 478     EDO Patterns, Computer Physics Communications 113 (1998), p 239.
 479     (http://lie.uwaterloo.ca/papers/ode_vii.pdf)
 480
 481 @item
 482 E. S. Cheb-Terrab, T. Koloknikov,  First Order EDO's,
 483     Symmetries and Linear Transformations, European Journal of
 484     Applied Mathematics, Vol. 14, No. 2, pp. 231-246 (2003).
 485     (http://arxiv.org/abs/math-ph/0007023)
 486     (http://lie.uwaterloo.ca/papers/ode_iv.pdf)
 487
 488 @item
 489 G W Bluman, S C Anco, Symmetry and Integration Methods for
 490     Differential Equations, Springer, (2002)
 491
 492 @item
 493 M Bronstein, S Lafaille,
 494 Solutions of linear ordinary equações diferenciais in terms
 495 of special functions,
 496 Proceedings of ISSAC 2002, Lille, ACM Press, 23-28.
 497 (http://www-sop.inria.fr/cafe/Manuel.Bronstein/publications/issac2002.pdf)
 498
 499
 500 @end enumerate
 501