Introducedilhaão a Funcedilhaões Especiais
==========================================

A notacedilhaão de funcedilhaão especial segue adiante:

     bessel_j (index, expr)         Funcedilhaão de Bessel, primeiro tipo
     bessel_y (index, expr)         Funcedilhaão de Bessel, segundo tipo
     bessel_i (index, expr)         Funcedilhaão de Bessel modificada, primeiro tipo
     bessel_k (index, expr)         Funcedilhaão de Bessel modificada, segundo tipo
     %he[n] (z)                     Polinómio de Hermite (Note bem: he, não h. Veja A&S 22.5.18)
     %p[u,v] (z)                    Funcedilhaão de Legendre
     %q[u,v] (z)                    Funcedilhaão de Legendre, segundo tipo
     hstruve[n] (z)                 Funcedilhaão H de Struve H
     lstruve[n] (z)                 Funcedilhaão de L Struve
     %f[p,q] ([], [], expr)         Funcedilhaão Hipergeométrica Generalizada
     gamma()                        Funcedilhaão Gamma
     gammagreek(a,z)                Funcedilhaão gama incompleta
     gammaincomplete(a,z)           Final da funcedilhaão gama incompleta
     slommel
     %m[u,k] (z)                    Funcedilhaão de Whittaker, primeiro tipo
     %w[u,k] (z)                    Funcedilhaão de Whittaker, segundo tipo
     erfc (z)                       Complemento da funcedilhaão erf (funcedilhaão de erros - integral da distribuicedilhaão normal)
     ei (z)                         Integral de exponencial (?)
     kelliptic (z)                  integral eliptica completa de primeiro tipo (K)
     %d [n] (z)                     Funcedilhaão cilíndrica parabólica

Definicedilhaões para Funcedilhaões Especiais
=============================================

 -- Funcedilhaão: airy_ai (X)
     A funcedilhaão de Airy Ai, como definida em Abramowitz e Stegun, Handbook of Mathematical Functions, Sessão 10.4.

     A equacedilhaão de Airy diff (y(x), x, 2) - x y(x) = 0 tem duas solucedilhaões linearmente independentes, y = Ai(x) e y = Bi(x). A derivada de diff (airy_ai(x), x) é airy_dai(x).

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

     Veja também airy_bi, airy_dai, airy_dbi.

 -- Funcedilhaão: airy_dai (X)
     A derivada da funcedilhaão de Airy Ai airy_ai(x).

     Veja airy_ai.

 -- Funcedilhaão: airy_bi (X)
     A funcedilhaão de Airy Bi, como definida em Abramowitz e Stegun, Handbook of Mathematical Functions, Sessão 10.4, é a segunda solucedilhaão da equacedilhaão de Airy diff (y(x), x, 2) - x y(x) = 0.

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

     A derivada de diff (airy_bi(x), x) é airy_dbi(x).

     Veja airy_ai, airy_dbi.

 -- Funcedilhaão: airy_dbi (X)
     A derivada de funcedilhaão de Airy Bi airy_bi(x).

     Veja airy_ai e airy_bi.

 -- Funcedilhaão: asympa
     asympa é um pacote para análise assintótica. O pacote contém funcedilhaões de simplificacedilhaão para análise assintótica, incluindo as funcedilhaões ``grande O'' e ``pequeno o'' que são largamente usadas em análises de complexidade e análise numérica.

     load ("asympa") chama esse pacote.

 -- Funcedilhaão: bessel (Z, A)
     A funcedilhaão de Bessel de primeiro tipo.

     Essa funcedilhaão está desactualizada.  Escreva bessel_j (Z, A) em lugar dessa.

 -- Funcedilhaão: bessel_j (V, Z)
     A funcedilhaão de Bessel do primeiro tipo de ordem v e argumento z.

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

     bessel_j é definida como

                          inf
                          ====       k  - v - 2 k  v + 2 k
                          \     (- 1)  2          z
                           >    --------------------------
                          /        k! gamma(v + k + 1)
                          ====
                          k = 0

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

 -- Funcedilhaão: bessel_y (V, Z)
     A funcedilhaão de Bessel do segundo tipo de ordem v e argumento z.

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

     bessel_y é definida como

                        cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
                        -------------------------------------------
                                       sin(%pi v)

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

 -- Funcedilhaão: bessel_i (V, Z)
     A funcedilhaão de Bessel modificada de primeiro tipo de ordem v e argumento z.

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

     bessel_i é definida como

                              inf
                              ====   - v - 2 k  v + 2 k
                              \     2          z
                               >    -------------------
                              /     k! gamma(v + k + 1)
                              ====
                              k = 0

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

 -- Funcedilhaão: bessel_k (V, Z)
     A funcedilhaão de Bessel modificada de segundo tipo de ordem v e argumento z.

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

     bessel_k é definida como

                     %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
                     -------------------------------------------------
                                            2

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

 -- Variável de opcedilhaão: besselexpand
     Valor por omissão: false

     Expansões de controle de funcedilhaões de Bessel quando a ordem for a metade de um inteiro ímpar.  Nesse caso, as funcedilhaões de Bessel podem ser expandidas em termos de outras funcedilhaões elementares.  Quando besselexpand for true, a funcedilhaão de Bessel é expandida.

          (%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

 -- Funcedilhaão: scaled_bessel_i (V, Z)

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

 -- Funcedilhaão: scaled_bessel_i0 (Z)

     Idêntica a scaled_bessel_i(0,z).

 -- Funcedilhaão: scaled_bessel_i1 (Z)

     Idêntica a scaled_bessel_i(1,z).

 -- Funcedilhaão: beta (X, Y)
     A funcedilhaão beta, definida como gamma(x) gamma(y)/gamma(x + y).

 -- Funcedilhaão: gamma (X)
     A funcedilhaão gama.

     Veja também makegamma.

     A variável gammalim controla a simplificacedilhaão da funcedilhaão gama.

     A constante de Euler-Mascheroni é %gamma.

 -- Variável de opcedilhaão: gammalim
     Valor por omissão: 1000000

     gammalim controla a simplificacedilhaão da funcedilhaão gama para integral e argumentos na forma de números racionais.  Se o valor absoluto do argumento não for maior que gammalim, então a simplificacedilhaão ocorrerá.  Note que factlim comuta controle de simplificacedilhacão do resultado de gamma de um argumento inteiro também.

 -- Funcedilhaão: intopois (A)
     Converte A em um código de Poisson.

 -- Funcedilhaão: makefact (EXPR)
     Transforma instâncias de funcedilhaões binomiais, gama, e beta em EXPR para factoriais.

     Veja também makegamma.

 -- Funcedilhaão: makegamma (EXPR)
     Transforma instâncias de funcedilhaões binomiais, factorial, e beta em EXPR para funcedilhaões gama.

     Veja também makefact.

 -- Funcedilhaão: numfactor (EXPR)
     Retorna o factor numérico multiplicando a expressão EXPR, que pode ser um termo simples.

     content retorna o máximo divisor comum (mdc) de todos os termos em uma adicedilhaão.

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

 -- Funcedilhaão: outofpois (A)
     Converte A de um código de Poisson para uma representacedilhaão geral.  Se A não for uma forma de Poisson, outofpois realiza a conversão, i.e., o valor de retorno é outofpois (intopois (A)). Essa funcedilhaão é desse modo um simplificador canónico para adicedilhaões e potências de termos de seno e co-seno de um tipo particular.

 -- Funcedilhaão: poisdiff (A, B)
     Deriva A com relacedilhaão a B.  B deve ocorrer somente nos argumentos trigonométricos ou somente nos coeficientes.

 -- Funcedilhaão: poisexpt (A, B)
     Funcionalmente identica a intopois (A^B). B deve ser um inteiro positico.

 -- Funcedilhaão: poisint (A, B)
     Integra em um senso restrito similarmente (para poisdiff).  Termos não periódicos em B são diminuídos se B estiver em argumentos trigonométricos.

 -- Variável de opcedilhaão: poislim
     Valor por omissão: 5

     poislim determina o domínio dos coeficientes nos argumentos de funcedilhaõ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)].

 -- Funcedilhaão: poismap (SERIES, SINFN, COSFN)
     mapeará as funcedilhaões SINFN sobre os termos de seno e COSFN ssobre os termos de co-seno das séries de Poisson dadas. SINFN e COSFN são funcedilhaões de dois argumentos que são um coeficiente e uma parte trigonométrica de um termo em séries respectivamente.

 -- Funcedilhaão: poisplus (A, B)
     É funcionalmente identica a intopois (a + b).

 -- Funcedilhaão: poissimp (A)
     Converte A em séries de Poisson para A em representacedilhaão geral.

 -- Símbolo especial: poisson
     O símbolo /P/ segue o rótulo de linha de uma expressão contendo séries de Poisson.

 -- Funcedilhaão: poissubst (A, B, C)
     Substitue A por B em C.  C é uma série de Poisson.

     (1) Quando B é uma variável U, V, W, X, Y, ou Z, então A deve ser uma expressão linear nessas variáveis (e.g., 6*u + 4*v).

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

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

 -- Funcedilhaão: poistimes (A, B)
     É funcionalmente idêntica a intopois (A*B).

 -- Funcedilhaão: poistrim ()
     é um nome de funcedilhaão reservado que (se o utilizador tiver definido uma funcedilhaão com esse nome) é aplicada durante multiplicacedilhaão de Poisson.  Isso é uma funcedilhaão predicada de 6 argumentos que são os coeficientes de U, V, ..., Z em um termo.  Termos para os quais poistrim for true (para os coeficientes daquele termo) são eliminados durante a multiplicacedilhaão.

 -- Funcedilhaão: printpois (A)
     Mostra uma série de Poisson em um formato legível.  Em comum com outofpois, essa funcedilhaão converterá A em um código de Poisson primeiro, se necessário.

 -- Funcedilhaão: psi [N](X)

     A derivada de log (gamma (X)) de ordem N+1. Dessa forma, psi[0](X) é a primeira derivada, psi[1](X) é a segunda derivada, etc.

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

     A funcedilhaão bfpsi no pacote bffac pode calcular valores numéricos.

 -- Variável de opcedilhaão: maxpsiposint
     Valor por omissão: 20

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

 -- Variável de opcedilhaão: maxpsinegint
     Valor por omissão: -10

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

 -- Variável de opcedilhaão: maxpsifracnum
     Valor por omissão: 4

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

 -- Funcedilhaão: specint (exp(- s*T) * EXPR, T)

     Calcula a transformada de Laplace de EXPR com ralacedilhaão à variável T. O integrando EXPR pode conter funcedilhaões especiais.

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

     demo(hypgeo) mostra muitos exemplos de transformadas de Laplace calculados por specint.

     Exemplos:

          (%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

 -- Variável de opcedilhaão: maxpsifracdenom
     Valor por omissão: 4

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