Introducedilhaão a Integracedilhaão
===================================

Maxima tem muitas rotinas para realizar integracedilhaão.  A funcedilhaão integrate faz uso de muitas dessas.  Exite também o pacote antid, que manuseia uma funcedilhaão não especificada (e suas derivadas, certamente).  Para usos numericos, existe um conjunto de integradores adaptativos de QUADPACK, a saber quad_qag, quad_qags, etc., os quais são descritos sob o tópico QUADPACK.  Funcedilhaões hipergeométricas estão sendo trabalhadas, veja specint para detalhes. Geralmente falando, Maxima somente calcula integrais que sejam integráveis em termos de "funcedilhaões elementares" (funcedilhaões racionais, trigonometricas, logarítmicas, exponenciais, radicais, etc.) e umas poucas extensões (funcedilhaão de erro, dilogaritmo). Nã consegue calcular integrais em termos de funcedilhaões desconhecidas tais como g(x) e h(x).

Definicedilhaões para Integracedilhaão
======================================

 -- Funcedilhaão: changevar (EXPR, F(X,Y), Y, X)
     Faz a mudancedilhaa de variável dada por F(X,Y) =
     0 em todos os integrais que existam em EXPR com integracedilhaão em relacedilhaã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 alteracedilhaões nos índices de uma soma ou de um produto. No entanto, é de salientar que quando seja feita uma alteracedilhaão a uma soma ou produto, essa mudancedilhaa deverá ser apenas uma deslocacedilhaão do índice, nomeadamente, i = j+ ..., e não uma funcedilhaão de grau superior. Por exemplo,

          (%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

 -- Funcedilhaão: dblint (F, R, S, A, B)
     Esta é uma rotina de integral duplo que foi escrita na linguagem de alto nível do Maxima sendo logo traduzida e compilada para linguagem de máquina. Use load (dblint) para poder usar este pacote. Esta funcedilhaão usa o método da regra de Simpson em ambas as direcedilhaões x e y para calcular

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

     A funcedilhaão F deve ser uma funcedilhaão traduzida ou compilada de duas variáveis, e R e S devem cada uma ser uma funcedilhaã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 direcedilhaão x , e 2*dblint_y+1 na direcedilhaão y).  A rotina subdivide o eixo X e então para cada valor de X primeiro calcula R(x) e S(x); então o eixo Y entre R(x) e S(x) é subdividido e o integral ao longo do eixo Y é executado usando a regra de Simpson; então o integral ao longo do eixo X é concluído usando a regra de Simpson com os valores da funcedilhaão sendo os integrais em Y.  Esse procedimento pode ser numericamente instável por várias razões, mas razoávelmente rápido: evite usar este progrma sobre funcedilhaões altamente oscilatórias e funcedilhaões com singularidades (pólos ou pontos de ramificacedilhaão na região).  Os integrais em Y dependem de quanto fragmentados R(x) e S(x) sejam; assim, se a distância S(x) - R(x) variar rapidamente com X, nesse ponto podrão surgir erros substanciais provenientes de truncacedilhaão com saltos de diferentes tamanhos nos vários integrais Y. Pode incrementar-se dblint_x e dblint_y numa tentativa para melhorar a convergência da região, com um aumento no tempo de computacedilhaão.  Os valores da funcedilhaão não são guardados, portanto se a funcedilhaão desperdicedilhar muito tempo, terá de esperar pela re-computacedilhaão cada vez que mudar qualquer coisa (pedimos desculpa por esse facto). É necessário que as funcedilhaõ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 demonstracedilhaão de dblint aplicado a um problema exemplo.

 -- Funcedilhaão: defint (EXPR, X, A, B)
     Tenta calcular um integral definido. defint é chamada por integrate quando limites de integracedilhaão são especificados, i.e., quando integrate é chamado como integrate (EXPR, X, A, B). Dessa forma do ponto de vista do utilizador, isso é suficiente para chamar integrate.

     defint retorna uma expressão simbólica, e executa um dos dois: ou calcula o integral ou a forma substantiva do integral. Veja quad_qag e funcedilhaões rellacionadas para aproximacedilhaão numérica de integrais definidos.

 -- Funcedilhaão: erf (X)
     Representa a funcedilhaão de erro, cuja derivada é: 2*exp(-x^2)/sqrt(%pi).

 -- Variável de opcedilhaão: erfflag
     Valor por omissão: true

     Quando erfflag é false, previne risch da introducedilhaão da funcedilhaão erf na resposta se não houver nenhum no integrando para comecedilhaar.

 -- Funcedilhaão: ilt (EXPR, T, S)
     Calcula a transformacedilhaão inversa de Laplace de EXPR em relacedilhaão a T e parâmetro S.  EXPR deve ser uma razão de polinómios cujo denominador tem somente factores lineares e quadráticos. Usando a funcedilhaões laplace e ilt juntas com as funcedilhaões solve ou linsolve o utilizador pode resolver uma diferencial simples ou uma equacedilhaão integral de convolucedilhaã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

 -- Funcedilhaão: integrate (EXPR, X)
 -- Funcedilhaão: integrate (EXPR, X, A, B)
     Tenta símbolicamente calcular o integral de EXPR em relacedilhaão a X. integrate (EXPR, X) é um integral indefinido, enquanto integrate (EXPR, X, A, B) é um integral definido, com limites de integracedilhaão A e B. Os limites não poderam conter X, embora integrate não imponha essa restricedilhaão. A não precisa ser menor que B. Se B é igual a A, integrate retorna zero.

     Veja quad_qag e funcedilhaões relacionadas para aproximacedilhaão numérica de integrais definidos. Veja residue para computacedilhaão de resíduos (integracedilhaão complexa). Veja antid para uma forma alternativa de calcular integrais indefinidos.

     O integral (uma expressão livre de integrate) é calculado se integrate for bem sucedido. De outra forma o valor de retorno é a forma substantiva do integral (o operador com apóstrofo 'integrate) ou uma expressão contendo uma ou mais formas substantivas. A forma substantiva de integrate é apresentada com um símbolo de integracedilhaão.

     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, o 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 calcula integrais definidos separadamente dos indefinidos, e utiliza uma gama de heurísticas para simplificar cada caso.  Casos especiais de integrais definidos incluem limites de integracedilhaão iguais a zero ou infinito (inf ou minf), funcedilhaões trigonométricas com limites de integracedilhaão iguais a zero e %pi ou 2 %pi, funcedilhaões racionais, integrais relacionados com as definicedilhaões das funcedilhaões beta e psi, e alguns integrais logarítmicos e trigonométricos.  O processamento de funcedilhaões racionais pode incluir cálculo de resíduos.  Se um caso especial aplicável não for encontrado, será feita uma tentativa para calcular o integral indefinido e avaliá-lo nos limites de integracedilhaão.  Isso pode incluir o cálculo de um limite nos casos em que um dos limites do integral for para infinito ou menos infinito; veja também ldefint.

     Casos especiais de integrais indefinidos incluem funcedilhaões trigonométricas, exponenciais e funcedilhaões logarítmicas, e funcedilhaões racionais.  integrate pode também fazer uso de uma pequena tabela de integais elementares.

     integrate pode realizar uma mudancedilhaa de variável se o integrando tiver 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 funcedilhaão gradef. Veja também changevar e antid.

     Se nenhum dos procedimentos heurísticos conseguir calcular o integral indefinido, o algoritmo de Risch é executado. O sinalizador risch pode ser utilizado como um parâmetro para ev, ou na linha de comando, nomeadamente, ev (integrate (EXPR, X), risch) ou integrate (EXPR, X), risch.  Se risch estiver presente, integrate chamará a funcedilhaão risch sem tentar heurísticas primeiro. Veja também risch.

     integrate trabalha somente com relacedilhaões funcionais representadas explicitamente com a notacedilhaão f(x). integrate não respeita dependências implicitas estabelecidas pela funcedilhaã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 utilizador. 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 integracedilhaão por partes somente em uns poucos casos especiais.

     Exemplos:

       * Integrais definidos e indefinidos 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

       * Mudancedilhaa de variável.  Existem duas mudancedilhaas de variável nesse exemplo: uma usando a derivada estabelecida por gradef, e uma usando a derivacedilhaão diff(r(x)) de uma funcedilhaã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 resultado contém a forma substantiva 'integrate.  Neste exemplo, Maxima pode extrair um factor do denominador de uma funcedilhaão racional, mas não pode factorizar o restante ou de outra forma achar o seu integral.  grind mostra a forma substantiva 'integrate no resultado.  Veja também integrate_use_rootsof para mais informacedilhaes sobre integrais de funcedilhaõ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 funcedilhaão em termos de um integral.  O corpo de uma funcedilhaão não é avaliado quando a funcedilhaão é definida.  Dessa forma o corpo de f_1 nesse exemplo contém a forma substantiva de integrate.  O operador de doi apóstrofos seguidos '' faz com que o integral seja avaliado, e o resultado se 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 por omissão: 0

     integration_constant_counter é um contador que é actualizado a cada vez que uma constante de integracedilhaão (nomeada pelo Maxima, por exemplo, integrationconstant1) é introduzida numa expressão obtida após a integracedilhaão indefinida de uma equacedilhaão.

 -- Variável de opcedilhaão: integrate_use_rootsof
     Valor por omissão: false

     Quando integrate_use_rootsof é true e o denominador de uma funcedilhaão racional não pode ser factorizado, integrate retorna o 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 um integral não resolvido de uma funcedilhaã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 do integral será escrito como uma soma sobre as raízes do denominador da funcedilhaã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(x  - x  + 1)
          (%o4) ----------------------------------------------------------
                         7

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

     Alternativamente o utilizador 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.

 -- Funcedilhaão: ldefint (EXPR, X, A, B)
     Tenta calcular o integral definido de EXPR pelo uso de limit para avaliar o integral indefinido EXPR em relacedilhaão a X no limite superior B e no limite inferior A. Se isso falha para calcular o integral definido, 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 o integral definido, enquanto integrate pode utilizar várias heurísticas e pode reconhecer alguns casos especiais.

 -- Funcedilhaã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 integracedilhaão.  O sucesso das integracedilhaões pode depender de seus valores e de sua ordem.  potentialzeroloc é inicialmente escolhido para 0.

 -- Funcedilhaã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

 -- Funcedilhaão: risch (EXPR, X)
     Integra EXPR em relacedilhaão a X usando um caso transcendental do algoritmo de Risch.  (O caso algébrico do algoritmo de Risch foi implementado.)  Isso actualmente manuseia os casos de exponenciais aninhadas e logaritmos 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 introducedilhaão da funcedilhaão erf na resposta se não for achado nenhum no integrando para comecedilhaar.

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

 -- Funcedilhaão: tldefint (EXPR, X, A, B)
     Equivalente a ldefint com tlimswitch escolhido para true.

Introducedilhaão a QUADPACK
===========================

QUADPACK é uma colecção de funcedilhaões para aálculo numérico de integrais definidos unidimensionais.  O pacote QUADPACK resultou da juncedilhaão de um projeto de R. Piessens (Applied Mathematics and Programming Division, K.U. Leuven), E. de Doncker  (Applied Mathematics and Programming Division, K.U. Leuven), C. Ueberhuber  (Institut fur Mathematik, T.U. Wien), e D. Kahaner  (National Bureau of Standards, Washington, D.C., U.S.A).

A biblioteca QUADPACK inclída no Maxima é uma traducedilhaão automática (feita através do programa f2cl) do código fonte em de QUADPACK como aparece na SLATEC Common Mathematical Library, Versão 4.1 (http://www.netlib.org/slatec).  A biblioteca Fortran SLATEC é datada de Julho de 1993, mas as funcedilhaões QUADPACK foram escritas alguns anos antes.  Existe outra versão de QUADPACK em Netlib  (http://www.netlib.org/quadpack); não está claro no que aquela versão difere da versão existente em SLATEC.

As funcedilhaões QUADPACK incluídas no Maxima são toda automáticas, no sentido de que essas funcedilhaões tentam calcular um resultado para uma precisão específica, requerendo um número não especificado de avaliacedilhaões de funcedilhaão. A traducedilhaão do Lisp do Maxima da iblioteca QUADPACK também inclui algumas funcedilhaẽs não automáticas, mas elas não são expostas a nível de Maxima.

Informacedilhaão adicionalsobre a bilioteca QUADPACK pode ser encontrada no livro do QUADPACK (R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, e D.K. Kahaner. QUADPACK: A Subroutine Package for Automatic Integration. Berlin: Springer-Verlag, 1983, ISBN 0387125531.).

Overview
--------

quad_qag
     Integracedilhaão de uma funcedilhaão genérica sobre um intervalo finito. quad_qag implementa um integrador adaptativo globalmente simples usando a estratégia de Aind (Piessens, 1973). O chamador pode escolher entre 6 pares de formulas da quadratura de Gauss-Kronrod para a componente de avaliacedilhaão da regra. As regras de alto grau são adequadas para integrandos fortemente oscilantes.

quad_qags
     Integracedilhaão de uma funcedilhaão genérica sob um intervalo finito. quad_qags implementa subdivisão de intervalos globalmente adaptativos com extrapolacedilhaão (de Doncker, 1978) por meio do algoritmo de Epsilon (Wynn, 1956).

quad_qagi
     Integracedilhaão de uma funcedilhaão genérica  sobre um intervalo finito ou semi-finito. O intervalo é mapeado sobre um intervalo finito e então a mesma estratégia de quad_qags é aplicada.

quad_qawo
     Integracedilhaão de cos(omega x) f(x) ou sin(omega x) f(x) sobre um intervalo finito, onde omega é uma constante. A componente de avaliacedilhaão da regra é baseada na técnica modificada de Clenshaw-Curtis. quad_qawo aplica subdivisão adaptativa com extrapolacedilhaão, similar a quad_qags.

quad_qawf
     Calcula uma transformacedilhaão de co-seno de Fourier ou de um seno de Fourier sobre um intervalo semi-finito. O mesmo aproxima como quad_qawo aplicado sobre intervalos finitos sucessivos, e aceleracedilhaão de convergência por meio d algorítimo de Epsilon (Wynn, 1956) aplicado a séries de contribuicedilhaões de integrais.

quad_qaws
     Integracedilhaào de w(x) f(x) sobre um intervalo finito [a, b], onde w é uma funcedilhaão da forma (x - a)^alpha (b - x)^beta v(x) e v(x) é 1 ou log(x - a) ou log(b - x) ou log(x - a) log(b - x), e alpha > -1 e beta > -1. Auma estratégia de subdivisão adaptativa é aplicada, com integracedilhaão modificada de Clenshaw-Curtis sobre os subintervalos que possuem a ou b.

quad_qawc
     Calcula o valor principal de Cauchy de f(x)/(x - c) sobre um intervalo finito (a, b) e um c especificado. A estratégia é globalmente adaptativa, e a integracedilhaão modificada de Clenshaw-Curtis é usada sobre subamplitudes que possuírem o ponto x = c.

Definicedilhaões para QUADPACK
==============================

 -- Funcedilhaão: quad_qag (F(X), X, A, B, CHAVE, EPSREL, LIMITE)
 -- Funcedilhaão: quad_qag (F, X, A, B, CHAVE, EPSREL, LIMITE)

     Integracedilhaão de uma funcedilhaão genérica sobre um intervalo finito. quad_qag implementa um integrador adaptativo globalmente simples usando a estratégia de Aind (Piessens, 1973). O chamador pode escolher entre 6 pares de fórmulas da quadratura de Gauss-Kronrod para a componente de avaliacedilhaão da regra. As regras de alto nível são adequadas para integrandos fortemente oscilatórios.

     quad_qag calcula o integral

     integrate (f(x), x, a, b)

     A funcedilhaão a ser integrada é F(X), com variável dependente X, e a funcedilhaão é para ser integrada entre os limites A e B.  CHAVE é o integrador a ser usado e pode ser um inteiro entre 1 e 6, inclusive.  O valor de CHAVE selecciona a ordem da regra de integracedilhaão de Gauss-Kronrod. Regra de alta ordem são adequadas para integrandos fortemente oscilatórios.

     O integrando pode ser especidficado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     A integracedilhaão numérica é concluída adaptativamente pela subdivisão a região de integracedilhaão até que a precisão desejada for completada.

     Os argumentos opcionais EPSREL e LIMITE são o erro relativo desejado e o número máximo de subintervalos respectivamente. EPSREL padrão em 1e-8 e LIMITE é 200.

     quad_qag retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os valores:

     0
          se nenhum problema foi encontrado;

     1
          se foram utilizados muitos subintervalos;

     2
          se for detectato um erro de arredondamento excessivo;

     3
          se o integrando se comportar muito mal;

     6
          se a entrada não for válida.

     Exemplos:

          (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3);
          (%o1)    [.4444444444492108, 3.1700968502883E-9, 961, 0]
          (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
                                          4
          (%o2)                           -
                                          9

 -- Funcedilhaão: quad_qags (F(X), X, A, B, EPSREL, LIMITE)
 -- Funcedilhaão: quad_qags (F, X, A, B, EPSREL, LIMITE)

     Integracedilhaão de uma funcedilhaão geral sobre um intervalo finito. quad_qags implementa subdivisão de intervalo globalmente adaptativa com extrapolacedilhaão (de Doncker, 1978) através do algoritmo de (Wynn, 1956).

     quad_qags calcula o integral

     integrate (f(x), x, a, b)

     A funcedilhaão a ser integrada é F(X), com variável dependente X, e a funcedilhaão é para ser integrada entre os limites A e B.

     O integrando pode ser especidficado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais EPSREL e LIMITE são o erro relativo desejado e o número máximo de subintervalos, respectivamente. EPSREL padrão em 1e-8 e LIMITE é 200.

     quad_qags retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os valores:

     0
          nenhum problema foi encontrado;

     1
          foram utilizados muitos subintervalos;

     2
          foi detectato um erro de arredondamento excessivo;

     3
          o integrando comporta-se muito mal;

     4
          não houve convergência

     5
          o integral provavelmente é divergente, o converge lentamente

     6
          a entrada não foi válida.

     Exemplos:

          (%i1) quad_qags (x^(1/2)*log(1/x), x, 0 ,1);
          (%o1)   [.4444444444444448, 1.11022302462516E-15, 315, 0]

     Note que quad_qags é mais preciso e eficiente que quad_qag para esse integrando.

 -- Funcedilhaão: quad_qagi (F(X), X, A, INFTYPE, EPSREL, LIMITE)
 -- Funcedilhaão: quad_qagi (F, X, A, INFTYPE, EPSREL, LIMITE)

     Integracedilhaão de uma funcedilhaão genérica sobre um intervalo finito ou semi-finito. O intervalo é mapeado sobre um intervalo finito e então a mesma estratégia que em quad_qags é aplicada.

     quad_qagi avalia um dos seguintes integrais

     integrate (f(x), x, minf, inf)

     integrate (f(x), x, minf, a)

     integrate (f(x), x, a, minf, inf)

     usando a rotina Quadpack QAGI.  A funcedilhaão a ser integrada é F(X), com variável dependente X, e a funcedilhaão é para ser integrada sobre um intervalo infinito.

     O integrando pode ser especidficado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     O parâmetro INFTYPE determina o intervalo de integracedilhaão como segue:

     inf
          O intervalo vai de A ao infinito positivo.

     minf
          O intervalo vai do infinito negativo até A.

     both
          O intervalo corresponde a toda reta real.

     Os argumentos opcionais EPSREL e LIMITE são o erro relativo desejado e o número maximo de subintervalos, respectivamente. EPSREL padrão para 1e-8 e LIMITE é 200.

     quad_qagi retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os valores:

     0
          nenhum problema foi encontrado;

     1
          foram utilizados muitos subintervalos;

     2
          foi detectato um erro de arredondamento excessivo;

     3
          o integrando comporta-se muito mal;

     4
          não houve convergência

     5
          o integral provavelmente é divergente, o converge lentamente

     6
          a entrada não foi válida.

     Exemplos:

          (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf);
          (%o1)        [0.03125, 2.95916102995002E-11, 105, 0]
          (%i2) integrate (x^2*exp(-4*x), x, 0, inf);
                                         1
          (%o2)                          --
                                         32

 -- Funcedilhaão: quad_qawc (F(X), X, C, A, B, EPSREL, LIMITE)
 -- Funcedilhaão: quad_qawc (F, X, C, A, B, EPSREL, LIMITE)

     Calcula o valor principal de Cauchy de f(x)/(x - c) over a finite interval. A estratégia é globalmente adaptativa, e a integracedilhaão de Clenshaw-Curtis modificada é usada sobre as subamplitudes que possuírem o ponto x = c.

     quad_qawc calcula o valor principal de Cauchy de

     integrate (f(x)/(x - c), x, a, b)

     usando a rotina Quadpack QAWC.  A funcedilhaão a ser integrada é F(X)/(X - C), com variável dependente X, e a funcedilhaão é para ser integrada sobre o intervalo que vai de A até B.

     O integrando pode ser especidficado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais EPSREL e LIMITE são o erro relativo desejado e o máximo número de subintervalos, respectivamente. EPSREL padrão para 1e-8 e LIMITE é 200.

     quad_qawc retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valoor de retorno) pode ter os valores:

     0
          nenhum problema foi encontrado;

     1
          foram utilizados muitos subintervalos;

     2
          foi detectato um erro de arredondamento excessivo;

     3
          o integrando comporta-se muito mal;

     6
          a entrada não foi válida.

     Exemplos:

          (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5);
          (%o1)    [- 3.130120337415925, 1.306830140249558E-8, 495, 0]
          (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), x, 0, 5);
          Principal Value
                                 alpha
                  alpha       9 4                 9
                 4      log(------------- + -------------)
                                alpha           alpha
                            64 4      + 4   64 4      + 4
          (%o2) (-----------------------------------------
                                  alpha
                               2 4      + 2

                   3 alpha                       3 alpha
                   -------                       -------
                      2            alpha/2          2          alpha/2
                2 4        atan(4 4       )   2 4        atan(4       )   alpha
              - --------------------------- - -------------------------)/2
                          alpha                        alpha
                       2 4      + 2                 2 4      + 2
          (%i3) ev (%, alpha=5, numer);
          (%o3)                    - 3.130120337415917

 -- Funcedilhaão: quad_qawf (F(X), X, A, OMEGA, TRIG, EPSABS, LIMIT, MAXP1, LIMLST)
 -- Funcedilhaão: quad_qawf (F, X, A, OMEGA, TRIG, EPSABS, LIMIT, MAXP1, LIMLST)

     Calcula uma transformacedilhaão de co-seno de Fourier ou de um seno de Fourier sobre um intervalo semi-finito. usando a funcedilhaão QAWF do pacote Quadpack. A mesma aproxima como em quad_qawo quando aplicada sobre intervalos finitos sucessivos, e aceleracedilhaão de convergência por meio d algorítimo de Epsilon (Wynn, 1956) aplicado a séries de contribuicedilhaões de integrais.

     quad_qawf calcula o integral

     integrate (f(x)*w(x), x, a, inf)

     A funcedilhaão peso w é seleccionada por TRIG:

     cos
          w(x) = cos (omega x)

     sin
          w(x) = sin (omega x)

     O integrando pode ser especidficado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais são:

     epsabs
          Erro absoluto de aproximacedilhaão desejado.  Padrão é 1d-10.

     limit
          Tamanho de array interno de trabalho.  (LIMIT - LIMLST)/2 é o maximo número de subintervalos para usar.  O Padrão é 200.

     maxp1
          O número máximo dos momentos de Chebyshev.  Deve ser maior que 0.  O padrão é 100.

     limlst
          Limite superior sobre número de ciclos.  Deve ser maior ou igual a 3.  O padrão é 10.

     EPSABS e LIMIT são o erro relativo desejado e o número maximo de subintervalos, respectivamente. EPSREL padrão para 1e-8 e LIMIT é 200.

     quad_qawf retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os valores:

     0
          nenhum problema foi encontrado;

     1
          foram utilizados muitos subintervalos;

     2
          foi detectato um erro de arredondamento excessivo;

     3
          o integrando comporta-se muito mal;

     6
          a entrada não foi válida.

     Exemplos:

          (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos);
          (%o1)   [.6901942235215714, 2.84846300257552E-11, 215, 0]
          (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
                                    - 1/4
                                  %e      sqrt(%pi)
          (%o2)                   -----------------
                                          2
          (%i3) ev (%, numer);
          (%o3)                   .6901942235215714

 -- Funcedilhaão: quad_qawo (F(X), X, A, B, OMEGA, TRIG, EPSABS, LIMITE, MAXP1, LIMLST)
 -- Funcedilhaão: quad_qawo (F, X, A, B, OMEGA, TRIG, EPSABS, LIMITE, MAXP1, LIMLST)

     Integracedilhaão de cos(omega x) f(x) ou sin(omega x) f(x) sobre um intervalo finito, onde omega é uma constante. A componente de avaliacedilhaão da regra é baseada na técnica modificada de Clenshaw-Curtis. quad_qawo aplica subdivisão adaptativa com extrapolacedilhaão, similar a quad_qags.

     quad_qawo calcula o integral usando a rotina Quadpack QAWO:

     integrate (f(x)*w(x), x, a, b)

     A funcedilhaão peso w é seleccionada por TRIG:

     cos
          w(x) = cos (omega x)

     sin
          w(x) = sin (omega x)

     O integrando pode ser especidficado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais são:

     epsabs
          Erro absoluto desejado de aproximacedilhaão.  O Padrão é 1d-10.

     limite
          Tamanho do array interno de trabalho.  (LIMITE - LIMLST)/2 é o número máximo de subintervalos a serem usados.  Default é 200.

     maxp1
          Número máximo dos momentos de Chebyshev.  Deve ser maior que 0.  O padrão é 100.

     limlst
          Limite superior sobre o número de ciclos.  Deve ser maior que ou igual a 3.  O padrão é 10.

     EPSABS e LIMITE são o erro relativo desejado e o número máximo de subintervalos, respectivamente. EPSREL o padrão é 1e-8 e LIMITE é 200.

     quad_qawo retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os valores:

     0
          nenhum problema foi encontrado;

     1
          foram utilizados muitos subintervalos;

     2
          foi detectato um erro de arredondamento excessivo;

     3
          o integrando comporta-se muito mal;

     6
          a entrada não foi válida.

     Exemplos:

          (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
          (%o1)     [1.376043389877692, 4.72710759424899E-11, 765, 0]
          (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), x, 0, inf));
                             alpha/2 - 1/2            2 alpha
                  sqrt(%pi) 2              sqrt(sqrt(2        + 1) + 1)
          (%o2)   -----------------------------------------------------
                                         2 alpha
                                   sqrt(2        + 1)
          (%i3) ev (%, alpha=2, numer);
          (%o3)                     1.376043390090716

 -- Funcedilhaão: quad_qaws (F(X), X, A, B, ALPHA, BETA, WFUN, EPSABS, LIMITE)
 -- Funcedilhaão: quad_qaws (F, X, A, B, ALPHA, BETA, WFUN, EPSABS, LIMITE)

     Integracedilhaão de w(x) f(x) sobre um intervalo finito, onde w(x) é uma certa funcedilhaão algébrica ou logarítmica. Uma estratégia de subdivisão globalmente adaptativa é aplicada, com integracedilhaão modificada de Clenshaw-Curtis sobre os subintervalos que possuírem os pontos finais dos intervalos de integracedilhaão.

     quad_qaws calcula o integral usando a rotina Quadpack QAWS:

     integrate (f(x)*w(x), x, a, b)

     A funcedilhaão peso w é seleccionada por WFUN:

     1
          w(x) = (x - a)^alpha (b - x)^beta

     2
          w(x) = (x - a)^alpha (b - x)^beta log(x - a)

     3
          w(x) = (x - a)^alpha (b - x)^beta log(b - x)

     4
          w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)

     O integrando pode ser especificado como o nome de uma funcedilhaão Maxima ou uma funcedilhaão Lisp ou um operador, uma expressão lambda do Maxima, ou uma expressão geral do Maxima.

     O argumentos opcionais são:

     epsabs
          Erro absoluto desejado de aproximacedilhaão.  O padrão é 1d-10.

     limite
          Tamanho do array interno de trabalho.  (LIMITE - LIMLST)/2 é o número máximo de subintervalos para usar.  O padrão é 200.

     EPSABS e LIMIT são o erro relativo desejado e o número máximo de subintervalos, respectivamente. EPSREL o padrão é 1e-8 e LIMITE é 200.

     quad_qaws retorna uma lista de quatro elementos:

       * uma aproximacedilhaão para o integral,

       * o erro absoluto estimado da aproximacedilhaão,

       * o número de avaliacedilhaões do integrando,

       * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os valores:

     0
          nenhum problema foi encontrado;

     1
          foram utilizados muitos subintervalos;

     2
          foi detectato um erro de arredondamento excessivo;

     3
          o integrando comporta-se muito mal;

     6
          a entrada não foi válida.

     Exemplos:

          (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1);
          (%o1)     [8.750097361672832, 1.24321522715422E-10, 170, 0]
          (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
                 alpha
          Is  4 2      - 1  positive, negative, or zero?

          pos;
                                    alpha         alpha
                             2 %pi 2      sqrt(2 2      + 1)
          (%o2)              -------------------------------
                                         alpha
                                      4 2      + 2
          (%i3) ev (%, alpha=4, numer);
          (%o3)                     8.750097361672829