doc/info/pt_BR/orthopoly.texi

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