@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /orthopoly.texi/1.11/Sat Jun  2 00:13:29 2007//
@menu
* Introdu@value{cedilha}@~{a}o a polin@^{o}mios ortogonais::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para polin@^{o}mios ortogonais::
@end menu

@node Introdu@value{cedilha}@~{a}o a polin@^{o}mios ortogonais, Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para polin@^{o}mios ortogonais, orthopoly, orthopoly
@section Introdu@value{cedilha}@~{a}o a polin@^{o}mios ortogonais

@code{orthopoly} @'{e} um pacote para avalia@value{cedilha}@~{a}o simb@'{o}lica e num@'{e}rica de
muitos tipos de polin@^{o}mios ortogonais, incluindo polin@^{o}mios de Chebyshev,
Laguerre, Hermite, Jacobi, Legendre, e ultraesf@'{e}rico
(Gegenbauer). Adicionalmentey, @code{orthopoly} inclui suporte fun@value{cedilha}@~{o}es esf@'{e}ricas segundo o crit@'{e}rio de
Bessel, esf@'{e}ricas segundo o crit@'{e}rio de Hankel, e fun@value{cedilha}@~{o}es harm@^{o}nica esf@'{e}ricas.

Em sua maior parte, @code{orthopoly} segue as conven@value{cedilha}@~{o}es de Abramowitz e Stegun
@i{Handbook of Mathematical Functions}, Chapter 22 (10th printing, December 1972);
adicionalmente, usamos Gradshteyn e Ryzhik, 
@i{Table of Integrals, Series, and Products} (1980 corrected and 
enlarged edition), e Eugen Merzbacher @i{Quantum Mechanics} (2nd edition, 1970).

@c INSTALLATION INSTRUCTIONS NO LONGER RELEVANT
@c BUT MAYBE SOME OF THESE FILES SHOULD BE MENTIONED IN ANOTHER CONTEXT
@c This will create a directory @code{orthopoly_x} (again x is the release 
@c identifier) that contains the source file @code{orthopoly.lisp}, user 
@c documentation in html and texi formats, a sample maxima initialization file 
@c @code{orthopoly-init.lisp}, a README file, a testing routine 
@c @code{test_orthopoly.mac}, and two demonstration files.

@c Start Maxima and compile orthopoly. To do this, use the command
@c 
@c (c1) compile_file("orthopoly.lisp");

Barton Willis da University de Nebraska e Kearney (UNK) escreveu
o pacote @code{orthopoly} e sua documeta@value{cedilha}@~{a}o. O pacote 
@'{e} liberado segundo a licen@value{cedilha}a p@'{u}blica geral GNU (GPL).

@subsection Iniciando com orthopoly

@code{load (orthopoly)} torna o pacote @code{orthopoly} dispon@'{i}vel para uso.

Para encontrar o polin@^{o}mio de Legendre de terceira ordem,

@c ===beg===
@c legendre_p (3, x);
@c ===end===
@example
(%i1) legendre_p (3, x);
                      3             2
             5 (1 - x)    15 (1 - x)
(%o1)      - ---------- + ----------- - 6 (1 - x) + 1
                 2             2
@end example

Para expressar esse polin@^{o}mio como uma soma de pot@^{e}ncias de @var{x}, aplique @var{ratsimp} ou @var{rat}
para o resultado anterior.

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c [ratsimp (%), rat (%)];
@c ===end===
@example
(%i2) [ratsimp (%), rat (%)];
                        3           3
                     5 x  - 3 x  5 x  - 3 x
(%o2)/R/            [----------, ----------]
                         2           2
@end example

Alternativamente, fa@value{cedilha}a o segundo argumento  para @code{legendre_p} (sua vari@'{a}vel ``principal'') 
uma express@~{a}o racional can@^{o}nica (CRE)  usando @code{rat(x)} em lugar de somente @code{x}.

@c ===beg===
@c legendre_p (3, rat (x));
@c ===end===
@example
(%i1) legendre_p (3, rat (x));
                              3
                           5 x  - 3 x
(%o1)/R/                   ----------
                               2
@end example

Para avalia@value{cedilha}@~{a}o em ponto flutuante, @code{orthopoly} usa uma an@'{a}lise de erro durante a execu@value{cedilha}@~{a}o
para estimar uma associa@value{cedilha}@~{a}o superior para o erro. Por exemplo,

@c ===beg===
@c jacobi_p (150, 2, 3, 0.2);
@c ===end===
@example
(%i1) jacobi_p (150, 2, 3, 0.2);
(%o1) interval(- 0.062017037936715, 1.533267919277521E-11)
@end example

intervalos possuem a forma @code{interval (@var{c}, @var{r})}, onde @var{c} @'{e} o
centro e @var{r} @'{e} o raio do intervalo. Uma vez que Maxima
n@~{a}o suporta aritm@'{e}tica sobre intervalos, em algumas situa@value{cedilha}@~{o}es, tais
como em gr@'{a}ficos, voc@^{e} vai querer suprimir o erro e sair somente com o
centro do intervalo. Para fazer isso, escolha a vari@'{a}vel de
op@value{cedilha}@~{a}o @code{orthopoly_returns_intervals} para @code{false}.

@c ===beg===
@c orthopoly_returns_intervals : false;
@c jacobi_p (150, 2, 3, 0.2);
@c ===end===
@example
(%i1) orthopoly_returns_intervals : false;
(%o1)                         false
(%i2) jacobi_p (150, 2, 3, 0.2);
(%o2)                  - 0.062017037936715
@end example

Veja a se@value{cedilha}@~{a}o @pxref{Avalia@value{cedilha}@~{a}o em Ponto Flutuante} para maiores informa@value{cedilha}@~{o}esfor more information.

Muitas fun@value{cedilha}@~{o}es em @code{orthopoly} possuem uma propriedade @code{gradef}; dessa forma

@c ===beg===
@c diff (hermite (n, x), x);
@c diff (gen_laguerre (n, a, x), x);
@c ===end===
@example
(%i1) diff (hermite (n, x), x);
(%o1)                     2 n H     (x)
                               n - 1
(%i2) diff (gen_laguerre (n, a, x), x);
              (a)               (a)
           n L   (x) - (n + a) L     (x) unit_step(n)
              n                 n - 1
(%o2)      ------------------------------------------
                               x
@end example

A fun@value{cedilha}@~{a}o de um @'{u}nico passo no segundo exemplo previne um erro que poderia
de outra forma surgir atrav@'{e}s da avalia@value{cedilha}@~{a}o de @var{n} para 0.

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c ev (%, n = 0);
@c ===end===
@example
(%i3) ev (%, n = 0);
(%o3)                           0
@end example

A propriedade @code{gradef} somente aplica para a vari@'{a}vel ``principal''; dderivadas com
rela@value{cedilha}@~{a}o a outros argumentos usualmente resultam em uma mensagem de erro; por exemplo

@c ===beg===
@c diff (hermite (n, x), x);
@c diff (hermite (n, x), n);
@c ===end===
@example
(%i1) diff (hermite (n, x), x);
(%o1)                     2 n H     (x)
                               n - 1
(%i2) diff (hermite (n, x), n);

Maxima doesn't know the derivative of hermite with respect the first argument
 -- an error.  Quitting.  To debug this try debugmode(true);
@end example

Geralmente, fun@value{cedilha}@~{o}es em @code{orthopoly} mapeiam sobre listas e matrizes. Para
o mapeamento para avalia@value{cedilha}@~{a}o total, as vari@'{a}veis de op@value{cedilha}@~{a}o 
@code{doallmxops} e @code{listarith} devem ambas serem @code{true} (o valor padr@~{a}o).
Para ilustrar o mapeamento sobre matrizes, considere

@c ===beg===
@c hermite (2, x);
@c m : matrix ([0, x], [y, 0]);
@c hermite (2, m);
@c ===end===
@example
(%i1) hermite (2, x);
                                     2
(%o1)                    - 2 (1 - 2 x )
(%i2) m : matrix ([0, x], [y, 0]);
                            [ 0  x ]
(%o2)                       [      ]
                            [ y  0 ]
(%i3) hermite (2, m);
               [                             2  ]
               [      - 2        - 2 (1 - 2 x ) ]
(%o3)          [                                ]
               [             2                  ]
               [ - 2 (1 - 2 y )       - 2       ]
@end example

No segundo exemplo, o elemento @code{i, j} do valor
@'{e} @code{hermite (2, m[i,j])}; isso n@~{a}o @'{e} o mesmo que calcular
@code{-2 + 4 m . m}, como visto no pr@'{o}ximo exemplo.

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c -2 * matrix ([1, 0], [0, 1]) + 4 * m . m;
@c ===end===
@example
(%i4) -2 * matrix ([1, 0], [0, 1]) + 4 * m . m;
                    [ 4 x y - 2      0     ]
(%o4)               [                      ]
                    [     0      4 x y - 2 ]
@end example

Se voc@^{e} avaliar uma fun@value{cedilha}@~{a}o em um ponto fora do seu dom@'{i}nio, geralmente
@code{orthopoly} retorna uma fun@value{cedilha}@~{a}o n@~{a}o avaliada. Por exemplo,

@c ===beg===
@c legendre_p (2/3, x);
@c ===end===
@example
(%i1) legendre_p (2/3, x);
(%o1)                        P   (x)
                              2/3
@end example

@code{orthopoly} suporta tradu@value{cedilha}@~{a}o em TeX; @code{orthopoly} tamb@'{e}m faz sa@'{i}das
bidimensionais em um terminal.

@c ===beg===
@c spherical_harmonic (l, m, theta, phi);
@c tex (%);
@c jacobi_p (n, a, a - b, x/2);
@c tex (%);
@c ===end===
@example
(%i1) spherical_harmonic (l, m, theta, phi);
                          m
(%o1)                    Y (theta, phi)
                          l
(%i2) tex (%);
$$Y_@{l@}^@{m@}\left(\vartheta,\varphi\right)$$
(%o2)                         false
(%i3) jacobi_p (n, a, a - b, x/2);
                          (a, a - b) x
(%o3)                    P          (-)
                          n          2
(%i4) tex (%);
$$P_@{n@}^@{\left(a,a-b\right)@}\left(@{@{x@}\over@{2@}@}\right)$$
(%o4)                         false
@end example

@subsection Limitations

Quando uma express@~{a}o envolve muitos polin@^{o}mios ortogonais com
ordens simb@'{o}licas, @'{e} poss@'{i}vel que a express@~{a}o atualmente
tenda para zero, e ainda ocorre tamb@'{e}m que Maxima estar incapacitado de simplificar essa express@~{a}o para zero. Se voc@^{e}
faz uma divis@~{a}o por tal quantidade que tende a zero, voc@^{e} pode estar em apuros. Por exemplo,
a seguinte express@~{a}o tende para zero para inteiros @var{n} maiores que 1, e ainda ocorre tamb@'{e}m que  Maxima
est@'{a} incapacitado de simplificar essa express@~{a}o para zero.

@c ===beg===
@c (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x) + (1 - n) * legendre_p (n - 2, x);
@c ===end===
@example
(%i1) (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x) + (1 - n) * legendre_p (n - 2, x);
(%o1)  (2 n - 1) P     (x) x - n P (x) + (1 - n) P     (x)
                  n - 1           n               n - 2
@end example

Para um @var{n} espec@'{i}fico, podemos reduzir a express@~{a}o a zero.

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c ev (% ,n = 10, ratsimp);
@c ===end===
@example
(%i2) ev (% ,n = 10, ratsimp);
(%o2)                           0
@end example

Geralmente, a forma polinomial de um polin@^{o}mio ortogonal esteja adequada de forma hostil
para avalia@value{cedilha}ao em ponto flutuante. Aqui est@'{a} um exemplo.

@c ACTUALLY NEEDS load(orthopoly); BEFORE ANYTHING ELSE
@c ===beg===
@c p : jacobi_p (100, 2, 3, x)$
@c subst (0.2, x, p);
@c jacobi_p (100, 2, 3, 0.2);
@c float(jacobi_p (100, 2, 3, 2/10));
@c ===end===
@example 
(%i1) p : jacobi_p (100, 2, 3, x)$

(%i2) subst (0.2, x, p);
(%o2)                3.4442767023833592E+35
(%i3) jacobi_p (100, 2, 3, 0.2);
(%o3)  interval(0.18413609135169, 6.8990300925815987E-12)
(%i4) float(jacobi_p (100, 2, 3, 2/10));
(%o4)                   0.18413609135169
@end example

O verdadeiro valor est@'{a} em torno de 0.184; ess calculo suporta erro de 
cancelamento por extremo subtrativo.Expandindo o polin@^{o}mio e ent@~{a}o
avaliando, fornecendo um melhor resultado.
@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c p : expand (p)$
@c subst (0.2, x, p);
@c ===end===
@example
(%i5) p : expand(p)$
(%i6) subst (0.2, x, p);
(%o6) 0.18413609766122982
@end example

Essa n@~{a}o @'{e} uma regra geral; expandindo o polin@^{o}mio n@~{a}o resulta sempre 
em express@~{o}es que s@~{a}o melhores adaptadas a avalia@value{cedilha}@~{a}o num@'{e}rica.
Com grande folga, o melhor caminho para fazer avalia@value{cedilha}@~{a}o num@'{e}rica @'{e} fazer um ou mais
argumentos da fun@value{cedilha}@~{a}o serem n@'{u}meros em ponto flutuante. Em fun@value{cedilha}@~{a}o disso, 
algor@'{i}tmos especializados em ponto flutuante s@~{a}o usados para avalia@value{cedilha}@~{a}o.

A fun@value{cedilha}@~{a}o @code{float} do Maxima @'{e} at@'{e} certo ponto indiscriminada; se voc@^{e} aplicar 
@code{float} a uma express@~{a}o envolvendo um polin@^{o}mio ortogonal com um
grau simb@'{o}lico ou um par@^{a}metro de ordem, esses par@^{a}metos (inteiros) podem ser 
convertido em n@'{u}meros em ponto flutuante; ap@'{o}s o que, a express@~{a}o n@~{a}o ir@'{a} avaliar 
completamente. Considere

@c ===beg===
@c assoc_legendre_p (n, 1, x);
@c float (%);
@c ev (%, n=2, x=0.9);
@c ===end===
@example
(%i1) assoc_legendre_p (n, 1, x);
                               1
(%o1)                         P (x)
                               n
(%i2) float (%);
                              1.0
(%o2)                        P   (x)
                              n
(%i3) ev (%, n=2, x=0.9);
                             1.0
(%o3)                       P   (0.9)
                             2
@end example

A express@~{a}o em (%o3) n@~{a}o ir@'{a} avaliar para um n@'{u}mero em ponto flutuante; @code{orthopoly} n@~{a}o
reconhece valores em ponto flutuante em lugares onde deve haver valores inteiros. Similarmente, 
avalia@value{cedilha}@~{a}o num@'{e}rica da fun@value{cedilha}@~{a}o @code{pochhammer} para ordens que
excedam @code{pochhammer_max_index} pode ser perturbador; considere

@c ===beg===
@c x :  pochhammer (1, 10), pochhammer_max_index : 5;
@c ===end===
@example
(%i1) x :  pochhammer (1, 10), pochhammer_max_index : 5;
(%o1)                         (1)
                                 10
@end example

Aplicando @code{float} n@~{a}o avalia @var{x} para um n@'{u}mero em ponto flutuante

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c float (x);
@c ===end===
@example
(%i2) float (x);
(%o2)                       (1.0)
                                 10.0
@end example

Para avaliar @var{x} para um n@'{u}mero em ponto flutuante, voc@^{e} ir@'{a} precisar associar
@code{pochhammer_max_index} a 11 ou mais e aplicar @code{float} a @var{x}.

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c float (x), pochhammer_max_index : 11;
@c ===end===
@example
(%i3) float (x), pochhammer_max_index : 11;
(%o3)                       3628800.0
@end example

O valor padr@~{a}o de @code{pochhammer_max_index} @'{e} 100;
modifique esse valor ap@'{o}s chama @code{orthopoly}.

Finalmente, tenha consci@^{e}ncia que os livros citados nas refer@^{e}ncias adotam diferentes defini@value{cedilha}@~{o}es de 
polin@^{o}mios ortogonais; geralmente adotamos as conven@value{cedilha}@~{o}es 
citadas nas conven@value{cedilha}@~{o}es de Abramowitz e Stegun.

Antes de voc@^{e} suspeitar de um erro no pacote @code{orthopoly}, verifique alguns casos especiais 
para determinar se suas defini@value{cedilha}@~{o}es coincidem com aquelas usadas por @code{orthopoly}. 
Definitions muitas vezes diferem por uma normaliza@value{cedilha}@~{a}o; ocasionalmente, autores
utilizam vers@~{o}es ``modificadas'' das fun@value{cedilha}@~{o}es que fazem a fam@'{i}lia
ortogonal sobre um intervalo diferente do intervalo @math{(-1, 1)}. Para definir, por exemplo,
um polin@^{o}mio de Legendre que @'{e} ortogonal a @math{(0, 1)}, defina

@c ===beg===
@c shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$
@c shifted_legendre_p (2, rat (x));
@c legendre_p (2, rat (x));
@c ===end===
@example
(%i1) shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$

(%i2) shifted_legendre_p (2, rat (x));
                            2
(%o2)/R/                 6 x  - 6 x + 1
(%i3) legendre_p (2, rat (x));
                               2
                            3 x  - 1
(%o3)/R/                    --------
                               2
@end example

@anchor{Avalia@value{cedilha}@~{a}o em Ponto Flutuante}
@subsection Avalia@value{cedilha}@~{a}o em Ponto Flutuante

Muitas fun@value{cedilha}@~{o}es em @code{orthopoly} utilizam an@'{a}lise de erro durante a execu@value{cedilha}@~{a}o para 
estimar o erro em avalia@value{cedilha}@~{o}es em ponto flutuante; as 
exce@value{cedilha}@~{o}es s@~{a}o fun@value{cedilha}@~{o}es de Bessel esf@'{e}ricas e os polin@^{o}mios associados de
Legendre do segundo tipo. Para avalia@value{cedilha}@~{o}es num@'{e}ricas, as fun@value{cedilha}@~{o}es 
de Bessel esf@'{e}ricas chamam fun@value{cedilha}@~{o}es da cole@value{cedilha}@~{a}o de programas @code{SLATEC}. Nenhum m@'{e}todo especializado @'{e} usado
para avalia@value{cedilha}@~{a}o num@'{e}rica dos polin@^{o}mios associados  de Legendre do
segundo tipo.

A an@'{a}lise de erro durante a execu@value{cedilha}@~{a}o ignora erros que s@~{a}o de segunda ordem ou maior
na m@'{a}quina (tamb@'{e}m conhecida como perda de algarismos). A an@'{a}lise de erro durante a execu@value{cedilha}@~{a}o tamb@'{e}m
ignora alguns poucos outros tipos de erro. @'{E} poss@'{i}vel (embora n@~{a}o prov@'{a}vel) 
que o erro atual exceda o estimado.

Intervalos possuem a forma @code{interval (@var{c}, @var{r})}, onde @var{c} @'{e} o centro 
do intervalo e @var{r} @'{e} seu raio. O 
centro de um intervalo pode sr um n@'{u}mero complexo, e o raio @'{e} sempre um n@'{u}mero real positivo.

Aqui est@'{a} um exemplo.

@c ===beg===
@c fpprec : 50$
@c y0 : jacobi_p (100, 2, 3, 0.2);
@c y1 : bfloat (jacobi_p (100, 2, 3, 1/5));
@c ===end==

@example
(%i1) fpprec : 50$

(%i2) y0 : jacobi_p (100, 2, 3, 0.2);
(%o2) interval(0.1841360913516871, 6.8990300925815987E-12)
(%i3) y1 : bfloat (jacobi_p (100, 2, 3, 1/5));
(%o3) 1.8413609135168563091370224958913493690868904463668b-1
@end example

Vamos testar o quanto o erro atual @'{e} @'{e} menor que o erro estimado

@c CONTINUING PREVIOUS EXAMPLE HERE
@c ===beg===
@c is (abs (part (y0, 1) - y1) < part (y0, 2));
@c ===end===
@example
(%i4) is (abs (part (y0, 1) - y1) < part (y0, 2));
(%o4)                         true
@end example

Realmente, por esse exemplo o erro estimado @'{e} um maior que
o erro verdadeiro.

Maxima n@~{a}o suporta aritm@'{e}tica sobre intervalos.

@c ===beg===
@c legendre_p (7, 0.1) + legendre_p (8, 0.1);
@c ===end===
@example
(%i1) legendre_p (7, 0.1) + legendre_p (8, 0.1);
(%o1) interval(0.18032072148437508, 3.1477135311021797E-15)
        + interval(- 0.19949294375000004, 3.3769353084291579E-15)
@end example

Um usu@'{a}rio pode definir operadores aritm@'{e}ticos que fazem matem@'{a}tica de intervalos. Para
definir adi@value{cedilha}@~{a}o de intervalos, podemos definir

@c ===beg===
@c infix ("@+")$
@c "@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2) + part (y, 2))$
@c legendre_p (7, 0.1) @+ legendre_p (8, 0.1);
@c ===end===
@example
(%i1) infix ("@@+")$

(%i2) "@@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2) + part (y, 2))$

(%i3) legendre_p (7, 0.1) @@+ legendre_p (8, 0.1);
(%o3) interval(- 0.019172222265624955, 6.5246488395313372E-15)
@end example

As rotinas eseciais em ponto flutuante s@~{a}o chamadas quando os argumentos
forem complexos.  Por exemplo,

@c ===beg===
@c legendre_p (10, 2 + 3.0*%i);
@c ===end===
@example
(%i1) legendre_p (10, 2 + 3.0*%i);
(%o1) interval(- 3.876378825E+7 %i - 6.0787748E+7, 
                                           1.2089173052721777E-6)
@end example

Let's compare this to the true value.

@c ===beg===
@c float (expand (legendre_p (10, 2 + 3*%i)));
@c ===end===
@example
(%i1) float (expand (legendre_p (10, 2 + 3*%i)));
(%o1)          - 3.876378825E+7 %i - 6.0787748E+7
@end example

Adicionalmente, quando os argumentos forem grandes n@'{u}meros em ponto flutuante, as rotinas especiais
de ponto flutuante s@~{a}o chamadas; todavia, tos grandes n@'{u}meros em ponto flutuante s@~{a}o convertidos para n@'{u}meros em ponto flutuante de dupla precis@~{a}o
e o resultado final @'{e} n@'{u}mero em ponto flutuante de precis@~{a}o dupla.

@c ===beg===
@c ultraspherical (150, 0.5b0, 0.9b0);
@c ===end===
@example
(%i1) ultraspherical (150, 0.5b0, 0.9b0);
(%o1) interval(- 0.043009481257265, 3.3750051301228864E-14)
@end example

@subsection Gr@'{a}ficos e @code{orthopoly}

Para montar gr@'{a}ficos de express@~{o}es que envolvem polin@^{o}mios ortogonais, voc@^{e} 
deve azer duas coisas:
@enumerate
@item 
Escolher a vari@'{a}vel de op@value{cedilha}@~{a}o @code{orthopoly_returns_intervals} para @code{false},
@item
Colocar ap@'{o}strofo em qualquer chamada a fun@value{cedilha}@~{o}es do pacote @code{orthopoly}.
@end enumerate
Se chamadas a fun@value{cedilha}@~{o}es n@~{a}o receberem ap@'{o}strofo, Maxima ir@'{a} avali@'{a}-las para polin@^{o}mios antes 
de montar o gr@'{a}fico; conseq@"{u}@^{e}ntemente, as rotinas especializadas em ponto flutuante n@~{a}o ser@~{a}o chamadas.
Aqui est@'{a} um exemplo de como montar o gr@'{a}fico de uma express@~{a}o que envolve
um polin@^{o}mio de Legendre.

@c ===beg===
@c plot2d ('(legendre_p (5, x)), [x, 0, 1]), orthopoly_returns_intervals : false;
@c ===end===
@example
(%i1) plot2d ('(legendre_p (5, x)), [x, 0, 1]), orthopoly_returns_intervals : false;
(%o1)
@end example

@ifnotinfo
@image{../figures/orthopoly1,8cm}
@end ifnotinfo

A express@~{a}o @i{completa} @code{legendre_p (5, x)} recebe ap@'{o}strofo; isso @'{e} 
diferente de apenas colocar ap@'{o}strofo no nome da fun@value{cedilha}@~{a}o usando @code{'legendre_p (5, @var{x})}.

@subsection Fun@value{cedilha}@~{o}es Diversas

O pacote @code{orthopoly} define o
s@'{i}bolo de Pochhammer e uma fun@value{cedilha}@~{a}o de passo de unidade. @code{orthopoly} utiliza 
a fun@value{cedilha}@~{a}o delta de Kronecker e a fun@value{cedilha}@~{a}o de passo de unidade em
declara@value{cedilha}@~{o}es @code{gradef}.

Para converter os s@'{i}mbolos Pochhammer em quocientes da fun@value{cedilha}@~{o}es gama,
use @code{makegamma}.

@c ===beg===
@c makegamma (pochhammer (x, n));
@c makegamma (pochhammer (1/2, 1/2));
@c ===end===
@example
(%i1) makegamma (pochhammer (x, n));
                          gamma(x + n)
(%o1)                     ------------
                            gamma(x)
(%i2) makegamma (pochhammer (1/2, 1/2));
                                1
(%o2)                       ---------
                            sqrt(%pi)
@end example

Derivadas de s@'{i}mbolos de Pochhammer s@~{a}o fornecidas em termos de @code{psi}
function.

@c ===beg===
@c diff (pochhammer (x, n), x);
@c diff (pochhammer (x, n), n);
@c ===end===
@example
(%i1) diff (pochhammer (x, n), x);
(%o1)             (x)  (psi (x + n) - psi (x))
                     n     0             0
(%i2) diff (pochhammer (x, n), n);
(%o2)                   (x)  psi (x + n)
                           n    0
@end example

Voc@^{e}precisa ser cuidadoso com express@~{o}es como (%o1); a diferen@value{cedilha}a das
fun@value{cedilha}@~{o}es @code{psi} possuem polin@^{o}mios quando @code{@var{x} = -1, -2, .., -@var{n}}. Esses polin@^{o}mios
cacelam-se com fatores em @code{pochhammer (@var{x}, @var{n})} fazendo da derivada um polin@^{o}mio
de grau @code{@var{n} - 1} quando @var{n} for um inteiro positivo.

O s@'{i}mbolo de Pochhammer @'{e} definido de ordens negativas at@'{e} sua
representa@value{cedilha}@~{a}o como um quociente de fun@value{cedilha}@~{o}es gama. Considere

@c ===beg===
@c q : makegamma (pochhammer (x, n));
@c sublis ([x=11/3, n= -6], q);
@c ===end===
@example
(%i1) q : makegamma (pochhammer (x, n));
                          gamma(x + n)
(%o1)                     ------------
                            gamma(x)
(%i2) sublis ([x=11/3, n= -6], q);
                               729
(%o2)                        - ----
                               2240
@end example

Alternativamente, podemos tomar ese resultado diretamente.

@c ===beg===
@c pochhammer (11/3, -6);
@c ===end===
@example
(%i1) pochhammer (11/3, -6);
                               729
(%o1)                        - ----
                               2240
@end example

A fun@value{cedilha}@~{a}o passo de unidade @'{e} cont@'{i}nua @`a esquerda; dessa forma

@c ===beg===
@c [unit_step (-1/10), unit_step (0), unit_step (1/10)];
@c ===end===
@example
(%i1) [unit_step (-1/10), unit_step (0), unit_step (1/10)];
(%o1)                       [0, 0, 1]
@end example

Se voc@^{e} precisa de uma fun@value{cedilha}@~{a}o de unidade de passo que @'{e} ou cont@'{i}nua @`a esquerda ou cont@'{i}nua @`a direita
em zero, defina sua pr@'{o}pria fun@value{cedilha}@~{a}o de unidade de passo usando @code{signum}; por exemplo,

@c ===beg===
@c xunit_step (x) := (1 + signum (x))/2$
@c [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)];
@c ===end===
@example
(%i1) xunit_step (x) := (1 + signum (x))/2$

(%i2) [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)];
                                1
(%o2)                       [0, -, 1]
                                2
@end example

N@~{a}o redefina a pr@'{o}pria @code{unit_step}; alguns c@'{o}digo em @code{orthopoly}
requerem que a fun@value{cedilha}@~{a}o de passo de unidade seja cont@'{i}nua @`a esquerda.

@subsection Algor@'{i}tmos

Geralmente, @code{orthopoly} faz avalia@value{cedilha}@~{o}es simb@'{o}licas pelo uso de uma representa@value{cedilha}@~{a}o 
hipergeom@'{e}trica de polin@^{o}mios ortogonais. As fun@value{cedilha}@~{o}es 
hipegeom@'{e}tricas s@~{a}o avaliadas usando as fun@value{cedilha}@~{o}es (n@~{a}o documetadas) @code{hypergeo11} 
e @code{hypergeo21}. As excess@~{o}es s@~{a}o as fun@value{cedilha}@~{o}es de Bessel metade inteiras 
e a fun@value{cedilha}@~{a}o de Legendre associada de segundo tipo. As fun@value{cedilha}@~{o}es de Bessel metade inteiras s@~{a}o
avaliadas usando uma representa@value{cedilha}@~{a}o expl@'{i}cita, e a fun@value{cedilha}@~{a}o de Legendre 
associada de segundo tipo @'{e} avaliada usando recursividade.

Para avalia@value{cedilha}@~{a}o em ponto flutuante, n@'{o}s novamente convertemos muitas fu@value{cedilha}@~{o}es em
uma forma hipergeom@'{e}trica; n@'{o}s avaliamos as fun@value{cedilha}@~{o}es hipergeom@'{e}tricas usando 
recursividade para frente. Novamente, as excess@~{o}es s@~{a}o as fun@value{cedilha}@~{o}es de Bessel metade inteiras 
e a fun@value{cedilha}@~{a}o de Legendre associada de segundo tipo. Numericamente, 
as fun@value{cedilha}@~{o}es de Bessel meio inteiras s@~{a}o avaliadas usando o c@'{o}digo SLATEC.

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para polin@^{o}mios ortogonais,  , Introdu@value{cedilha}@~{a}o a polin@^{o}mios ortogonais, orthopoly
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para polin@^{o}mios ortogonais

@deffn {Fun@value{cedilha}@~{a}o} assoc_legendre_p (@var{n}, @var{m}, @var{x})
As fun@value{cedilha}@~{o}es de Legendre associadas de primeiro tipo. 

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{o}es 22.5.37, p@'{a}gina 779, 8.6.6
(segunda equa@value{cedilha}@~{a}o), p@'{a}gina 334, e 8.2.5, p@'{a}gina 333.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} assoc_legendre_q (@var{n}, @var{m}, @var{x})
A fun@value{cedilha}@~{a}o de Legendre associada de segundo tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 8.5.3 e 8.1.8.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} chebyshev_t (@var{n}, @var{x})
A fun@value{cedilha}@~{a}o de Chebyshev de primeiro tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 22.5.47,p@'{a}gina 779.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} chebyshev_u (@var{n}, @var{x})
A fun@value{cedilha}@~{a}o de Chebyshev do segundo tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 22.5.48,p@'{a}gina 779.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} gen_laguerre (@var{n}, @var{a}, @var{x})
O poli@^{o}mio generalizado de Laguerre.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 22.5.54,p@'{a}gina 780.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} hermite (@var{n}, @var{x})
O polin@^{o}mio de Hermite.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 22.5.55,p@'{a}gina 780.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} intervalp (@var{e})
Retorna @code{true} se a entrada for um intervalo e retorna @code{false} se n@~{a}o for. 
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} jacobi_p (@var{n}, @var{a}, @var{b}, @var{x})
o polin@^{o}mio de Jacobi.

Os polin@^{o}mios de Jacobi s@~{a}o atualmente definidos para todo
@var{a} e @var{b}; todavia, o peso do polin@^{o}mio de
Jacobi @code{(1 - @var{x})^@var{a} (1 + @var{x})^@var{b}} n@~{a}o @'{e} integr@'{a}vel para @code{@var{a} <= -1} ou
@code{@var{b} <= -1}. 

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 22.5.42,p@'{a}gina 779.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} laguerre (@var{n}, @var{x})
O polin@^{o}mio de Laguerre.

Refer@^{e}ncia: Abramowitz e Stegun, equat@value{cedilha}@~{o}es 22.5.16 e 22.5.54,p@'{a}gina 780.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} legendre_p (@var{n}, @var{x})
O polin@^{o}mio de Legendre de primeiro tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{o}es 22.5.50 e 22.5.51,p@'{a}gina 779.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} legendre_q (@var{n}, @var{x})
O polin@^{o}mio de Legendre de primeiro tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{o}es 8.5.3 e 8.1.8.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} orthopoly_recur (@var{f}, @var{args})
Retorna uma rela@value{cedilha}@~{a}o recursiva para a fam@'{i}lia de fun@value{cedilha}@~{o}es ortogonais
@var{f} com argumentos @var{args}. A recursividade @'{e} com 
rela@value{cedilha}@~{a}o ao grau do polin@^{o}mio.

@c ===beg===
@c orthopoly_recur (legendre_p, [n, x]);
@c ===end===
@example
(%i1) orthopoly_recur (legendre_p, [n, x]);
                (2 n - 1) P     (x) x + (1 - n) P     (x)
                           n - 1                 n - 2
(%o1)   P (x) = -----------------------------------------
         n                          n
@end example

O segundo argumento a @code{orthopoly_recur} deve ser uma lista com o 
n@'{u}mero correto de argumentos para a fun@value{cedilha}@~{a}o @var{f}; se o n@'{u}mero de argumetnos n@~{a}o for o correto, 
Maxima sinaliza com um erro.

@c ===beg===
@c orthopoly_recur (jacobi_p, [n, x]);
@c ===end===
@example
(%i1) orthopoly_recur (jacobi_p, [n, x]);

Function jacobi_p needs 4 arguments, instead it received 2
 -- an error.  Quitting.  To debug this try debugmode(true);
@end example

Adicionalmente, quando @var{f} n@~{a}o for o nome de uma das
fam@'{i}lias de polin@^{o}mios ortogonais, um erro @'{e} sinalizado.

@c ===beg===
@c orthopoly_recur (foo, [n, x]);
@c ===end===
@example
(%i1) orthopoly_recur (foo, [n, x]);

A recursion relation for foo isn't known to Maxima
 -- an error.  Quitting.  To debug this try debugmode(true);
@end example
@end deffn

@defvr {Variable} orthopoly_returns_intervals
Valor padr@~{a}o: @code{true}

Quando @code{orthopoly_returns_intervals} for @code{true}, resultados em ponto flutuante s@~{a}o retornados na
forma @code{interval (@var{c}, @var{r})}, onde @var{c} @'{e} o centro de um intervalo
e @var{r} @'{e} seu raio. O centro pode ser um n@'{u}mero complexo; nesse
caso, o intervalo @'{e} um disco no plano complexo.
@end defvr

@deffn {Fun@value{cedilha}@~{a}o} orthopoly_weight (@var{f}, @var{args})

Retorna uma lista de tr@^{e}s elementos; o primeiro elemento @'{e} 
a f@'{o}rmula do peso para a fam@'{i}lia de polin@^{o}mios ortogonais
@var{f} com argumentos fornecidos pela lista @var{args}; os 
segundos e terceiros elementos fornecem os pontos finais inferior e superior
do intervalo de ortogonalidade. Por exemplo,

@c ===beg===
@c w : orthopoly_weight (hermite, [n, x]);
@c integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]);
@c ===end===
@example
(%i1) w : orthopoly_weight (hermite, [n, x]);
                            2
                         - x
(%o1)                 [%e    , - inf, inf]
(%i2) integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]);
(%o2)                           0
@end example

A vari@'{a}vel principal de @var{f} deve ser um s@'{i}mbolo; Se n@~{a}o for, Maxima
sinaliza com um erro. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} pochhammer (@var{n}, @var{x})
O s@'{i}mbolo de Pochhammer. Para inteiros n@~{a}o negativos @var{n} com
@code{@var{n} <= pochhammer_max_index}, a express@~{a}o @code{pochhammer (@var{x}, @var{n})} 
avalia para o produto @code{@var{x} (@var{x} + 1) (@var{x} + 2) ... (@var{x} + n - 1)}
when @code{@var{n} > 0} e
para 1 quando @code{@var{n} = 0}. Para valores negativos de @var{n},
@code{pochhammer (@var{x}, @var{n})} @'{e} definido como @code{(-1)^@var{n} / pochhammer (1 - @var{x}, -@var{n})}.
Dessa forma

@c ===beg===
@c pochhammer (x, 3);
@c pochhammer (x, -3);
@c ===end===
@example
(%i1) pochhammer (x, 3);
(%o1)                   x (x + 1) (x + 2)
(%i2) pochhammer (x, -3);
                                 1
(%o2)               - -----------------------
                      (1 - x) (2 - x) (3 - x)
@end example

Para converter um s@'{i}mbolo de Pochhammer em um quociente de fun@value{cedilha}@~{o}es gama,
(veja Abramowitz e Stegun, equa@value{cedilha}@~{a}o 6.1.22) use @code{makegamma}; por exemplo 

@c ===beg===
@c makegamma (pochhammer (x, n));
@c ===end===
@example
(%i1) makegamma (pochhammer (x, n));
                          gamma(x + n)
(%o1)                     ------------
                            gamma(x)
@end example

Quando @var{n} exceder @code{pochhammer_max_index} ou quando @var{n} 
for simb@'{o}lico, @code{pochhammer} retorna uma forma substantiva.

@c ===beg===
@c pochhammer (x, n);
@c ===end===
@example
(%i1) pochhammer (x, n);
(%o1)                         (x)
                                 n
@end example
@end deffn

@defvr {Vari@'{a}vel} pochhammer_max_index
Valor padr@~{a}o: 100

@code{pochhammer (@var{n}, @var{x})} expande para um produto se e somente se
@code{@var{n} <= pochhammer_max_index}.

Exemplos:

@c ===beg===
@c pochhammer (x, 3), pochhammer_max_index : 3;
@c pochhammer (x, 4), pochhammer_max_index : 3;
@c ===end===
@example
(%i1) pochhammer (x, 3), pochhammer_max_index : 3;
(%o1)                   x (x + 1) (x + 2)
(%i2) pochhammer (x, 4), pochhammer_max_index : 3;
(%o2)                         (x)
                                 4
@end example

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 6.1.16,p@'{a}gina 256.
@end defvr

@deffn {Fun@value{cedilha}@~{a}o} spherical_bessel_j (@var{n}, @var{x})
A Fun@value{cedilha}@~{a}o de Bessel esf@'{e}rica de primeiro tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{o}es 10.1.8,p@'{a}gina 437 e 10.1.15,p@'{a}gina 439.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} spherical_bessel_y (@var{n}, @var{x})
A Fun@value{cedilha}@~{a}o de Bessel esf@'{e}rica de segundo tipo. 

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{o}es 10.1.9,p@'{a}gina 437 e 10.1.15,p@'{a}gina 439.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} spherical_hankel1 (@var{n}, @var{x})
A Fun@value{cedilha}@~{a}o de Hankel esf@'{e}rica de
primeiro tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 10.1.36,p@'{a}gina 439.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} spherical_hankel2 (@var{n}, @var{x})
A Fun@value{cedilha}@~{a}o de Hankel esf@'{e}rica de segundo tipo.

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 10.1.17,p@'{a}gina 439.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} spherical_harmonic (@var{n}, @var{m}, @var{x}, @var{y})
A fun@value{cedilha}@~{a}o arm@^{o}nica esf@'{e}rica.

Refer@^{e}ncia: Merzbacher 9.64.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} unit_step (@var{x})
A fun@value{cedilha}@~{a}o de passo de unidade cont@'{i}nua @`a esquerda; dessa forma
@code{unit_step (@var{x})} tende para @code{@var{x} <= 0} e @'{e} igual a
1 para @code{@var{x} > 0}.

Se voc@^{e} quiser uma fun@value{cedilha}@~{a}o de passo de unidade que
tome o valor 1/2 em zero, use @code{(1 + signum (@var{x}))/2}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ultraspherical (@var{n}, @var{a}, @var{x})
A fun@value{cedilha}@~{a}o polin@^{o}mial ultraesf@'{e}rica (tamb@'{e}m conhecida como fun@value{cedilha}@~{a}o polinomial de Gegenbauer).

Refer@^{e}ncia: Abramowitz e Stegun, equa@value{cedilha}@~{a}o 22.5.46,p@'{a}gina 779.
@end deffn
