[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
16.1 Introdução a Funções Especiais | ||
16.2 specint | ||
16.3 Definições para Funções Especiais |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
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: |
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.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
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
.
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
.
A derivada da função de Airy Ai airy_ai(x)
.
Veja airy_ai
.
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
.
A derivada de função de Airy Bi airy_bi(x)
.
Veja airy_ai
e airy_bi
.
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.
A função de Bessel de primeiro tipo.
Essa função está desatualizada. Escreva bessel_j (z, a)
em lugar dessa.
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.
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.
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.
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.
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 |
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.
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.
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.
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.
A função de Bessel modificada de primeiro tipo de ordem 1.
Essa função está desatualizada. Escreva bessel_i (1,
em lugar dessa função.
x
)
A função beta, definida como gamma(x) gamma(y)/gamma(x + y)
.
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
.
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.
Converte a em um código de Poisson.
Transforma instâncias de funções binomiais, gama, e beta em expr para fatoriais.
Veja também makegamma
.
Transforma instâncias de funções binomiais, fatorial, e beta em expr para funções gama.
Veja também makefact
.
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 |
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.
Deriva a com relação a b. b deve ocorrer somente nos argumentos trigonométricos ou somente nos coeficientes.
Funcionalmente identica a intopois (a^b)
.
b deve ser um inteiro positico.
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.
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)].
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.
É funcionalmente identica a intopois (a + b)
.
Converte a em séries de Poisson para a em representação geral.
O símbolo /P/
segue o rótulo de linha de uma expressão contendo séries de
Poisson.
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)
.
É funcionalmente idêntica a intopois (a*b)
.
é 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.
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.
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.
Valor padrão: 20
maxpsiposint
é o maior valor positivo para o qual
psi[n](x)
irá tentar calcular um valor exato.
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.
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.
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.
[ << ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
This document was generated by root on Outubro, 18 2006 using texi2html 1.76.