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

Função: psi [n](x)

A derivada de log (gamma (x)).

Maxima não sabe como calcular um valor numérico de psi. Todavia, a função bfpsi no pacote bffac pode calcular valores numéricos.

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