Next: Introdução a QUADPACK, Previous: Introdução a Integração, Up: Integração [Contents][Index]

### 20.2 Funções e Variáveis Definidas para Integração

Função: changevar (expr, f(x,y), y, x)

  Faz a mudança de variável dada por `f(x,y) = 0` em todas as integrais que ocorrem em expr com integração em relação a x. A nova variável é y.

      (%i1) assume(a > 0)$
      (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
                            4
                           /
                           [    sqrt(a) sqrt(y)
      (%o2)                I  %e                dy
                           ]
                           /
                            0
      (%i3) changevar (%, y-z^2/a, z, y);
                            0
                           /
                           [                abs(z)
                         2 I            z %e       dz
                           ]
                           /
                            - 2 sqrt(a)
      (%o3)            - ----------------------------
                                      a

  Uma expressão contendo uma forma substantiva, tais como as instâncias de `'integrate` acima, pode ser avaliada por `ev` com o sinalizador `nouns`. Por exemplo, a expressão retornada por `changevar` acima pode ser avaliada por `ev (%o3, nouns)`.

  `changevar` pode também ser usada para alterações nos índices de uma soma ou de um produto. Todavia, isso deve obrigatóriamente ser realizado de forma que quando uma alteração é feita em uma soma ou produto, essa mudança deve ser um artifício, i.e., `i = j+ ...`, não uma função de grau mais alto. E.g.,

      (%i4) sum (a[i]*x^(i-2), i, 0, inf);
                               inf
                               ====
                               \         i - 2
      (%o4)                     >    a  x
                               /      i
                               ====
                               i = 0
      (%i5) changevar (%, i-2-n, n, i);
                              inf
                              ====
                              \               n
      (%o5)                    >      a      x
                              /        n + 2
                              ====
                              n = - 2

Função: dblint (f, r, s, a, b)

  Uma rotina de integral dupla que foi escrita no alto-nível do Maxima e então traduzida e compilada para linguagem de máquina. Use `load (dblint)` para acessar esse pacote. Isso usa o método da regra de Simpson em ambas as direções x e y para calcular

      /b /s(x)
      |  |
      |  |    f(x,y) dy dx
      |  |
      /a /r(x)

  A função f deve ser uma função traduzida ou compilada de duas variáveis, e r e s devem cada uma ser uma função traduzida ou compilada de uma variável, enquanto a e b devem ser números em ponto flutuante. A rotina tem duas variáveis globais que determinam o número de divisões dos intervalos x e y: `dblint_x` e `dblint_y`, ambas as quais são inicialmente 10, e podem ser alteradas independentemente para outros valores inteiros (existem `2*dblint_x+1` pontos calculados na direção x , e `2*dblint_y+1` na direção y). A rotina subdivide o eixo X e então para cada valor de X isso primeiro calcula `r(x)` e `s(x)`; então o eixo Y entre `r(x)` e `s(x)` é subdividido e a integral ao longo do eixo Y é executada usando a regra de Simpson; então a integral ao longo do eixo X é concluída usando a regra de Simpson com os valores da função sendo as integrais-Y. Esse procedimento pode ser numericamente instável por uma grande variedade razões, mas razoávelmente rápido: evite usar isso sobre funções altamente oscilatórias e funções com singularidades (postes ou pontos de ramificação na região). As integrais Y dependem de quanto fragmentados `r(x)` e `s(x)` são, então se a ditância `s(x) - r(x)` varia rapidamente com X, nesse ponto pode ter erros substanciais provenientes de truncação com diferentes saltos-tamanhos nas várias integrais Y. Um pode incrementar `dblint_x` e `dblint_y` em uma tentativa para melhorar a convergência da reião, com sacrifício do tempo de computação. Os valores da função não são salvos, então se a função é muito desperdiçadora de tempo,você terá de esperar por re-computação se você mudar qualquer coisa (desculpe). Isso é requerido que as funções f, r, e s sejam ainda traduzidas ou compiladas previamente chamando `dblint`. Isso resultará em ordens de magnitude de melhoramentos de velocidade sobre o código interpretado em muitos casos!

  `demo (dblint)` executa uma demonstração de `dblint` aplicado a um problema exemplo.

Função: defint (expr, x, a, b)

  Tenta calcular uma integral definida. `defint` é chamada por `integrate` quando limites de integração são especificados, i.e., quando `integrate` é chamado como `integrate (expr, x, a, b)`. Dessa forma do ponto de vista do usuário, isso é suficiente para chamar `integrate`.

  `defint` retorna uma expressão simbólica, e executa um dos dois: ou calcula a integral ou a forma substantiva da integral. Veja `quad_qag` e funções rellacionadas para aproximação numérica de integrais definidas.

Função: erf (x)

  Representa a função de erro, cuja derivada é: `2*exp(-x^2)/sqrt(%pi)`.

Variável de opção: erfflag

  Valor padrão: `true`

  Quando `erfflag` é `false`, previne `risch` da introdução da função `erf` na resposta se não houver nenhum no integrando para começar.

Função: ilt (expr, t, s)

  Calcula a transformação inversa de Laplace de expr em relação a t e parâmetro s. expr deve ser uma razão de polinômios cujo denominador tem somente fatores lineares e quadráticos. Usando a funções `laplace` e `ilt` juntas com as funções `solve` ou `linsolve` o usuário pode resolver uma diferencial simples ou uma equação integral de convolução ou um conjunto delas.

      (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
                    t
                   /
                   [                                    2
      (%o1)        I  f(t - x) sinh(a x) dx + b f(t) = t
                   ]
                   /
                    0
      (%i2) laplace (%, t, s);
                                     a laplace(f(t), t, s)   2
      (%o2)  b laplace(f(t), t, s) + --------------------- = --
                                             2    2           3
                                            s  - a           s
      (%i3) linsolve ([%], ['laplace(f(t), t, s)]);
                                              2      2
                                           2 s  - 2 a
      (%o3)     [laplace(f(t), t, s) = --------------------]
                                          5         2     3
                                       b s  + (a - a  b) s
      (%i4) ilt (rhs (first (%)), s, t);
      Is  a b (a b - 1)  positive, negative, or zero?

      pos;
                     sqrt(a b (a b - 1)) t
              2 cosh(---------------------)       2
                               b               a t
      (%o4) - ----------------------------- + -------
                    3  2      2               a b - 1
                   a  b  - 2 a  b + a

                                                             2
                                                   + ------------------
                                                      3  2      2
                                                     a  b  - 2 a  b + a

Função: integrate (expr, x)
Função: integrate (expr, x, a, b)

  Tenta símbolicamente calcular a integral de expr em relação a x. `integrate (expr, x)` é uma integral indefinida, enquanto `integrate (expr, x, a, b)` é uma integral definida, com limites de integração a e b. Os limites não poderam conter x, embora `integrate` não imponha essa restrição. a não precisa ser menor que b. Se b é igual a a, `integrate` retorna zero.

  Veja `quad_qag` e funções relacionadas para aproximação numérica de integrais definidas. Veja `residue` para computação de resíduos (integração complexa). Veja `antid` para uma forma alternativa de calcular integrais indefinidas.

  A integral (uma expressão livre de `integrate`) é retornada se `integrate` obtém sucesso. De outra forma o valor de retorno é a forma substantiva da integral (o operador com apóstrofo `'integrate`) ou uma expressão contendo uma ou mais formas substantivas. A forma substantiva de `integrate` é mostrada com um sinal de integral.

  Em algumas circunstâncias isso é útil para construir uma forma substantiva manualmente, colocando em `integrate` um apóstrofo, e.g., `'integrate (expr, x)`. Por exemplo, a integral pode depender de alguns parâmetos que não estão ainda calculados. A forma substantiva pode ser aplicada a seus argumentos por `ev (i, nouns)` onde i é a forma substantiva de interesse.

  `integrate` manuseia integrais definidas separadamente das indefinidas, e utiliza uma gama de heurísticas para manusear cada caso. Casos especiais de integrais definidas incluem limites de integração iguais a zero ou infinito (`inf` ou `minf`), funções trigonométricas com limites de integração iguais a zero e `%pi` ou `2 %pi`, funções racionais, integrais relacionadas para as definições de funções `beta` e `psi`, e algumas integrais logarítmicas e trigonométricas. Processando funções racionais pode incluir computação de resíduo. Se um caso especial aplicável não é encontrado, tentativa será feita para calcular a integra indefinida e avaliar isso nos limites de integração. Isso pode incluir pegar um limite como um limite de integração tendendo ao infinito ou a menos infinito; veja também `ldefint`.

  Casos especiais de integrais indefinidas incluem funções trigonométricas, exponenciais e funções logarítmicas, e funções racionais. `integrate` pode também fazer uso de uma curta tabela de integais elementares.

  `integrate` pode realizar uma mudança de variável se o integrando tem a forma `f(g(x)) * diff(g(x), x)`. `integrate` tenta achar uma subexpressão `g(x)` de forma que a derivada de `g(x)` divida o integrando. Essa busca pode fazer uso de derivadas definidas pela função `gradef`. Veja também `changevar` e `antid`.

  Se nenhum dos procedimentos heurísticos acha uma integral indefinida, o algorítmo de Risch é executado. O sinalizador `risch` pode ser escolhido como um `evflag`, na chamada para `ev` ou na linha de comando, e.g., `ev (integrate (expr, x), risch)` ou `integrate (expr, x), risch`. Se `risch` está presente, `integrate` chama a função `risch` sem tentar heurísticas primeiro. Veja também `risch`.

  `integrate` trabalha somente com relações funcionais representadas explicitamente com a notação `f(x)`. `integrate` não respeita dependências implicitas estabelecidas pela função `depends`. `integrate` pode necessitar conhecer alguma propriedade de um parâmetro no integrando. `integrate` irá primeiro consultar a base de dados do `assume`, e , se a variável de interesse não está lá, `integrate` perguntará ao usuário. Dependendo da pergunta, respostas adequadas são `yes;` ou `no;`, ou `pos;`, `zero;`, ou `neg;`.

  `integrate` não é, por padrão, declarada ser linear. Veja `declare` e `linear`.

  `integrate` tenta integração por partes somente em uns poucos casos especiais.

  Exemplos:

  - Integrais definidas e indefinidas elementares.

        (%i1) integrate (sin(x)^3, x);
                                   3
                                cos (x)
        (%o1)                   ------- - cos(x)
                                   3
        (%i2) integrate (x/ sqrt (b^2 - x^2), x);
                                         2    2
        (%o2)                    - sqrt(b  - x )
        (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
                                       %pi
                                   3 %e      3
        (%o3)                      ------- - -
                                      5      5
        (%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
                                    sqrt(%pi)
        (%o4)                       ---------
                                        2

  - Uso de `assume` e dúvida interativa.

        (%i1) assume (a > 1)$
        (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
            2 a + 2
        Is  -------  an integer?
               5

        no;
        Is  2 a - 3  positive, negative, or zero?

        neg;
                                           3
        (%o2)                  beta(a + 1, - - a)
                                           2

  - Mudança de variável. Existem duas mudanças de variável nesse exemplo: uma usando a derivada estabelecida por `gradef`, e uma usando a derivação `diff(r(x))` de uma função não especificada `r(x)`.

        (%i3) gradef (q(x), sin(x**2));
        (%o3)                         q(x)
        (%i4) diff (log (q (r (x))), x);
                              d               2
                             (-- (r(x))) sin(r (x))
                              dx
        (%o4)                ----------------------
                                    q(r(x))
        (%i5) integrate (%, x);
        (%o5)                     log(q(r(x)))

  - O valor de retorno contém a forma substantiva `'integrate`. Nesse exemplo, Maxima pode extrair um fator do denominador de uma função racional, mas não pode fatorar o restante ou de outra forma achar sua integral. `grind` mostra a forma substantiva `'integrate` no resultado. Veja também `integrate_use_rootsof` para mais sobre integrais de funções racionais.

        (%i1) expand ((x-4) * (x^3+2*x+1));
                            4      3      2
        (%o1)              x  - 4 x  + 2 x  - 7 x - 4
        (%i2) integrate (1/%, x);
                                      /  2
                                      [ x  + 4 x + 18
                                      I ------------- dx
                                      ]  3
                         log(x - 4)   / x  + 2 x + 1
        (%o2)            ---------- - ------------------
                             73               73
        (%i3) grind (%);
        log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$

  - Definindo uma função em termos de uma integral. O corpo de uma função não é avaliado quando a função é definida. Dessa forma o corpo de `f_1` nesse exemplo contém a forma substantiva de `integrate`. O operador apóstrofo-apóstrofo `''` faz com que a integral seja avaliada, e o resultado transforme-se no corpo de `f_2`.

        (%i1) f_1 (a) := integrate (x^3, x, 1, a);
                                             3
        (%o1)           f_1(a) := integrate(x , x, 1, a)
        (%i2) ev (f_1 (7), nouns);
        (%o2)                          600
        (%i3) /* Note parentheses around integrate(...) here */
              f_2 (a) := ''(integrate (x^3, x, 1, a));
                                           4
                                          a    1
        (%o3)                   f_2(a) := -- - -
                                          4    4
        (%i4) f_2 (7);
        (%o4)                          600

Variável de sistema: integration_constant_counter

  Valor padrão: 0

  `integração_constant_counter` é um contador que é atualizado a cada vez que uma constante de integração (nomeada pelo Maxima, e.g., `integrationconstant1`) é introduzida em uma expressão pela integração indefinida de uma equação.

Variável de opção: integrate_use_rootsof

  Valor padrão: `false`

  Quando `integrate_use_rootsof` é `true` e o denominador de uma função racional não pode ser fatorado, `integrate` retorna a integral em uma forma que é uma soma sobre as raízes (não conhecidas ainda) do denominador.

  Por exemplo, com `integrate_use_rootsof` escolhido para `false`, `integrate` retorna uma integral não resolvida de uma função racional na forma substantiva:

      (%i1) integrate_use_rootsof: false$
      (%i2) integrate (1/(1+x+x^5), x);
              /  2
              [ x  - 4 x + 5
              I ------------ dx                            2 x + 1
              ]  3    2                2            5 atan(-------)
              / x  - x  + 1       log(x  + x + 1)          sqrt(3)
      (%o2)   ----------------- - --------------- + ---------------
                      7                 14             7 sqrt(3)

  Agora vamos escolher o sinalizador para ser true e a parte não resolvida da integral será expressa como um somatório sobre as raízes do denominador da função racional:

      (%i3) integrate_use_rootsof: true$
      (%i4) integrate (1/(1+x+x^5), x);
            ====        2
            \       (%r4  - 4 %r4 + 5) log(x - %r4)
             >      -------------------------------
            /                    2
            ====            3 %r4  - 2 %r4
                              3      2
            %r4 in rootsof(%r4  - %r4  + 1, %r4)
      (%o4) ----------------------------------------------------------
                     7

                                                                   2 x + 1
                                               2            5 atan(-------)
                                          log(x  + x + 1)          sqrt(3)
                                        - --------------- + ---------------
                                                14             7 sqrt(3)

  Alternativamente o usuário pode calcular as raízes do denominador separadamente, e então expressar o integrando em termos dessas raízes, e.g., `1/((x - a)*(x - b)*(x - c))` ou `1/((x^2 - (a+b)*x + a*b)*(x - c))` se o denominador for um polinômio cúbico. Algumas vezes isso ajudará Maxima a obter resultados mais úteis.

Função: ldefint (expr, x, a, b)

  Tenta calcular a integral definida de expr pelo uso de `limit` para avaliar a integral indefinida expr em relação a x no limite superior b e no limite inferior a. Se isso falha para calcular a integral definida, `ldefint` retorna uma expressão contendo limites como formas substantivas.

  `ldefint` não é chamada por `integrate`, então executando `ldefint (expr, x, a, b)` pode retornar um resultado diferente de `integrate (expr, x, a, b)`. `ldefint` sempre usa o mesmo método para avaliar a integral definida, enquanto `integrate` pode utilizar várias heurísticas e pode reconhecer alguns casos especiais.

Função: potential (givengradient)

  O cálculo faz uso da variável global `potentialzeroloc[0]` que deve ser `nonlist` ou da forma

      [indeterminatej=expressãoj, indeterminatek=expressãok, ...]

  O formador sendo equivalente para a expressão nonlist para todos os lados direitos-manuseados mais tarde. Os lados direitos indicados são usados como o limite inferior de integração. O sucesso das integrações pode depender de seus valores e de sua ordem. `potentialzeroloc` é inicialmente escolhido para 0.

Função: residue (expr, z, z_0)

  Calcula o resíduo no plano complexo da expressão expr quando a variável z assumes o valor z_0. O resíduo é o coeficiente de `(z - z_0)^(-1)` nas séries de Laurent para expr.

      (%i1) residue (s/(s**2+a**2), s, a*%i);
                                      1
      (%o1)                           -
                                      2
      (%i2) residue (sin(a*x)/x**4, x, 0);
                                       3
                                      a
      (%o2)                         - --
                                      6

Função: risch (expr, x)

  Integra expr em relação a x usando um caso transcendental do algorítmo de Risch. (O caso algébrico do algorítmo de Risch foi implementado.) Isso atualmente manuseia os casos de exponenciais aninhadas e logarítmos que a parte principal de `integrate` não pode fazer. `integrate` irá aplicar automaticamente `risch` se dados esses casos.

  `erfflag`, se `false`, previne `risch` da introdução da função `erf` na resposta se não for achado nenhum no integrando para começar.

      (%i1) risch (x^2*erf(x), x);
                                                              2
                   3                      2                - x
              %pi x  erf(x) + (sqrt(%pi) x  + sqrt(%pi)) %e
      (%o1)   -------------------------------------------------
                                    3 %pi
      (%i2) diff(%, x), ratsimp;
                                   2
      (%o2)                       x  erf(x)

Função: tldefint (expr, x, a, b)

  Equivalente a `ldefint` com `tlimswitch` escolhido para `true`.

Next: Introdução a QUADPACK, Previous: Introdução a Integração, Up: Integração [Contents][Index]