[ < ] [ > ]   [ << ] [ 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 L de 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 Funções e Variáveis Definidas 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á desatualizada. 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

embora 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 padrã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 padrã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 fatoriais.

Veja também makegamma.

Função: makegamma (expr)

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

Veja também makefact.

Função: numfactor (expr)

Retorna o fator 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 cosseno de um tipo particular.

Função: poisdiff (a, b)

Deriva a em 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 padrã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 cosseno 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é disso, livre de senos ou cossenos.

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 usuário 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 padrã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 padrã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 padrão: 6

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.

Variável de opção: maxpsifracdenom

Valor padrão: 6

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

Function: specint (exp(- s*t) * expr, t)

Calcula a trasformada de Laplace de expr com relação à variável t. O integrando expr pode conter funções especiais.

Se specint não puder calcular a integral, o valor de retorno pode coter 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 tansformadas de Laplace calculados por meio de 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

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

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