@c /Special.texi/1.27/Mon Jan 15 06:08:56 2007/-ko/
@menu
* Introdução a Funções Especiais::  
* Definições para Funções Especiais::  
@end menu

@node Introdução a Funções Especiais, Definições para Funções Especiais, Funções Especiais, Funções Especiais
@section Introdução a Funções Especiais

A notação de função especial segue adiante:

@example
bessel_j (index, expr)         Função de Bessel, primeiro tipo
bessel_y (index, expr)         Função de Bessel, segundo tipo
bessel_i (index, expr)         Função de Bessel modificada, primeiro tipo
bessel_k (index, expr)         Função de Bessel modificada, segundo tipo
%he[n] (z)                     Polinómio de Hermite (Note bem: @code{he}, não @code{h}. Veja A&S 22.5.18)
%p[u,v] (z)                    Função de Legendre
%q[u,v] (z)                    Função de Legendre, segundo tipo
hstruve[n] (z)                 Função H de Struve H
lstruve[n] (z)                 Função de L Struve
%f[p,q] ([], [], expr)         Função Hipergeométrica Generalizada
gamma()                        Função Gamma
gamma_incomplete_lower(a,z)    Função gama incompleta inferior
gammaincomplete(a,z)           Final da função gama incompleta
@c IS slommel THE "LOMMEL" FUNCTION ?? NOT OTHERWISE MENTIONED IN TEXINFO FILES
slommel
%m[u,k] (z)                    Função de Whittaker, primeiro tipo
%w[u,k] (z)                    Função de Whittaker, segundo tipo
erfc (z)                       Complemento da função erf (função de erros - integral da distribuição normal)
ei (z)                         Integral de exponencial (?)
kelliptic (z)                  integral eliptica completa de primeiro tipo (K)
%d [n] (z)                     Função cilíndrica parabólica
@end example

@node Definições para Funções Especiais,  , Introdução a Funções Especiais, Funções Especiais
@section Definições para Funções Especiais

@deffn {Função} airy_ai (@var{x})
A função de Airy Ai, como definida em Abramowitz e Stegun,
@i{Handbook of Mathematical Functions}, Sessão 10.4. 

A equação de Airy @code{diff (y(x), x, 2) - x y(x) = 0} tem duas 
soluções linearmente independentes, @code{y = Ai(x)} e @code{y = Bi(x)}.
A derivada de @code{diff (airy_ai(x), x)} é @code{airy_dai(x)}.

Se o argumento @code{x} for um número real ou um número complexo qualquer deles em ponto
flutuante , o valor numérico de @code{airy_ai} é retornado 
quando possível.

Veja também @code{airy_bi}, @code{airy_dai}, @code{airy_dbi}.
@end deffn


@deffn {Função} airy_dai (@var{x})
A derivada da função de Airy Ai @code{airy_ai(x)}. 

Veja @code{airy_ai}.
@end deffn

@deffn {Função} airy_bi (@var{x})
A função de Airy Bi, como definida em Abramowitz e Stegun,
@i{Handbook of Mathematical Functions}, Sessão 10.4, 
é a segunda solução da equação de Airy
@code{diff (y(x), x, 2) - x y(x) = 0}.

Se o argumento @code{x} for um número real ou um número complexo qualquer deles em ponto flutuante,
o valor numérico de @code{airy_bi} é retornado quando possível.
Em outros casos a expressão não avaliada é retornada.

A derivada de @code{diff (airy_bi(x), x)} é @code{airy_dbi(x)}.

Veja @code{airy_ai}, @code{airy_dbi}.
@end deffn


@deffn {Função} airy_dbi (@var{x})
A derivada de função de Airy Bi @code{airy_bi(x)}.

Veja @code{airy_ai} e @code{airy_bi}.
@end deffn

@deffn {Função} asympa
@code{asympa} é um pacote para análise assintótica. O pacote contém
funções de simplificação para análise assintótica, incluindo as funções 
``grande O'' e ``pequeno o'' que são largamente usadas em análises de complexidade e
análise numérica.

@code{load ("asympa")} chama esse pacote.

@end deffn

@deffn {Função} bessel (@var{z}, @var{a}) 
A função de Bessel de primeiro tipo.

Essa função está desactualizada.  Escreva @code{bessel_j (@var{z}, @var{a})} em lugar dessa.

@end deffn


@deffn {Função} bessel_j (@var{v}, @var{z})
A função de Bessel do primeiro tipo de ordem @math{v} e argumento @math{z}.

@code{bessel_j} calcula o array @code{besselarray} tal que
@code{besselarray [i] = bessel_j [i + v - int(v)] (z)} para @code{i} de zero a @code{int(v)}.

@code{bessel_j} é definida como
@ifhtml
@example
                inf
                ====       k  - v - 2 k  v + 2 k
                \     (- 1)  2          z
                 >    --------------------------
                /        k! gamma(v + k + 1)
                ====
                k = 0
@end example
@end ifhtml
@ifinfo
@example
                inf
                ====       k  - v - 2 k  v + 2 k
                \     (- 1)  2          z
                 >    --------------------------
                /        k! gamma(v + k + 1)
                ====
                k = 0
@end example
@end ifinfo

@tex
$$\sum_{k=0}^{\infty }{{{\left(-1\right)^{k}\,\left(z\over 2\right)^{v+2\,k}
 }\over{k!\,\Gamma\left(v+k+1\right)}}}$$
@end tex

todavia séries infinitas não são usadas nos cálculos.

@end deffn


@deffn {Função} bessel_y (@var{v}, @var{z})
A função de Bessel do segundo tipo de ordem @math{v} e argumento @math{z}.

@code{bessel_y} calcula o array @code{besselarray} tal que
@code{besselarray [i] = bessel_y [i + v - int(v)] (z)} para @code{i} de zero a @code{int(v)}.

@code{bessel_y} é definida como
@ifhtml
@example
              cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
              -------------------------------------------
                             sin(%pi v)
@end example
@end ifhtml
@ifinfo
@example
              cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
              -------------------------------------------
                             sin(%pi v)
@end example
@end ifinfo

@tex
$${{\cos \left(\pi\,v\right)\,J_{v}(z)-J_{-v}(z)}\over{
 \sin \left(\pi\,v\right)}}$$
@end tex

quando @math{v} não for um inteiro.  Quando @math{v} for um inteiro @math{n},
o limite com @math{v} aprocimando-se de @math{n} é tomado.

@end deffn


@deffn {Função} bessel_i (@var{v}, @var{z})
A função de Bessel modificada de primeiro tipo de ordem @math{v} e argumento @math{z}.

@code{bessel_i} calcula o array @code{besselarray} tal que
@code{besselarray [i] = bessel_i [i + v - int(v)] (z)} para @code{i} de zero a @code{int(v)}.

@code{bessel_i} é definida como
@ifhtml
@example
                    inf
                    ====   - v - 2 k  v + 2 k
                    \     2          z
                     >    -------------------
                    /     k! gamma(v + k + 1)
                    ====
                    k = 0
@end example
@end ifhtml
@ifinfo
@example
                    inf
                    ====   - v - 2 k  v + 2 k
                    \     2          z
                     >    -------------------
                    /     k! gamma(v + k + 1)
                    ====
                    k = 0
@end example
@end ifinfo

@tex
$$\sum_{k=0}^{\infty } {{1\over{k!\,\Gamma
 \left(v+k+1\right)}} {\left(z\over 2\right)^{v+2\,k}}}$$
@end tex

todavia séries infinitas não são usadas nos cálculos.

@end deffn


@deffn {Função} bessel_k (@var{v}, @var{z})
A função de Bessel modificada de segundo tipo de ordem @math{v} e argumento @math{z}.

@code{bessel_k} calcula o array @code{besselarray} tal que
@code{besselarray [i] = bessel_k [i + v - int(v)] (z)} para @code{i} de zero a @code{int(v)}.

@code{bessel_k} é definida como
@ifhtml
@example
           %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
           -------------------------------------------------
                                  2
@end example
@end ifhtml
@ifinfo
@example
           %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
           -------------------------------------------------
                                  2
@end example
@end ifinfo
@tex
$${{\pi\,\csc \left(\pi\,v\right)\,\left(I_{-v}(z)-I_{v}(z)\right)}\over{2}}$$
@end tex

quando @math{v} não for inteiro.  Se @math{v} for um inteiro @math{n},
então o limite  com @math{v} aproximando-se de @math{n} é tomado.

@end deffn

@defvr {Variável de opção} besselexpand
Valor por omissão: @code{false}

@c REPHRASE
Expansões de controle de funções de Bessel quando a ordem for a metade de
um inteiro ímpar.  Nesse caso, as funções de Bessel podem ser expandidas
em termos de outras funções elementares.  Quando @code{besselexpand} for @code{true},
a função de Bessel é expandida.

@example
(%i1) besselexpand: false$
(%i2) bessel_j (3/2, z);
                                    3
(%o2)                      bessel_j(-, z)
                                    2
(%i3) besselexpand: true$
(%i4) bessel_j (3/2, z);
                          2 z   sin(z)   cos(z)
(%o4)                sqrt(---) (------ - ------)
                          %pi      2       z
                                  z
@end example
@end defvr

@deffn {Função} scaled_bessel_i (@var{v}, @var{z}) 

A função homotética modificada de Bessel de primeiro tipo de ordem
@math{v} e argumento @math{z}.  Isto é, @math{scaled_bessel_i(v,z) =
exp(-abs(z))*bessel_i(v, z)}. Essa função é particularmente útil
para calcular @math{bessel_i} para grandes valores de @math{z}.
Todavia, maxima não conhece outra forma muito mais sobre essa função.  Para
computação simbólica, é provavelmete preferível trabalhar com a expressão
@code{exp(-abs(z))*bessel_i(v, z)}.

@end deffn

@deffn {Função} scaled_bessel_i0 (@var{z}) 

Idêntica a @code{scaled_bessel_i(0,z)}.

@end deffn

@deffn {Função} scaled_bessel_i1 (@var{z}) 

Idêntica a @code{scaled_bessel_i(1,z)}.

@end deffn

@deffn {Função} beta (@var{x}, @var{y})
A função beta, definida como @code{gamma(x) gamma(y)/gamma(x + y)}.
@c SEEMS LIKE THERE SHOULD BE MORE TO SAY HERE
@c ANY SIMPLIFICATION RULES FOR THIS FUNCTION ??

@end deffn

@deffn {Função} gamma (@var{x})
A função gama.

@c SEEMS POINTLESS TO MENTION THE FOLLOWING IDENTITY, 
@c AS MAXIMA DOESN'T SEEM TO CARRY OUT THIS SIMPLIFICATION
@c GAMMA(I)=(I-1)!  for I a positive integer.

Veja também @code{makegamma}.

A variável @code{gammalim} controla a simplificação da função gama.

A constante de Euler-Mascheroni é @code{%gamma}.

@end deffn

@defvr {Variável de opção} gammalim
Valor por omissão: 1000000

@c REPHRASE
@code{gammalim} controla a simplificação da função
gama para integral e argumentos na forma de números racionais.  Se o valor
absoluto do argumento não for maior que @code{gammalim}, então
a simplificação ocorrerá.  Note que @code{factlim} comuta controle de
simplificaçcão do resultado de @code{gamma} de um argumento inteiro também.

@end defvr

@c NEED EXAMPLES HERE
@deffn {Função} intopois (@var{a})
Converte @var{a} em um código de Poisson.

@end deffn

@c NEED CROSS REFS HERE
@c NEED EXAMPLES HERE
@deffn {Função} makefact (@var{expr})
Transforma instâncias de funções binomiais, gama,
e beta em @var{expr} para factoriais.

Veja também @code{makegamma}.

@end deffn

@c NEED CROSS REFS HERE
@c NEED EXAMPLES HERE
@deffn {Função} makegamma (@var{expr})
Transforma instâncias de funções binomiais, factorial,
e beta em @var{expr} para funções gama.

Veja também @code{makefact}.

@end deffn

@c AREN'T THERE OTHER FUNCTIONS THAT DO ESSENTIALLY THE SAME THING ??
@deffn {Função} numfactor (@var{expr})
Retorna o factor numérico multiplicando a expressão
@var{expr}, que pode ser um termo simples.

@c WHY IS content MENTIONED IN THIS CONTEXT ??
@code{content} retorna o máximo divisor comum (mdc) de todos os termos em uma adição.

@example
(%i1) gamma (7/2);
                          15 sqrt(%pi)
(%o1)                     ------------
                               8
(%i2) numfactor (%);
                               15
(%o2)                          --
                               8
@end example

@end deffn

@c NEED EXAMPLES HERE
@deffn {Função} outofpois (@var{a})
Converte @var{a} de um código de Poisson para uma representação
geral.  Se @var{a} não for uma forma de Poisson, @code{outofpois} realiza a conversão,
i.e., o valor de retorno é @code{outofpois (intopois (@var{a}))}.
Essa função é desse modo um simplificador canónico
para adições e potências de termos de seno e co-seno de um tipo particular.

@end deffn

@c NEED MORE INFO HERE
@c NEED EXAMPLES HERE
@deffn {Função} poisdiff (@var{a}, @var{b})
Deriva @var{a} com relação a @var{b}.  @var{b} deve ocorrer somente
nos argumentos trigonométricos ou somente nos coeficientes.

@end deffn

@c LOOKING AT THE CODE IN src/pois3.lisp, THIS FCN SEEMS TO COMPUTE THE EXPONENT BY MULTIPLYING IN A LOOP
@c DUNNO HOW WE WANT TO EXPLAIN THAT
@c REPHRASE WITHOUT USING THE TERM "FUNCTIONALLY IDENTICAL"
@deffn {Função} poisexpt (@var{a}, @var{b})
Funcionalmente identica a @code{intopois (@var{a}^@var{b})}.
@var{b} deve ser um inteiro positico.

@end deffn

@c WHAT IS THIS ABOUT ??
@deffn {Função} poisint (@var{a}, @var{b})
Integra em um senso restrito similarmente (para
@code{poisdiff}).  Termos não periódicos em @var{b} são diminuídos se @var{b} estiver em argumentos
trigonométricos.

@end deffn

@defvr {Variável de opção} poislim
Valor por omissão: 5

@code{poislim} determina o domínio dos coeficientes nos
argumentos de funções trigonométricas.  O valor inicial de 5
corresponde ao intervalo [-2^(5-1)+1,2^(5-1)], ou [-15,16], mas isso
pode ser alterado para [-2^(n-1)+1, 2^(n-1)].

@end defvr

@c UMM, WHAT IS THIS ABOUT EXACTLY ?? EXAMPLES NEEDED
@deffn {Função} poismap (@var{series}, @var{sinfn}, @var{cosfn})
mapeará as funções @var{sinfn} sobre os
termos de seno e @var{cosfn} ssobre os termos de co-seno das séries de Poisson dadas.
@var{sinfn} e @var{cosfn} são funções de dois argumentos que são um coeficiente
e uma parte trigonométrica de um termo em séries respectivamente.

@end deffn

@c REPHRASE WITHOUT USING THE TERM "FUNCTIONALLY IDENTICAL"
@deffn {Função} poisplus (@var{a}, @var{b})
É funcionalmente identica a @code{intopois (a + b)}.

@end deffn

@deffn {Função} poissimp (@var{a})
Converte @var{a} em séries de Poisson para @var{a} em representação
geral.

@end deffn

@c MORE INFO NEEDED HERE
@defvr {Símbolo especial} poisson
O símbolo @code{/P/} segue o rótulo de linha de uma expressão contendo séries de
Poisson.

@end defvr

@deffn {Função} poissubst (@var{a}, @var{b}, @var{c})
Substitue @var{a} por @var{b} em @var{c}.  @var{c} é uma série de Poisson.

(1) Quando @var{B} é uma variável @var{u}, @var{v}, @var{w}, @var{x}, @var{y}, ou @var{z},
então @var{a} deve ser uma
expressão linear nessas variáveis (e.g., @code{6*u + 4*v}).

(2) Quando @var{b} for outra que não essas variáveis, então @var{a} deve também ser
livre dessas variáveis, e além disso, livre de senos ou co-senos.

@code{poissubst (@var{a}, @var{b}, @var{c}, @var{d}, @var{n})} é um tipo especial d substituição que
opera sobre @var{a} e @var{b} como no tipo (1) acima, mas onde @var{d} é uma série de
Poisson, expande @code{cos(@var{d})} e @code{sin(@var{d})} para a ordem @var{n} como provendo o
resultado da substituição @code{@var{a} + @var{d}} por @var{b} em @var{c}.  A idéia é que @var{d} é uma
expansão em termos de um pequeno parâmetro.  Por exemplo,
@code{poissubst (u, v, cos(v), %e, 3)} retorna @code{cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)}.

@end deffn

@c REPHRASE WITHOUT USING THE TERM "FUNCTIONALLY IDENTICAL"
@deffn {Função} poistimes (@var{a}, @var{b})
É funcionalmente idêntica a @code{intopois (@var{a}*@var{b})}.

@end deffn

@c HOW DOES THIS WORK ?? NEED MORE INFO AND EXAMPLES
@deffn {Função} poistrim ()
é um nome de função reservado que (se o utilizador tiver definido
uma função com esse nome) é aplicada durante multiplicação de Poisson.  Isso é uma função
predicada de 6 argumentos que são os coeficientes de @var{u}, @var{v}, ..., @var{z}
em um termo.  Termos para os quais @code{poistrim} for @code{true} (para os coeficientes
daquele termo) são eliminados durante a multiplicação.

@end deffn

@deffn {Função} printpois (@var{a})
Mostra uma série de Poisson em um formato legível.  Em comum
com @code{outofpois}, essa função converterá @var{a} em um código de Poisson primeiro, se
necessário.

@end deffn

@c NEED INFO HERE ABOUT THE SUBSCRIPTED FORM psi[n](x)
@c I (rtoy) don't think there is a plain psi(x) function anymore.
@c @deffn {Função} psi (@var{x})
@c @deffnx {Função} psi [@var{n}](@var{x})
@deffn {Função} psi [@var{n}](@var{x})

A derivada de @code{log (gamma (@var{x}))} de ordem @code{@var{n}+1}.
Dessa forma, @code{psi[0](@var{x})} é a primeira derivada,
@code{psi[1](@var{x})} é a segunda derivada, etc.

Maxima não sabe como, em geral, calcular um valor numérico de
@code{psi}, mas Maxima pode calcular alguns valores exatos para argumentos racionais.
Muitas variáveis controlam qual intervalo de argumentos racionais @code{psi} irá
retornar um valor exato, se possível.  Veja @code{maxpsiposint},
@code{maxpsinegint}, @code{maxpsifracnum}, e @code{maxpsifracdenom}.
Isto é, @var{x} deve localizar-se entre @code{maxpsinegint} e
@code{maxpsiposint}.  Se o valor absoluto da parte facionária de
@var{x} for racional e tiver um numerador menor que @code{maxpsifracnum}
e tiver um denominador menor que @code{maxpsifracdenom}, @code{psi}
irá retornar um valor exato.

A função @code{bfpsi} no pacote @code{bffac} pode calcular
valores numéricos.
 
 @end deffn

@defvr {Variável de opção} maxpsiposint
Valor por omissão: 20

@code{maxpsiposint} é o maior valor positivo para o qual
@code{psi[n](x)} irá tentar calcular um valor exato.

@end defvr

@defvr {Variável de opção} maxpsinegint
Valor por omissão: -10

@code{maxpsinegint} é o valor mais negativo para o qual
@code{psi[n](x)} irá tentar calcular um valor exato.  Isto é, se
@var{x} for menor que @code{maxnegint}, @code{psi[n](@var{x})} não irá
retornar resposta simplificada, mesmo se isso for possível.

@end defvr

@defvr {Variável de opção} maxpsifracnum
Valor por omissão: 4

Tomemos @var{x} como sendo um número racional menor que a unidade e da forma @code{p/q}.
Se @code{p} for menor que @code{maxpsifracnum}, então
@code{psi[@var{n}](@var{x})} não irá tentar retornar um valor
simplificado.

@end defvr

@deffn {Função} specint (exp(- s*@var{t}) * @var{expr}, @var{t})

Calcula a transformada de Laplace de @var{expr} com ralação à variável @var{t}.
O integrando @var{expr} pode conter funções especiais.

Se @code{specint} não puder calcular a integral, o valore de retorno pode
conter vários símbolos do Lisp, incluindo
@code{other-defint-to-follow-negtest},
@code{other-lt-exponential-to-follow},
@code{product-of-y-with-nofract-indices}, etc.; isso é um erro.  
@c REPORTED AS SOURCEFORGE BUG # 1162505

@code{demo(hypgeo)} mostra muitos exemplos de transformadas de Laplace calculados por @code{specint}.

Exemplos:
@c ===beg===
@c assume (p > 0, a > 0);
@c specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
@c specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) * exp(-p*t), t);
@c ===end===

@example
(%i1) assume (p > 0, a > 0);
(%o1)                    [p > 0, a > 0]
(%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
                           sqrt(%pi)
(%o2)                     ------------
                                 a 3/2
                          2 (p + -)
                                 4
(%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) * exp(-p*t), t);
                                   - a/p
                         sqrt(a) %e
(%o3)                    ---------------
                                2
                               p
@end example

@end deffn

@defvr {Variável de opção} maxpsifracdenom
Valor por omissão: 4

Tomemos @var{x} como sendo um número racional menor que a unidade e da forma @code{p/q}.
Se @code{q} for maior que @code{maxpsifracdeonm}, então
@code{psi[@var{n}](@var{x})} não irá tentar retornar um valor
simplificado.


@end defvr

