doc/info/pt/orthopoly.texi

   1 @c /orthopoly.texi/1.10/Fri Mar  2 00:44:47 2007//
   2 @menu
   3 * Introdução a polinómios ortogonais::
   4 * Definições para polinómios ortogonais::
   5 @end menu
   6
   7 @node Introdução a polinómios ortogonais, Definições para polinómios ortogonais, orthopoly, orthopoly
   8 @section Introdução a polinómios ortogonais
   9
  10 @code{orthopoly} é um pacote para avaliação simbólica e numérica de
  11 muitos tipos de polinómios ortogonais, incluindo polinómios de Chebyshev,
  12 Laguerre, Hermite, Jacobi, Legendre, e ultraesférico
  13 (Gegenbauer). Adicionalmentey, @code{orthopoly} inclui suporte funções esféricas segundo o critério de
  14 Bessel, esféricas segundo o critério de Hankel, e funções harm@^onica esféricas.
  15
  16 Em sua maior parte, @code{orthopoly} segue as convenções de Abramowitz e Stegun
  17 @i{Handbook of Mathematical Functions}, Chapter 22 (10th printing, December 1972);
  18 adicionalmente, usamos Gradshteyn e Ryzhik,
  19 @i{Table of Integrals, Series, and Products} (1980 corrected and
  20 enlarged edition), e Eugen Merzbacher @i{Quantum Mechanics} (2nd edition, 1970).
  21
  22 @c INSTALLATION INSTRUCTIONS NO LONGER RELEVANT
  23 @c BUT MAYBE SOME OF THESE FILES SHOULD BE MENTIONED IN ANOTHER CONTEXT
  24 @c This will create a directory @code{orthopoly_x} (again x is the release
  25 @c identifier) that contains the source file @code{orthopoly.lisp}, user
  26 @c documentation in html and texi formats, a sample maxima initialization file
  27 @c @code{orthopoly-init.lisp}, a README file, a testing routine
  28 @c @code{test_orthopoly.mac}, and two demonstration files.
  29
  30 @c Start Maxima and compile orthopoly. To do this, use the command
  31 @c
  32 @c (c1) compile_file("orthopoly.lisp");
  33
  34 Barton Willis da University de Nebraska e Kearney (UNK) escreveu
  35 o pacote @code{orthopoly} e sua documetação. O pacote
  36 é liberado segundo a licença pública geral GNU (GPL).
  37
  38 @subsection Iniciando com orthopoly
  39
  40 @code{load (orthopoly)} torna o pacote @code{orthopoly} disponível para uso.
  41
  42 Para encontrar o polinómio de Legendre de terceira ordem,
  43
  44 @c ===beg===
  45 @c legendre_p (3, x);
  46 @c ===end===
  47 @example
  48 (%i1) legendre_p (3, x);
  49                       3             2
  50              5 (1 - x)    15 (1 - x)
  51 (%o1)      - ---------- + ----------- - 6 (1 - x) + 1
  52                  2             2
  53 @end example
  54
  55 Para expressar esse polinómio como uma soma de potências de @var{x}, aplique @var{ratsimp} ou @var{rat}
  56 para o resultado anterior.
  57
  58 @c CONTINUING PREVIOUS EXAMPLE HERE
  59 @c ===beg===
  60 @c [ratsimp (%), rat (%)];
  61 @c ===end===
  62 @example
  63 (%i2) [ratsimp (%), rat (%)];
  64                         3           3
  65                      5 x  - 3 x  5 x  - 3 x
  66 (%o2)/R/            [----------, ----------]
  67                          2           2
  68 @end example
  69
  70 Alternativamente, faça o segundo argumento  para @code{legendre_p} (sua variável ``principal'')
  71 uma expressão racional canónica (CRE)  usando @code{rat(x)} em lugar de somente @code{x}.
  72
  73 @c ===beg===
  74 @c legendre_p (3, rat (x));
  75 @c ===end===
  76 @example
  77 (%i1) legendre_p (3, rat (x));
  78                               3
  79                            5 x  - 3 x
  80 (%o1)/R/                   ----------
  81                                2
  82 @end example
  83
  84 Para avaliação em ponto flutuante, @code{orthopoly} usa uma análise de erro durante a execução
  85 para estimar uma associação superior para o erro. Por exemplo,
  86
  87 @c ===beg===
  88 @c jacobi_p (150, 2, 3, 0.2);
  89 @c ===end===
  90 @example
  91 (%i1) jacobi_p (150, 2, 3, 0.2);
  92 (%o1) interval(- 0.062017037936715, 1.533267919277521E-11)
  93 @end example
  94
  95 intervalos possuem a forma @code{interval (@var{c}, @var{r})}, onde @var{c} é o
  96 centro e @var{r} é o raio do intervalo. Uma vez que Maxima
  97 não suporta aritmética sobre intervalos, em algumas situações, tais
  98 como em gráficos, vai querer suprimir o erro e sair somente com o
  99 centro do intervalo. Para fazer isso, escolha a variável de
 100 opção @code{orthopoly_returns_intervals} para @code{false}.
 101
 102 @c ===beg===
 103 @c orthopoly_returns_intervals : false;
 104 @c jacobi_p (150, 2, 3, 0.2);
 105 @c ===end===
 106 @example
 107 (%i1) orthopoly_returns_intervals : false;
 108 (%o1)                         false
 109 (%i2) jacobi_p (150, 2, 3, 0.2);
 110 (%o2)                  - 0.062017037936715
 111 @end example
 112
 113 Veja a secção @pxref{Avaliação em Ponto Flutuante} para maiores informações.
 114
 115 Muitas funções em @code{orthopoly} possuem uma propriedade @code{gradef}; dessa forma
 116
 117 @c ===beg===
 118 @c diff (hermite (n, x), x);
 119 @c diff (gen_laguerre (n, a, x), x);
 120 @c ===end===
 121 @example
 122 (%i1) diff (hermite (n, x), x);
 123 (%o1)                     2 n H     (x)
 124                                n - 1
 125 (%i2) diff (gen_laguerre (n, a, x), x);
 126               (a)               (a)
 127            n L   (x) - (n + a) L     (x) unit_step(n)
 128               n                 n - 1
 129 (%o2)      ------------------------------------------
 130                                x
 131 @end example
 132
 133 A função de um único passo no segundo exemplo previne um erro que poderia
 134 de outra forma surgir através da avaliação de @var{n} para 0.
 135
 136 @c CONTINUING PREVIOUS EXAMPLE HERE
 137 @c ===beg===
 138 @c ev (%, n = 0);
 139 @c ===end===
 140 @example
 141 (%i3) ev (%, n = 0);
 142 (%o3)                           0
 143 @end example
 144
 145 A propriedade @code{gradef} somente aplica para a variável ``principal''; dderivadas com
 146 relação a outros argumentos usualmente resultam em uma mensagem de erro; por exemplo
 147
 148 @c ===beg===
 149 @c diff (hermite (n, x), x);
 150 @c diff (hermite (n, x), n);
 151 @c ===end===
 152 @example
 153 (%i1) diff (hermite (n, x), x);
 154 (%o1)                     2 n H     (x)
 155                                n - 1
 156 (%i2) diff (hermite (n, x), n);
 157
 158 Maxima doesn't know the derivative of hermite with respect the first argument
 159  -- an error.  Quitting.  To debug this try debugmode(true);
 160 @end example
 161
 162 Geralmente, funções em @code{orthopoly} mapeiam sobre listas e matrizes. Para
 163 o mapeamento para avaliação total, as variáveis de opção
 164 @code{doallmxops} e @code{listarith} devem ambas serem @code{true} (o valor padrão).
 165 Para ilustrar o mapeamento sobre matrizes, considere
 166
 167 @c ===beg===
 168 @c hermite (2, x);
 169 @c m : matrix ([0, x], [y, 0]);
 170 @c hermite (2, m);
 171 @c ===end===
 172 @example
 173 (%i1) hermite (2, x);
 174                                      2
 175 (%o1)                    - 2 (1 - 2 x )
 176 (%i2) m : matrix ([0, x], [y, 0]);
 177                             [ 0  x ]
 178 (%o2)                       [      ]
 179                             [ y  0 ]
 180 (%i3) hermite (2, m);
 181                [                             2  ]
 182                [      - 2        - 2 (1 - 2 x ) ]
 183 (%o3)          [                                ]
 184                [             2                  ]
 185                [ - 2 (1 - 2 y )       - 2       ]
 186 @end example
 187
 188 No segundo exemplo, o elemento @code{i, j} do valor
 189 é @code{hermite (2, m[i,j])}; isso não é o mesmo que calcular
 190 @code{-2 + 4 m . m}, como visto no próximo exemplo.
 191
 192 @c CONTINUING PREVIOUS EXAMPLE HERE
 193 @c ===beg===
 194 @c -2 * matrix ([1, 0], [0, 1]) + 4 * m . m;
 195 @c ===end===
 196 @example
 197 (%i4) -2 * matrix ([1, 0], [0, 1]) + 4 * m . m;
 198                     [ 4 x y - 2      0     ]
 199 (%o4)               [                      ]
 200                     [     0      4 x y - 2 ]
 201 @end example
 202
 203 Se avaliar uma função em um ponto fora do seu domínio, geralmente
 204 @code{orthopoly} retorna uma função não avaliada. Por exemplo,
 205
 206 @c ===beg===
 207 @c legendre_p (2/3, x);
 208 @c ===end===
 209 @example
 210 (%i1) legendre_p (2/3, x);
 211 (%o1)                        P   (x)
 212                               2/3
 213 @end example
 214
 215 @code{orthopoly} suporta tradução em TeX; @code{orthopoly} também faz saídas
 216 bidimensionais em um terminal.
 217
 218 @c ===beg===
 219 @c spherical_harmonic (l, m, theta, phi);
 220 @c tex (%);
 221 @c jacobi_p (n, a, a - b, x/2);
 222 @c tex (%);
 223 @c ===end===
 224 @example
 225 (%i1) spherical_harmonic (l, m, theta, phi);
 226                           m
 227 (%o1)                    Y (theta, phi)
 228                           l
 229 (%i2) tex (%);
 230 $$Y_@{l@}^@{m@}\left(\vartheta,\varphi\right)$$
 231 (%o2)                         false
 232 (%i3) jacobi_p (n, a, a - b, x/2);
 233                           (a, a - b) x
 234 (%o3)                    P          (-)
 235                           n          2
 236 (%i4) tex (%);
 237 $$P_@{n@}^@{\left(a,a-b\right)@}\left(@{@{x@}\over@{2@}@}\right)$$
 238 (%o4)                         false
 239 @end example
 240
 241 @subsection Limitations
 242
 243 Quando uma expressão envolve muitos polinómios ortogonais com ordens
 244 simbólicas, é possível que a expressão actualmente
 245 tenda para zero, e ainda ocorre também que Maxima estar incapacitado
 246 de simplificar essa expressão para zero. Se fizer uma divisão por
 247 tal quantidade que tende a zero, poderá ficar em apuros. Por exemplo,
 248 a seguinte expressão tende para zero para inteiros @var{n} maiores que
 249 1, e ainda ocorre também que Maxima está incapacitado de simplificar
 250 essa expressão para zero.
 251
 252 @c ===beg===
 253 @c (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x) + (1 - n) * legendre_p (n - 2, x);
 254 @c ===end===
 255 @example
 256 (%i1) (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x) + (1 - n) * legendre_p (n - 2, x);
 257 (%o1)  (2 n - 1) P     (x) x - n P (x) + (1 - n) P     (x)
 258                   n - 1           n               n - 2
 259 @end example
 260
 261 Para um @var{n} específico, podemos reduzir a expressão a zero.
 262
 263 @c CONTINUING PREVIOUS EXAMPLE HERE
 264 @c ===beg===
 265 @c ev (% ,n = 10, ratsimp);
 266 @c ===end===
 267 @example
 268 (%i2) ev (% ,n = 10, ratsimp);
 269 (%o2)                           0
 270 @end example
 271
 272 Geralmente, a forma polinomial de um polinómio ortogonal esteja adequada de forma hostil
 273 para avaliaçao em ponto flutuante. Aqui está um exemplo.
 274
 275 @c ACTUALLY NEEDS load(orthopoly); BEFORE ANYTHING ELSE
 276 @c ===beg===
 277 @c p : jacobi_p (100, 2, 3, x)$
 278 @c subst (0.2, x, p);
 279 @c jacobi_p (100, 2, 3, 0.2);
 280 @c float(jacobi_p (100, 2, 3, 2/10));
 281 @c ===end===
 282 @example
 283 (%i1) p : jacobi_p (100, 2, 3, x)$
 284
 285 (%i2) subst (0.2, x, p);
 286 (%o2)                3.4442767023833592E+35
 287 (%i3) jacobi_p (100, 2, 3, 0.2);
 288 (%o3)  interval(0.18413609135169, 6.8990300925815987E-12)
 289 (%i4) float(jacobi_p (100, 2, 3, 2/10));
 290 (%o4)                   0.18413609135169
 291 @end example
 292
 293 O verdadeiro valor está em torno de 0.184; ess calculo suporta erro de
 294 cancelamento por extremo subtrativo.Expandindo o polinómio e então
 295 avaliando, fornecendo um melhor resultado.
 296 @c CONTINUING PREVIOUS EXAMPLE HERE
 297 @c ===beg===
 298 @c p : expand (p)$
 299 @c subst (0.2, x, p);
 300 @c ===end===
 301 @example
 302 (%i5) p : expand(p)$
 303 (%i6) subst (0.2, x, p);
 304 (%o6) 0.18413609766122982
 305 @end example
 306
 307 Essa não é uma regra geral; expandindo o polinómio não resulta sempre
 308 em expressões que são melhores adaptadas a avaliação numérica.
 309 Com grande folga, o melhor caminho para fazer avaliação numérica é fazer um ou mais
 310 argumentos da função serem números em ponto flutuante. Em função disso,
 311 algoritmos especializados em ponto flutuante são usados para avaliação.
 312
 313 A função @code{float} do Maxima é até certo ponto indiscriminada; se aplicar
 314 @code{float} a uma expressão envolvendo um polinómio ortogonal com um
 315 grau simbólico ou um parâmetro de ordem, esses parâmetos (inteiros) podem ser
 316 convertido em números em ponto flutuante; após o que, a expressão não irá avaliar
 317 completamente. Considere
 318
 319 @c ===beg===
 320 @c assoc_legendre_p (n, 1, x);
 321 @c float (%);
 322 @c ev (%, n=2, x=0.9);
 323 @c ===end===
 324 @example
 325 (%i1) assoc_legendre_p (n, 1, x);
 326                                1
 327 (%o1)                         P (x)
 328                                n
 329 (%i2) float (%);
 330                               1.0
 331 (%o2)                        P   (x)
 332                               n
 333 (%i3) ev (%, n=2, x=0.9);
 334                              1.0
 335 (%o3)                       P   (0.9)
 336                              2
 337 @end example
 338
 339 A expressão em (%o3) não irá avaliar para um número em ponto flutuante; @code{orthopoly} não
 340 reconhece valores em ponto flutuante em lugares onde deve haver valores inteiros. Similarmente,
 341 avaliação numérica da função @code{pochhammer} para ordens que
 342 excedam @code{pochhammer_max_index} pode ser perturbador; considere
 343
 344 @c ===beg===
 345 @c x :  pochhammer (1, 10), pochhammer_max_index : 5;
 346 @c ===end===
 347 @example
 348 (%i1) x :  pochhammer (1, 10), pochhammer_max_index : 5;
 349 (%o1)                         (1)
 350                                  10
 351 @end example
 352
 353 Aplicando @code{float} não avalia @var{x} para um número em ponto flutuante
 354
 355 @c CONTINUING PREVIOUS EXAMPLE HERE
 356 @c ===beg===
 357 @c float (x);
 358 @c ===end===
 359 @example
 360 (%i2) float (x);
 361 (%o2)                       (1.0)
 362                                  10.0
 363 @end example
 364
 365 Para avaliar @var{x} para um número em ponto flutuante, irá precisar associar
 366 @code{pochhammer_max_index} a 11 ou mais e aplicar @code{float} a @var{x}.
 367
 368 @c CONTINUING PREVIOUS EXAMPLE HERE
 369 @c ===beg===
 370 @c float (x), pochhammer_max_index : 11;
 371 @c ===end===
 372 @example
 373 (%i3) float (x), pochhammer_max_index : 11;
 374 (%o3)                       3628800.0
 375 @end example
 376
 377 O valor padrão de @code{pochhammer_max_index} é 100;
 378 modifique esse valor após chama @code{orthopoly}.
 379
 380 Finalmente, tenha consciência que os livros citados nas referências adotam diferentes definições de
 381 polinómios ortogonais; geralmente adotamos as convenções
 382 citadas nas convenções de Abramowitz e Stegun.
 383
 384 Antes de suspeitar de um erro no pacote @code{orthopoly}, verifique alguns casos especiais
 385 para determinar se suas definições coincidem com aquelas usadas por @code{orthopoly}.
 386 Definitions muitas vezes diferem por uma normalização; ocasionalmente, autores
 387 utilizam versões ``modificadas'' das funções que fazem a família
 388 ortogonal sobre um intervalo diferente do intervalo @math{(-1, 1)}. Para definir, por exemplo,
 389 um polinómio de Legendre que é ortogonal a @math{(0, 1)}, defina
 390
 391 @c ===beg===
 392 @c shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$
 393 @c shifted_legendre_p (2, rat (x));
 394 @c legendre_p (2, rat (x));
 395 @c ===end===
 396 @example
 397 (%i1) shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$
 398
 399 (%i2) shifted_legendre_p (2, rat (x));
 400                             2
 401 (%o2)/R/                 6 x  - 6 x + 1
 402 (%i3) legendre_p (2, rat (x));
 403                                2
 404                             3 x  - 1
 405 (%o3)/R/                    --------
 406                                2
 407 @end example
 408
 409 @anchor{Avaliação em Ponto Flutuante}
 410 @subsection Avaliação em Ponto Flutuante
 411
 412 Muitas funções em @code{orthopoly} utilizam análise de erro durante a execução para
 413 estimar o erro em avaliações em ponto flutuante; as
 414 exceções são funções de Bessel esféricas e os polinómios associados de
 415 Legendre do segundo tipo. Para avaliações numéricas, as funções
 416 de Bessel esféricas chamam funções da colecção de programas @code{SLATEC}. Nenhum método especializado é usado
 417 para avaliação numérica dos polinómios associados  de Legendre do
 418 segundo tipo.
 419
 420 A análise de erro durante a execução ignora erros que são de segunda ordem ou maior
 421 na máquina (também conhecida como perda de algarismos). A análise de erro durante a execução também
 422 ignora alguns poucos outros tipos de erro. É possível (embora não provável)
 423 que o erro actual exceda o estimado.
 424
 425 Intervalos possuem a forma @code{interval (@var{c}, @var{r})}, onde @var{c} é o centro
 426 do intervalo e @var{r} é seu raio. O
 427 centro de um intervalo pode sr um número complexo, e o raio é sempre um número real positivo.
 428
 429 Aqui está um exemplo.
 430
 431 @c ===beg===
 432 @c fpprec : 50$
 433 @c y0 : jacobi_p (100, 2, 3, 0.2);
 434 @c y1 : bfloat (jacobi_p (100, 2, 3, 1/5));
 435 @c ===end===
 436
 437 @example
 438 (%i1) fpprec : 50$
 439
 440 (%i2) y0 : jacobi_p (100, 2, 3, 0.2);
 441 (%o2) interval(0.1841360913516871, 6.8990300925815987E-12)
 442 (%i3) y1 : bfloat (jacobi_p (100, 2, 3, 1/5));
 443 (%o3) 1.8413609135168563091370224958913493690868904463668b-1
 444 @end example
 445
 446 Vamos testar o quanto o erro actual é é menor que o erro estimado
 447
 448 @c CONTINUING PREVIOUS EXAMPLE HERE
 449 @c ===beg===
 450 @c is (abs (part (y0, 1) - y1) < part (y0, 2));
 451 @c ===end===
 452 @example
 453 (%i4) is (abs (part (y0, 1) - y1) < part (y0, 2));
 454 (%o4)                         true
 455 @end example
 456
 457 Realmente, por esse exemplo o erro estimado é um maior que
 458 o erro verdadeiro.
 459
 460 Maxima não suporta aritmética sobre intervalos.
 461
 462 @c ===beg===
 463 @c legendre_p (7, 0.1) + legendre_p (8, 0.1);
 464 @c ===end===
 465 @example
 466 (%i1) legendre_p (7, 0.1) + legendre_p (8, 0.1);
 467 (%o1) interval(0.18032072148437508, 3.1477135311021797E-15)
 468         + interval(- 0.19949294375000004, 3.3769353084291579E-15)
 469 @end example
 470
 471 Um utilizador pode definir operadores aritméticos que fazem matemática de intervalos. Para
 472 definir adição de intervalos, podemos definir
 473
 474 @c ===beg===
 475 @c infix ("@+")$
 476 @c "@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2) + part (y, 2))$
 477 @c legendre_p (7, 0.1) @+ legendre_p (8, 0.1);
 478 @c ===end===
 479 @example
 480 (%i1) infix ("@@+")$
 481
 482 (%i2) "@@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2) + part (y, 2))$
 483
 484 (%i3) legendre_p (7, 0.1) @@+ legendre_p (8, 0.1);
 485 (%o3) interval(- 0.019172222265624955, 6.5246488395313372E-15)
 486 @end example
 487
 488 As rotinas eseciais em ponto flutuante são chamadas quando os argumentos
 489 forem complexos.  Por exemplo,
 490
 491 @c ===beg===
 492 @c legendre_p (10, 2 + 3.0*%i);
 493 @c ===end===
 494 @example
 495 (%i1) legendre_p (10, 2 + 3.0*%i);
 496 (%o1) interval(- 3.876378825E+7 %i - 6.0787748E+7,
 497                                            1.2089173052721777E-6)
 498 @end example
 499
 500 Let's compare this to the true value.
 501
 502 @c ===beg===
 503 @c float (expand (legendre_p (10, 2 + 3*%i)));
 504 @c ===end===
 505 @example
 506 (%i1) float (expand (legendre_p (10, 2 + 3*%i)));
 507 (%o1)          - 3.876378825E+7 %i - 6.0787748E+7
 508 @end example
 509
 510 Adicionalmente, quando os argumentos forem grandes números em ponto flutuante, as rotinas especiais
 511 de ponto flutuante são chamadas; todavia, tos grandes números em ponto flutuante são convertidos para números em ponto flutuante de dupla precisão
 512 e o resultado final é número em ponto flutuante de precisão dupla.
 513
 514 @c ===beg===
 515 @c ultraspherical (150, 0.5b0, 0.9b0);
 516 @c ===end===
 517 @example
 518 (%i1) ultraspherical (150, 0.5b0, 0.9b0);
 519 (%o1) interval(- 0.043009481257265, 3.3750051301228864E-14)
 520 @end example
 521
 522 @subsection Gráficos e @code{orthopoly}
 523
 524 Para desenhar gráficos de expressões que envolvem polinómios
 525 ortogonais, deverá fazer duas coisas:
 526 @enumerate
 527 @item
 528 Escolher a variável de opção @code{orthopoly_returns_intervals} para @code{false},
 529 @item
 530 Colocar apóstrofo em qualquer chamada a funções do pacote @code{orthopoly}.
 531 @end enumerate
 532 Se chamadas a funções não receberem apóstrofo, Maxima irá avaliá-las para polinómios antes
 533 de montar o gráfico; consequêntemente, as rotinas especializadas em ponto flutuante não serão chamadas.
 534 Aqui está um exemplo de como montar o gráfico de uma expressão que envolve
 535 um polinómio de Legendre.
 536
 537 @c ===beg===
 538 @c plot2d ('(legendre_p (5, x)), [x, 0, 1]), orthopoly_returns_intervals : false;
 539 @c ===end===
 540 @example
 541 (%i1) plot2d ('(legendre_p (5, x)), [x, 0, 1]), orthopoly_returns_intervals : false;
 542 (%o1)
 543 @end example
 544
 545 @ifnotinfo
 546 @figure{orthopoly1}
 547 @end ifnotinfo
 548
 549 A expressão @i{completa} @code{legendre_p (5, x)} recebe apóstrofo; isso é
 550 diferente de apenas colocar apóstrofo no nome da função usando @code{'legendre_p (5, @var{x})}.
 551
 552 @subsection Funções Diversas
 553
 554 O pacote @code{orthopoly} define o
 555 síbolo de Pochhammer e uma função de passo de unidade. @code{orthopoly} utiliza
 556 a função delta de Kronecker e a função de passo de unidade em
 557 declarações @code{gradef}.
 558
 559 Para converter os símbolos Pochhammer em quocientes da funções gama,
 560 use @code{makegamma}.
 561
 562 @c ===beg===
 563 @c makegamma (pochhammer (x, n));
 564 @c makegamma (pochhammer (1/2, 1/2));
 565 @c ===end===
 566 @example
 567 (%i1) makegamma (pochhammer (x, n));
 568                           gamma(x + n)
 569 (%o1)                     ------------
 570                             gamma(x)
 571 (%i2) makegamma (pochhammer (1/2, 1/2));
 572                                 1
 573 (%o2)                       ---------
 574                             sqrt(%pi)
 575 @end example
 576
 577 Derivadas de símbolos de Pochhammer são fornecidas em termos de @code{psi}
 578 function.
 579
 580 @c ===beg===
 581 @c diff (pochhammer (x, n), x);
 582 @c diff (pochhammer (x, n), n);
 583 @c ===end===
 584 @example
 585 (%i1) diff (pochhammer (x, n), x);
 586 (%o1)             (x)  (psi (x + n) - psi (x))
 587                      n     0             0
 588 (%i2) diff (pochhammer (x, n), n);
 589 (%o2)                   (x)  psi (x + n)
 590                            n    0
 591 @end example
 592
 593 É preciso ser cuidadoso com expressões como (%o1); a diferença das
 594 funções @code{psi} possuem polinómios quando @code{@var{x} = -1, -2, .., -@var{n}}. Esses polinómios
 595 cacelam-se com factores em @code{pochhammer (@var{x}, @var{n})} fazendo da derivada um polinómio
 596 de grau @code{@var{n} - 1} quando @var{n} for um inteiro positivo.
 597
 598 O símbolo de Pochhammer é definido de ordens negativas até sua
 599 representação como um quociente de funções gama. Considere
 600
 601 @c ===beg===
 602 @c q : makegamma (pochhammer (x, n));
 603 @c sublis ([x=11/3, n= -6], q);
 604 @c ===end===
 605 @example
 606 (%i1) q : makegamma (pochhammer (x, n));
 607                           gamma(x + n)
 608 (%o1)                     ------------
 609                             gamma(x)
 610 (%i2) sublis ([x=11/3, n= -6], q);
 611                                729
 612 (%o2)                        - ----
 613                                2240
 614 @end example
 615
 616 Alternativamente, podemos tomar ese resultado directamente.
 617
 618 @c ===beg===
 619 @c pochhammer (11/3, -6);
 620 @c ===end===
 621 @example
 622 (%i1) pochhammer (11/3, -6);
 623                                729
 624 (%o1)                        - ----
 625                                2240
 626 @end example
 627
 628 A função passo de unidade é contínua à esquerda; dessa forma
 629
 630 @c ===beg===
 631 @c [unit_step (-1/10), unit_step (0), unit_step (1/10)];
 632 @c ===end===
 633 @example
 634 (%i1) [unit_step (-1/10), unit_step (0), unit_step (1/10)];
 635 (%o1)                       [0, 0, 1]
 636 @end example
 637
 638 Se precisar de uma função de degrau unitário que seja
 639 ou contínua à esquerda ou contínua à
 640 direita do zero, defina a sua própria função usando
 641 @code{signum}; por exemplo,
 642
 643 @c ===beg===
 644 @c xunit_step (x) := (1 + signum (x))/2$
 645 @c [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)];
 646 @c ===end===
 647 @example
 648 (%i1) xunit_step (x) := (1 + signum (x))/2$
 649
 650 (%i2) [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)];
 651                                 1
 652 (%o2)                       [0, -, 1]
 653                                 2
 654 @end example
 655
 656 Não redefina a própria @code{unit_step}; alguns código em @code{orthopoly}
 657 requerem que a função de passo de unidade seja contínua à esquerda.
 658
 659 @subsection Algorítmos
 660
 661 Geralmente, @code{orthopoly} faz avaliações simbólicas pelo uso de uma representação
 662 hipergeométrica de polinómios ortogonais. As funções
 663 hipegeométricas são avaliadas usando as funções (não documetadas) @code{hypergeo11}
 664 e @code{hypergeo21}. As excessões são as funções de Bessel metade inteiras
 665 e a função de Legendre associada de segundo tipo. As funções de Bessel metade inteiras são
 666 avaliadas usando uma representação explícita, e a função de Legendre
 667 associada de segundo tipo é avaliada usando recursividade.
 668
 669 Para avaliação em ponto flutuante, nós novamente convertemos muitas fuções em
 670 uma forma hipergeométrica; nós avaliamos as funções hipergeométricas usando
 671 recursividade para frente. Novamente, as excessões são as funções de Bessel metade inteiras
 672 e a função de Legendre associada de segundo tipo. Numericamente,
 673 as funções de Bessel meio inteiras são avaliadas usando o código SLATEC.
 674
 675 @node Definições para polinómios ortogonais,  , Introdução a polinómios ortogonais, orthopoly
 676 @section Definições para polinómios ortogonais
 677
 678 @deffn {Função} assoc_legendre_p (@var{n}, @var{m}, @var{x})
 679 As funções de Legendre associadas de primeiro tipo.
 680
 681 Referência: Abramowitz e Stegun, equações 22.5.37, página 779, 8.6.6
 682 (segunda equação), página 334, e 8.2.5, página 333.
 683 @end deffn
 684
 685 @deffn {Função} assoc_legendre_q (@var{n}, @var{m}, @var{x})
 686 A função de Legendre associada de segundo tipo.
 687
 688 Referência: Abramowitz e Stegun, equação 8.5.3 e 8.1.8.
 689 @end deffn
 690
 691 @deffn {Função} chebyshev_t (@var{n}, @var{x})
 692 A função de Chebyshev de primeiro tipo.
 693
 694 Referência: Abramowitz e Stegun, equação 22.5.47,página 779.
 695 @end deffn
 696
 697 @deffn {Função} chebyshev_u (@var{n}, @var{x})
 698 A função de Chebyshev do segundo tipo.
 699
 700 Referência: Abramowitz e Stegun, equação 22.5.48,página 779.
 701 @end deffn
 702
 703 @deffn {Função} gen_laguerre (@var{n}, @var{a}, @var{x})
 704 O poli@^omio generalizado de Laguerre.
 705
 706 Referência: Abramowitz e Stegun, equação 22.5.54,página 780.
 707 @end deffn
 708
 709 @deffn {Função} hermite (@var{n}, @var{x})
 710 O polinómio de Hermite.
 711
 712 Referência: Abramowitz e Stegun, equação 22.5.55,página 780.
 713 @end deffn
 714
 715 @deffn {Função} intervalp (@var{e})
 716 Retorna @code{true} se a entrada for um intervalo e retorna @code{false} se não for.
 717 @end deffn
 718
 719 @deffn {Função} jacobi_p (@var{n}, @var{a}, @var{b}, @var{x})
 720 o polinómio de Jacobi.
 721
 722 Os polinómios de Jacobi são actualmente definidos para todo
 723 @var{a} e @var{b}; todavia, o peso do polinómio de
 724 Jacobi @code{(1 - @var{x})^@var{a} (1 + @var{x})^@var{b}} não é integrável para @code{@var{a} <= -1} ou
 725 @code{@var{b} <= -1}.
 726
 727 Referência: Abramowitz e Stegun, equação 22.5.42,página 779.
 728 @end deffn
 729
 730 @deffn {Função} laguerre (@var{n}, @var{x})
 731 O polinómio de Laguerre.
 732
 733 Referência: Abramowitz e Stegun, equatções 22.5.16 e 22.5.54,página 780.
 734 @end deffn
 735
 736 @deffn {Função} legendre_p (@var{n}, @var{x})
 737 O polinómio de Legendre de primeiro tipo.
 738
 739 Referência: Abramowitz e Stegun, equações 22.5.50 e 22.5.51,página 779.
 740 @end deffn
 741
 742 @deffn {Função} legendre_q (@var{n}, @var{x})
 743 O polinómio de Legendre de primeiro tipo.
 744
 745 Referência: Abramowitz e Stegun, equações 8.5.3 e 8.1.8.
 746 @end deffn
 747
 748 @deffn {Função} orthopoly_recur (@var{f}, @var{args})
 749 Retorna uma relação recursiva para a família de funções ortogonais
 750 @var{f} com argumentos @var{args}. A recursividade é com
 751 relação ao grau do polinómio.
 752
 753 @c ===beg===
 754 @c orthopoly_recur (legendre_p, [n, x]);
 755 @c ===end===
 756 @example
 757 (%i1) orthopoly_recur (legendre_p, [n, x]);
 758                 (2 n - 1) P     (x) x + (1 - n) P     (x)
 759                            n - 1                 n - 2
 760 (%o1)   P (x) = -----------------------------------------
 761          n                          n
 762 @end example
 763
 764 O segundo argumento a @code{orthopoly_recur} deve ser uma lista com o
 765 número correcto de argumentos para a função @var{f}; se o número de argumentos não for o correcto,
 766 Maxima sinaliza com um erro.
 767
 768 @c ===beg===
 769 @c orthopoly_recur (jacobi_p, [n, x]);
 770 @c ===end===
 771 @example
 772 (%i1) orthopoly_recur (jacobi_p, [n, x]);
 773
 774 Function jacobi_p needs 4 arguments, instead it received 2
 775  -- an error.  Quitting.  To debug this try debugmode(true);
 776 @end example
 777
 778 Adicionalmente, quando @var{f} não for o nome de uma das
 779 famílias de polinómios ortogonais, um erro é sinalizado.
 780
 781 @c ===beg===
 782 @c orthopoly_recur (foo, [n, x]);
 783 @c ===end===
 784 @example
 785 (%i1) orthopoly_recur (foo, [n, x]);
 786
 787 A recursion relation for foo isn't known to Maxima
 788  -- an error.  Quitting.  To debug this try debugmode(true);
 789 @end example
 790 @end deffn
 791
 792 @defvr {Variable} orthopoly_returns_intervals
 793 Valor por omissão: @code{true}
 794
 795 Quando @code{orthopoly_returns_intervals} for @code{true}, resultados em ponto flutuante são retornados na
 796 forma @code{interval (@var{c}, @var{r})}, onde @var{c} é o centro de um intervalo
 797 e @var{r} é seu raio. O centro pode ser um número complexo; nesse
 798 caso, o intervalo é um disco no plano complexo.
 799 @end defvr
 800
 801 @deffn {Função} orthopoly_weight (@var{f}, @var{args})
 802
 803 Retorna uma lista de três elementos; o primeiro elemento é
 804 a fórmula do peso para a família de polinómios ortogonais
 805 @var{f} com argumentos fornecidos pela lista @var{args}; os
 806 segundos e terceiros elementos fornecem os pontos finais inferior e superior
 807 do intervalo de ortogonalidade. Por exemplo,
 808
 809 @c ===beg===
 810 @c w : orthopoly_weight (hermite, [n, x]);
 811 @c integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]);
 812 @c ===end===
 813 @example
 814 (%i1) w : orthopoly_weight (hermite, [n, x]);
 815                             2
 816                          - x
 817 (%o1)                 [%e    , - inf, inf]
 818 (%i2) integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]);
 819 (%o2)                           0
 820 @end example
 821
 822 A variável principal de @var{f} deve ser um símbolo; Se não for, Maxima
 823 sinaliza com um erro.
 824
 825 @end deffn
 826
 827 @deffn {Função} pochhammer (@var{n}, @var{x})
 828 O símbolo de Pochhammer. Para inteiros não negativos @var{n} com
 829 @code{@var{n} <= pochhammer_max_index}, a expressão @code{pochhammer (@var{x}, @var{n})}
 830 avalia para o produto @code{@var{x} (@var{x} + 1) (@var{x} + 2) ... (@var{x} + n - 1)}
 831 when @code{@var{n} > 0} e
 832 para 1 quando @code{@var{n} = 0}. Para valores negativos de @var{n},
 833 @code{pochhammer (@var{x}, @var{n})} é definido como @code{(-1)^@var{n} / pochhammer (1 - @var{x}, -@var{n})}.
 834 Dessa forma
 835
 836 @c ===beg===
 837 @c pochhammer (x, 3);
 838 @c pochhammer (x, -3);
 839 @c ===end===
 840 @example
 841 (%i1) pochhammer (x, 3);
 842 (%o1)                   x (x + 1) (x + 2)
 843 (%i2) pochhammer (x, -3);
 844                                  1
 845 (%o2)               - -----------------------
 846                       (1 - x) (2 - x) (3 - x)
 847 @end example
 848
 849 Para converter um símbolo de Pochhammer em um quociente de funções gama,
 850 (veja Abramowitz e Stegun, equação 6.1.22) use @code{makegamma}; por exemplo
 851
 852 @c ===beg===
 853 @c makegamma (pochhammer (x, n));
 854 @c ===end===
 855 @example
 856 (%i1) makegamma (pochhammer (x, n));
 857                           gamma(x + n)
 858 (%o1)                     ------------
 859                             gamma(x)
 860 @end example
 861
 862 Quando @var{n} exceder @code{pochhammer_max_index} ou quando @var{n}
 863 for simbólico, @code{pochhammer} retorna uma forma substantiva.
 864
 865 @c ===beg===
 866 @c pochhammer (x, n);
 867 @c ===end===
 868 @example
 869 (%i1) pochhammer (x, n);
 870 (%o1)                         (x)
 871                                  n
 872 @end example
 873 @end deffn
 874
 875 @defvr {Variável} pochhammer_max_index
 876 Valor por omissão: 100
 877
 878 @code{pochhammer (@var{n}, @var{x})} expande para um produto se e somente se
 879 @code{@var{n} <= pochhammer_max_index}.
 880
 881 Exemplos:
 882
 883 @c ===beg===
 884 @c pochhammer (x, 3), pochhammer_max_index : 3;
 885 @c pochhammer (x, 4), pochhammer_max_index : 3;
 886 @c ===end===
 887 @example
 888 (%i1) pochhammer (x, 3), pochhammer_max_index : 3;
 889 (%o1)                   x (x + 1) (x + 2)
 890 (%i2) pochhammer (x, 4), pochhammer_max_index : 3;
 891 (%o2)                         (x)
 892                                  4
 893 @end example
 894
 895 Referência: Abramowitz e Stegun, equação 6.1.16,página 256.
 896 @end defvr
 897
 898 @deffn {Função} spherical_bessel_j (@var{n}, @var{x})
 899 A Função de Bessel esférica de primeiro tipo.
 900
 901 Referência: Abramowitz e Stegun, equações 10.1.8,página 437 e 10.1.15,página 439.
 902 @end deffn
 903
 904 @deffn {Função} spherical_bessel_y (@var{n}, @var{x})
 905 A Função de Bessel esférica de segundo tipo.
 906
 907 Referência: Abramowitz e Stegun, equações 10.1.9,página 437 e 10.1.15,página 439.
 908 @end deffn
 909
 910 @deffn {Função} spherical_hankel1 (@var{n}, @var{x})
 911 A Função de Hankel esférica de
 912 primeiro tipo.
 913
 914 Referência: Abramowitz e Stegun, equação 10.1.36,página 439.
 915 @end deffn
 916
 917 @deffn {Função} spherical_hankel2 (@var{n}, @var{x})
 918 A Função de Hankel esférica de segundo tipo.
 919
 920 Referência: Abramowitz e Stegun, equação 10.1.17,página 439.
 921 @end deffn
 922
 923 @deffn {Função} spherical_harmonic (@var{n}, @var{m}, @var{x}, @var{y})
 924 A função arm@^onica esférica.
 925
 926 Referência: Merzbacher 9.64.
 927 @end deffn
 928
 929 @deffn {Função} unit_step (@var{x})
 930 A função de passo de unidade contínua à esquerda; dessa forma
 931 @code{unit_step (@var{x})} tende para @code{@var{x} <= 0} e é igual a
 932 1 para @code{@var{x} > 0}.
 933
 934 Se quiser uma função de degrau unitário que tome o
 935 valor 1/2 em zero, use @code{(1 + signum (@var{x}))/2}.
 936 @end deffn
 937
 938 @deffn {Função} ultraspherical (@var{n}, @var{a}, @var{x})
 939 A função polin@^omial ultraesférica (também conhecida como função polinomial de Gegenbauer).
 940
 941 Referência: Abramowitz e Stegun, equação 22.5.46,página 779.
 942 @end deffn
 943