[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
21.1 Introdução a Integração | ||
21.2 Definições para Integração |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
Maxima tem muitas rotinas para manusear integração.
A função integrate
faz uso de muitas dessas. Exite também o
pacote antid
, que manuseia uma função não especificada (e suas
derivadas, certamente). Para usos numéricos, existe a função
romberg
; um
integrador adaptativo que usa a regra da quadratura dos currais de Newton,
chamada quanc8
; e uma escolha de integradores adaptativos de Quadpack,
a saber quad_qag
, quad_qags
, etc.
Funções hipergeométricas estão sendo trabalhadas,
veja specint
for details.
Geralmente falando, Maxima somente manuseia integrais que são
integráveis em termos de "funções elementares" (funções racionais,
trigonometricas, logarítmicas, exponenciais, radicais, etc.) e umas poucas
extensões (função de erro, dilogarithm). Isso não manuseia
integrais em termos de funções desconhecidas tais como g(x)
e h(x)
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
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 |
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.
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.
Representa a função de erro, cuja derivada é:
2*exp(-x^2)/sqrt(%pi)
.
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.
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 |
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:
(%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 |
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 |
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))) |
'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$ |
f_1
nesse exemplo contém a forma substantiva de integrate
.
O operador aspas simples ''
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 |
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.
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(x - x + 1) (%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.
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.
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.
O pacote qq
(que pode ser carregado com load ("qq")
)
contém uma função quanc8
que pode pegar ou 3 ou 4 arguments. A
versão de 3 argumentos calcula a integral da função especificada como
primeiro argumento sobre o intervalo de lo a hi como em
quanc8 ('função, lo, hi)
.
o nome da função pode receber apóstrofo. A versão de 4 argumentos calculará
a integral da função ou expressão (primeiro argumento) em relação
à variável (segundo argumento) no intervalo de lo
a hi
como em
quanc8(<f(x) or expressão in x>, x, lo, hi)
.
O método usado é o da quadratura dos currais de Newton,
e a rotina é adaptativa. Isso irá dessa forma gastar tempo dividindo o
intervalo somente quando necessário para completar as condições de erro especificadas
pelas variáveis quanc8_relerr
(valor padrão=1.0e-4) e
quanc8_abserr
(valor padrão=1.0e-8) que dão o teste de erro
relativo:
|integral(função) - valor calculado| < quanc8_relerr*|integral(função)| |
e o teste de erro absoluto:
|integral(função) - valor calculado| < quanc8_abserr |
printfile ("qq.usg")
yields additional informação.
Um integrador adaptativo.
Demonstração e arquivos de utilização são fornecidos. O método é para
usar a regra da quadratura dos currais de Newton, daí o nome da função
quanc8
, disponível em versões de 3 ou 4 argumentos. Verificação de erro absoluto e
erro relativo são usadas. Para usar isso faça load ("qq")
. Veja também qq
.
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 |
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) |
Integração de Romberg.
Existem dois caminhos para usar essa função. O primeiro é um caminho
ineficiente como a versão de integral definida de integrate
:
romberg (<integrando>, <variável of integração>, <lower limit>, <upper limit>)
.
Exemplos:
(%i1) showtime: true$ (%i2) romberg (sin(y), y, 0, %pi); Evaluação took 0.00 seconds (0.01 elapsed) using 25.293 KB. (%o2) 2.000000016288042 (%i3) 1/((x-1)^2+1/100) + 1/((x-2)^2+1/1000) + 1/((x-3)^2+1/200)$ (%i4) f(x) := ''%$ (%i5) rombergtol: 1e-6$ (%i6) rombergit: 15$ (%i7) romberg (f(x), x, -5, 5); Evaluação took 11.97 seconds (12.21 elapsed) using 12.423 MB. (%o7) 173.6730736617464 |
O segundo é um caminho eficiente que é usado como segue:
romberg (<função name>, <lower limit>, <upper limit>); |
Continuando o exemplo acima, temos:
(%i8) f(x) := (mode_declare ([função(f), x], float), ''(%th(5)))$ (%i9) translate(f); (%o9) [f] (%i10) romberg (f, -5, 5); Evaluação took 3.51 seconds (3.86 elapsed) using 6.641 MB. (%o10) 173.6730736617464 |
O primeiro argumento deve ser uma função trauzida ou compilada. (Se for
compilada isso deve ser declarado para retorno a flonum
.) Se o primeiro
argumento não for já traduzido, romberg
não tentará
traduzí-lo mas resultará um erro.
A precisão da integração é governada pelas variáveis globais
rombergtol
(valor padrão 1.E-4) e rombergit
(valor padrão 11).
romberg
retornará um resultado se a diferença relativa em sucessivas
aproximações for menor que rombergtol
. Isso tentará dividir ao meio o
tamanho do passo rombergit
vezes antes que isso seja abandonado. O número de iterações
e avaliações da função que romberg
fará é governado por
rombergabs
e rombergmin
.
romberg
pode ser chamada recursivamente e dessa forma pode fazer integrais duplas e
triplas.
Exemplo:
(%i1) assume (x > 0)$ (%i2) integrate (integrate (x*y/(x+y), y, 0, x/2), x, 1, 3)$ (%i3) radcan (%); 26 log(3) - 26 log(2) - 13 (%o3) - -------------------------- 3 (%i4) %,numer; (%o4) .8193023963959073 (%i5) define_variable (x, 0.0, float, "Global variável in função F")$ (%i6) f(y) := (mode_declare (y, float), x*y/(x+y))$ (%i7) g(x) := romberg ('f, 0, x/2)$ (%i8) romberg (g, 1, 3); (%o8) .8193022864324522 |
A vantagem com esse caminho é que a função f
pode ser usada para outros
propósitos, como imprimir gráficos. A desvantagem é que você tem que inventar
um nome para ambas a função f
e sua variável independente x
.
Ou, sem a variável global:
(%i1) g_1(x) := (mode_declare (x, float), romberg (x*y/(x+y), y, 0, x/2))$ (%i2) romberg (g_1, 1, 3); (%o2) .8193022864324522 |
A vantagem aqui é que o código é menor.
(%i3) q (a, b) := romberg (romberg (x*y/(x+y), y, 0, x/2), x, a, b)$ (%i4) q (1, 3); (%o4) .8193022864324522 |
Isso é sempre o caminho mais curto, e as variáveis não precisam ser declaradas
porque elas estão no contexto de romberg
.
O uso de romberg
para integrais multiplas pode ter grandes desvantagens,
apesar disso. O amontoado de cálculos extras necessários por causa da
informação geométrica descartada durante o processo pela expressão de integrais multiplas por
esse caminho pode ser incrível. O usuário deverá ter certeza de entender e
usar os comutadores rombergtol
e rombergit
.
Valor padrão: 0.0
Assumindo que estimativas sucessivas
produzidas por romberg
são y[0]
, y[1]
, y[2]
, etc., então romberg
retornará após n
iterações se (grasseiramente falando)
(abs(y[n]-y[n-1]) <= rombergabs ou abs(y[n]-y[n-1])/(if y[n]=0.0 then 1.0 else y[n]) <= rombergtol) |
for true
. (A condição sobre o número de iterações dadas por
rombergmin
deve também ser satisfeita.)
Dessa forma se rombergabs
é 0.0 (o padrão) você apenas pega o teste
de erro relativo. A utilidade de uma variável adicional vem quando você
executar uma integral, quando a contribuição dominante vem
de uma pequena região. Então você pode fazer a integral sobre uma pequena
região dominante primeiro, usando a verificação relativa de precisão, seguida pela
integral sobre o restante da região usando a verificação absoluta
de erro.
Exemplo: Suponha que você quer calcular
'integrate (exp(-x), x, 0, 50) |
(numericamente) com uma precisão relativa de 1 parte em 10000000.
Defina a função. n
é o contador, então nós podemos ver quantas
avaliações de função foram necessárias.
Primeiro de tudo tente fazer a integral completa de uma só vez.
(%i1) f(x) := (mode_declare (n, integer, x, float), n:n+1, exp(-x))$ (%i2) translate(f)$ Warning-> n é an undefined global variable. (%i3) block ([rombergtol: 1.e-6, romberabs: 0.0], n:0, romberg (f, 0, 50)); (%o3) 1.000000000488271 (%i4) n; (%o4) 257 |
Que aproximadamente precisou de 257 avaliações de função .
Agora faça a integral inteligentemente, primeiro fazendo
'integrate (exp(-x), x, 0, 10)
e então escolhendo rombergabs
para 1.E-6 vezes (nessa
integral parcial).
Isso aproximdamente pega somente 130 avaliações de função.
(%i5) block ([rombergtol: 1.e-6, rombergabs:0.0, sum:0.0], n: 0, sum: romberg (f, 0, 10), rombergabs: sum*rombergtol, rombergtol:0.0, sum + romberg (f, 10, 50)); (%o5) 1.000000001234793 (%i6) n; (%o6) 130 |
Então se f(x)
onde a função pegou um longo tempo de computação, o
segundo método fez a mesma tarefa 2 vezes mais rápido.
Valor padrão: 11
A precisão do comando romberg
de
integração é governada pelas variáveis globais rombergtol
e
rombergit
. romberg
retornará um resultado se a diferença
relativa em sucessivas approximações é menor que rombergtol
. Isso
tentará dividir ao meio o tamanho do passoe rombergit
vezes antes disso ser abandonado.
Valor padrão: 0
rombergmin
governa o número mínimo de avaliações de
função que romberg
fará. romberg
avaliará seu primeiro
argumento pelo menos 2^(rombergmin+2)+1
vezes. Isso é útil para
integrar funções oscilatórias, onde o teste normal de convergência pode
lgumas vezes inadequadamente passar.
Valor padrão: 1e-4
A precisão do comando de integração de romberg
é governada pelas variáveis globais rombergtol
e
rombergit
. romberg
retornará um resultado se a difereça
relativa em sucessivas aproximações é menor que rombergtol
. Isso
tentará dividir ao meio o tamanho do passo rombergit
vezes antes disso ser abandonado.
Equivalente a ldefint
com tlimswitch
escolhido para true
.
Numericamente avalia a integral
integrate (f(x), x, a, b)
usando um integrador adaptativo simples.
A função a ser integrada é f(x), com variável dependente x, e a função é para ser integrada entre os limites a e b. key é o integrador a ser usado e pode ser um inteiro entre 1 e 6, inclusive. O valor de key seleciona a ordem da regra de integração de Gauss-Kronrod.
A integração numérica é concluída adaptativamente pela subdivisão a região de integração até que a precisão desejada for completada.
Os argumentos opcionais epsrel e limit são o erro relativo desejado e o número máximo de subintervalos respectivamente. epsrel padrão em 1e-8 e limit é 200.
quad_qag
retorna uma lista de quatro elementos:
O código de erro (quarto elemento do valor de retorno) pode ter os valores:
0
se nenhum problema for encontrado;
1
se muitos subintervalos foram concluídos;
2
se erro excessivo é detectado;
3
se ocorre comportamento extremamente ruim do integrando;
6
se a entrada é invá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 |
Integra numericamente a função dada usando quadratura adaptativa com extrapolação. A função a ser integrated é f(x), com variável dependente x, e a função é para ser integrada entre os limites a e b.
Os argumentos opcionais epsrel e limit são o erro relativo desejado e o número máximo de subintervalos, respectivamente. epsrel padrão em 1e-8 e limit é 200.
quad_qags
retorna uma lista de quatro elementos:
O código de erro (quarto elemento do valor de retorno) pode ter os valores:
0
nenhum problema foi encontrado;
1
muitos subintervalos foram concluídos;
2
erro excessivo é detectado;
3
ocorreu comportamento excessivamente ruim do integrando;
4
falhou para convergência
5
integral é provavelmente divergente ou lentamente convergente
6
se a entrada é invá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.
Avalia numericamente uma das seguintes integrais
integrate (f(x), x, a, inf)
integrate (f(x), x, minf, a)
integrate (f(x), x, a, minf, inf)
usando a rotina Quadpack QAGI. A função a ser integrada é f(x), com variável dependente x, e a função é para ser integrada sobre um intervalo infinito.
O parâmetro inftype determina o intervalo de integraçã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 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_qagi
retorna uma lista de quatro elementos:
O código de erro (quarto elemento do valor de retorno) pode ter os valores:
0
nenhum problema foi encontrado;
1
muitos subintervalos foram concluídos;
2
erro excessivo é detectado;
3
ocorreu comportamento excessivamente ruim do integrando;
4
falhou para convergência;
5
integral é provavelmente divergente ou lentamente convergente;
6
se a entrada for invá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 |
Calcula numericamente o valor principal de Cauchy de
integrate (f(x)/(x - c), x, a, b)
usando a rotina Quadpack QAWC. A função a ser integrada é
f(x)/(x - c)
, com variável dependente x, e a função
é para ser integrada sobre o intervalo que vai de a até b.
Os argumentos opcionais epsrel e limit são o erro relativo desejado e o máximo número de subintervalos, respectivamente. epsrel padrão para 1e-8 e limit é 200.
quad_qawc
retorna uma lista de quatro elementos:
O código de erro (quarto elemento do valoor de retorno) pode ter os valores:
0
nenhum problema foi encontrado;
1
muitos subintervalos foram concluídos;
2
erro excessivo é detectado;
3
ocorreu comportamento excessivamente ruim do integrando;
6
se a entrada é invá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 |
Calcula numericamente a integral tipo Fourier usando a rotina Quadpack QAWF. A integral é
integrate (f(x)*w(x), x, a, inf)
A função peso w é selecionada por trig:
cos
w(x) = cos (omega x)
sin
w(x) = sin (omega x)
Os argumentos opcionais são:
Erro absoluto de aproximação desejado. Padrão é 1d-10.
Tamanho de array interno de trabalho. (limit - limlst)/2 é o maximo número de subintervalos para usar. O Padrão é 200.
O número máximo dos momentos de Chebyshev. Deve ser maior que 0. O padrão é 100.
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:
O código de erro (quarto elemento do valor de retorno) pode ter os valores:
0
nenhum problema foi encontrado;
1
muitos subintervalos foram concluídos;
2
erro excessivo é detectado;
3
ocorreu um comportamento excessivamente ruim do integrando;
6
se a entrada é invalida.
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 |
Calcula numericamente a integral usando a rotina Quadpack QAWO:
integrate (f(x)*w(x), x, a, b)
A função peso w é selecionada por trig:
cos
w(x) = cos (omega x)
sin
w(x) = sin (omega x)
Os argumentos opcionais são:
Erro absoluto desejado de aproximação. O Padrão é 1d-10.
Tamanho do array interno de trabalho. (limit - limlst)/2 é o número máximo de subintervalos a serem usados. Default é 200.
Número máximo dos momentos de Chebyshev. Deve ser maior que 0. O padrão é 100.
Limite superior sobre o número de ciclos. Deve ser maior que ou igual a 3. O padrão é 10.
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 limit é 200.
quad_qawo
retorna uma lista de quatro elementos:
O código de erro (quarto elemento do valor de retorno) pode ter os valores:
0
nenhum problema foi encontrado;
1
muitos subintervalos foram concluídos;
2
erro excessivo é detectado;
3
comportamento extremamente ruim do integrando;
6
se a entrada é invá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 |
Numéricamente calcula a integral usando a rotina Quadpack QAWS:
integrate (f(x)*w(x), x, a, b)
A função peso w é selecionada por wfun:
1
w(x) = (x - a)^alfa (b - x)^beta
2
w(x) = (x - a)^alfa (b - x)^beta log(x - a)
3
w(x) = (x - a)^alfa (b - x)^beta log(b - x)
2
w(x) = (x - a)^alfa (b - x)^beta log(x - a) log(b - x)
O argumentos opcionais são:
Erro absoluto desejado de aproximação. O padrão é 1d-10.
Tamanho do array interno de trabalho. (limit - 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 limit é 200.
quad_qaws
retorna uma lista de quatro elementos:
O código de erro (quarto elemento do valor de retorno) pode ter os valores:
0
nenhum problema foi encontrado;
1
muitos subintervalos foram concluídos;
2
erro excessivo é detectado;
3
ocorreu um comportamento excessivamente ruim do integrando;
6
se a entrada é invalida.
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 |
[ << ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
This document was generated by root on Outubro, 3 2006 using texi2html 1.76.