Anterior: Introdução a Funções Especiais, Acima: Funções Especiais [Conteúdo][Índice]
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á desactualizada. 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 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
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).
Idêntica a scaled_bessel_i(0,z).
Idêntica a scaled_bessel_i(1,z).
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 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.
Converte a em um código de Poisson.
Transforma instâncias de funções binomiais, gama, e beta em expr para factoriais.
Veja também makegamma.
Transforma instâncias de funções binomiais, factorial, e beta em expr para funções gama.
Veja também makefact.
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
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.
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 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)].
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.
É 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é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).
É funcionalmente idêntica a intopois (a*b).
é 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.
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 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.
Valor por omissão: 20
maxpsiposint é o maior valor positivo para o qual
psi[n](x) irá tentar calcular um valor exato.
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.
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.
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
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.
Anterior: Introdução a Funções Especiais, Acima: Funções Especiais [Conteúdo][Índice]