16. Funções Especiais

16.1 Introdução a Funções Especiais

16.2 specint

hypgeo é um pacote para manusear transformações de Laplace de funções especiais. hyp é um pacote para manusear funções Hipergeométricas generalizadas.

specint tenta calcular a integral definida (sobre o intervalo de zero a infinito) de uma expressão contendo funções especiais. Quando o integrando contém um fator exp (-s t), o resultado é uma transformação de Laplace.

A sintaxe é como segue:

specint (exp (-s*t) * expr, t);

onde t é a variável de integração e expr é uma expressão contendo funções especiais.

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

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

demo ("hypgeo") mostra muitos exemplos de transformações de Laplace calculadas através de specint.

Esse é um trabalho em andamento. Alguns nomes de funções podem mudar.

16.3 Definições para Funções Especiais

Função: airy (x)

A função de Airy Ai. Se o argumento x for um número, o valor numérico de airy (x) é retornado. de outra forma, uma expressão não avaliada airy (x) é retornada.

A equação de Airy diff (y(x), x, 2) - x y(x) = 0 tem duas soluções linearmente independentes, chamadas ai e bi. Essa equação é muito popular como uma aproximação para problemas mais complicados em muitos ambientes de física matemática.

load ("airy") chama as funções ai, bi, dai, e dbi.

O pacote airy contém rotinas para calcular ai e bi e suas derivadas dai e dbi. O resultado é um número em ponto flutuante se o argumento for um número, e uma expressão não avaliada de outra forma.

Um erro ocorre se o argumento for maior que o esperado causando um estouro nas exponenciais, ou uma perda de precisão no sin ou no cos. Isso faz o intervalo de validade sobre -2800 a 10^38 para ai e dai, e de -2800 a 25 para bi e dbi.

Essas regras de derivação são conhecidas para Maxima:

• diff (ai(x), x) retorna dai(x),
• diff (dai(x), x) retorna x ai(x),
• diff (bi(x), x) retorna dbi(x),
• diff (dbi(x), x) retorna x bi(x).

Valores de função são calculados a partir das séries de Taylor convergentes para abs(x) < 3, e a partir de expansões assintóticas para x < -3 ou x > 3 como necessário. Esses resultados somente apresentam discrepâncias numéricas muito pequenas em x = 3 e x = -3. Para detalhes, veja Abramowitz e Stegun, Handbook of Mathematical Functions, Sessão 10.4 e Tabela 10.11.

ev (taylor (ai(x), x, 0, 9), infeval) retorna uma expansão de Taylor em ponto flutuante da função ai. Uma expressão similar pode ser construída para bi.

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

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 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: j0 (x)

A função de Bessel de primeiro tipo de ordem 0.

Essa função está desatualizada. Escreva bessel_j (0, x) em lugar dessa função.

Função: j1 (x)

A função de Bessel de primeiro tipo de ordem 1.

Essa função está desatualizada. Escreva bessel_j (1, x) em lugar dessa função.

Função: jn (x, n)

A função de Bessel de primeiro tipo de ordem n.

Essa função éstá desatualizada. Escreva bessel_j (n, x) em lugar dessa função.

Função: i0 (x)

A função de Bessel modificada de primeiro tipo de ordem 0.

Essa função éstá desatualizada. Escreva bessel_i (0, x) em lugar dessa função.

Função: i1 (x)

A função de Bessel modificada de primeiro tipo de ordem 1.

Essa função está desatualizada. Escreva bessel_i (1, x) em lugar dessa função.

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 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 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 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 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: 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.

Variável de opção: maxpsifracdenom

Valor padrã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.

This document was generated by root on Outubro, 18 2006 using texi2html 1.76.