[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 16. Funções Especiais

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 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 de L Struve
    %f[p,q] ([], [], expr)         Função Hipergeométrica Generalizada
    gamma()                        Função Gamma
    gamma_incomplete_lower(a,z)    Função gama incompleta inferior
    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] | [Index] | [ ? ]

## 16.2 Definições 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á desactualizada. 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 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

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

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

  Veja também `makegamma`.

Função: makegamma (expr)

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

  Veja também `makefact`.

Função: numfactor (expr)

  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

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 co-seno 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 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)].

Função: poismap (series, sinfn, cosfn)

  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.

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é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)`.

Função: poistimes (a, b)

  É funcionalmente idêntica a `intopois (a*b)`.

Função: poistrim ()

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

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 por omissã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 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.

Variável de opção: maxpsifracnum

  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.

Função: specint (exp(- s*t) * expr, t)

  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

Variável de opção: maxpsifracdenom

  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.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by U-Cygwin\ASSI on noviembre, 12 2017 using texi2html 1.76.