[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

16. Funções Especiais


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

16.1 Introdução a Funções Especiais

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

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: he, não 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
gammagreek(a,z)                Função gama incompleta
gammaincomplete(a,z)           Final da função gama incompleta
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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Índice] [ ? ]

16.2 Definições para Funções Especiais

Função: airy_ai (x)

A função de Airy Ai, como definida em Abramowitz e Stegun, Handbook of Mathematical Functions, Sessão 10.4.

A equação de Airy diff (y(x), x, 2) - x y(x) = 0 tem duas soluçõ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.

Função: airy_dai (x)

A derivada da função de Airy Ai airy_ai(x).

Veja airy_ai.

Função: airy_bi (x)

A função de Airy Bi, como definida em Abramowitz e Stegun, Handbook of Mathematical Functions, Sessão 10.4, é a segunda solução da equaçã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.

Função: airy_dbi (x)

A derivada de função de Airy Bi airy_bi(x).

Veja airy_ai e airy_bi.

Função: asympa

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.

load ("asympa") chama esse pacote.

Função: bessel (z, a)

A função de Bessel de primeiro tipo.

Essa função está desactualizada. Escreva bessel_j (z, a) em lugar dessa.

Função: bessel_j (v, z)

A funçã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.

Função: bessel_y (v, z)

A funçã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.

Função: bessel_i (v, z)

A funçã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.

Função: bessel_k (v, z)

A funçã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 opção: besselexpand

Valor por omissão: false

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 besselexpand for true, a funçã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
Função: scaled_bessel_i (v, z)

A funçã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 função é particularmente útil para calcular bessel_i para grandes valores de 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 exp(-abs(z))*bessel_i(v, z).

Função: scaled_bessel_i0 (z)

Idêntica a scaled_bessel_i(0,z).

Função: scaled_bessel_i1 (z)

Idêntica a scaled_bessel_i(1,z).

Função: beta (x, y)

A função beta, definida como gamma(x) gamma(y)/gamma(x + y).

Função: gamma (x)

A função gama.

Veja também makegamma.

A variável gammalim controla a simplificação da função gama.

A constante de Euler-Mascheroni é %gamma.

Variável de opção: gammalim

Valor por omissão: 1000000

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 gammalim, então a simplificação ocorrerá. Note que factlim comuta controle de simplificaçcão do resultado de gamma de um argumento inteiro também.

Função: intopois (a)

Converte a em um código de Poisson.

Função: makefact (expr)

Transforma instâncias de funções binomiais, gama, e beta em expr para factoriais.

Veja também makegamma.

Função: makegamma (expr)

Transforma instâncias de funções binomiais, factorial, e beta em expr para funções gama.

Veja também makefact.

Funçã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 adição.

(%i1) gamma (7/2);
                          15 sqrt(%pi)
(%o1)                     ------------
                               8
(%i2) numfactor (%);
                               15
(%o2)                          --
                               8
Função: outofpois (a)

Converte a de um código de Poisson para uma representaçã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 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.

Função: poisdiff (a, b)

Deriva a com relação a b. b deve ocorrer somente nos argumentos trigonométricos ou somente nos coeficientes.

Função: poisexpt (a, b)

Funcionalmente identica a intopois (a^b). b deve ser um inteiro positico.

Funçã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 opção: poislim

Valor por omissão: 5

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)].

Função: poismap (series, sinfn, cosfn)

mapeará as funçõ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 funções de dois argumentos que são um coeficiente e uma parte trigonométrica de um termo em séries respectivamente.

Função: poisplus (a, b)

É funcionalmente identica a intopois (a + b).

Função: poissimp (a)

Converte a em séries de Poisson para a em representaçã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.

Funçã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 substituiçã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 substituiçã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).

Função: poistimes (a, b)

É funcionalmente idêntica a intopois (a*b).

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 u, v, ..., z em um termo. Termos para os quais poistrim for true (para os coeficientes daquele termo) são eliminados durante a multiplicação.

Função: printpois (a)

Mostra uma série de Poisson em um formato legível. Em comum com outofpois, essa função converterá a em um código de Poisson primeiro, se necessário.

Funçã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 maxpsifracdenom. 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 função bfpsi no pacote bffac pode calcular valores numéricos.

Variável de opçã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 opçã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 opçã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.

Função: specint (exp(- s*t) * expr, t)

Calcula a transformada de Laplace de expr com ralação à variável t. O integrando expr pode conter funçõ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 opçã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.


[ << ] [ >> ]           [Top] [Contents] [Índice] [ ? ]

This document was generated by Jaime Villate on Outubro, 19 2014 using texi2html 1.76.