| blob | d8d20bd8d5ab5940d2a3e77b3596cd8950eb40af |
1 @c /Integration.texi/1.30/Mon Jan 8 04:17:39 2007/-ko/
2 @menu
3 * Introdução a Integração::
4 * Definições para Integração::
5 * Introdução a QUADPACK::
6 * Definições para QUADPACK::
7 @end menu
9 @node Introdução a Integração, Definições para Integração, Integração, Integração
10 @section Introdução a Integração
12 Maxima tem muitas rotinas para realizar integração. A
13 função @code{integrate} faz uso de muitas dessas. Exite
14 também o pacote @code{antid}, que manuseia uma função
15 não especificada (e suas derivadas, certamente). Para usos numericos,
16 existe um conjunto de integradores adaptativos de QUADPACK, a saber
17 @code{quad_qag}, @code{quad_qags}, etc., os quais são descritos sob o
18 tópico @code{QUADPACK}. Funções hipergeométricas
19 estão sendo trabalhadas, veja @code{specint} para detalhes.
20 Geralmente falando, Maxima somente calcula integrais que sejam
21 integráveis em termos de "funções elementares"
22 (funções racionais, trigonometricas, logarítmicas,
23 exponenciais, radicais, etc.) e umas poucas extensões
24 (função de erro, dilogaritmo). Nã consegue calcular
25 integrais em termos de funções desconhecidas tais como
26 @code{g(x)} e @code{h(x)}.
28 @c end concepts Integration
29 @node Definições para Integração, Introdução a QUADPACK, Introdução a Integração, Integração
30 @section Definições para Integração
31 @c NEEDS WORK
32 @deffn {Função} changevar (@var{expr}, @var{f(x,y)}, @var{y}, @var{x})
33 Faz a mudança de variável dada por @code{@var{f(x,y)} =
34 0} em todos os integrais que existam em @var{expr} com
35 integração em relação a @var{x}. A nova
36 variável é @var{y}.
38 @c HMM, THIS EXAMPLE YIELDS A CORRECT BUT SLIGHTLY STRANGE RESULT...
39 @example
40 (%i1) assume(a > 0)$
41 (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
42 4
43 /
44 [ sqrt(a) sqrt(y)
45 (%o2) I %e dy
46 ]
47 /
48 0
49 (%i3) changevar (%, y-z^2/a, z, y);
50 0
51 /
52 [ abs(z)
53 2 I z %e dz
54 ]
55 /
56 - 2 sqrt(a)
57 (%o3) - ----------------------------
58 a
59 @end example
61 Uma expressão contendo uma forma substantiva, tais como as
62 instâncias de @code{'integrate} acima, pode ser avaliada por @code{ev}
63 com o sinalizador @code{nouns}. Por exemplo, a expressão retornada
64 por @code{changevar} acima pode ser avaliada por @code{ev (%o3, nouns)}.
66 @code{changevar} pode também ser usada para alterações
67 nos índices de uma soma ou de um produto. No entanto, é
68 de salientar que quando seja feita uma alteração a uma
69 soma ou produto, essa mudança deverá ser apenas uma
70 deslocação do índice, nomeadamente,
71 @code{i = j+ ...}, e não uma função de grau superior.
72 Por exemplo,
74 @example
75 (%i4) sum (a[i]*x^(i-2), i, 0, inf);
76 inf
77 ====
78 \ i - 2
79 (%o4) > a x
80 / i
81 ====
82 i = 0
83 (%i5) changevar (%, i-2-n, n, i);
84 inf
85 ====
86 \ n
87 (%o5) > a x
88 / n + 2
89 ====
90 n = - 2
91 @end example
93 @end deffn
95 @c THIS ITEM IS A MESS, BUT DON'T BOTHER TO CLEAN IT UP:
96 @c THE GAUSS-KRONROD FUNCTIONS (QUADPACK) MAKE THIS OBSOLETE
97 @deffn {Função} dblint (@var{f}, @var{r}, @var{s}, @var{a}, @var{b})
98 Esta é uma rotina de integral duplo que foi escrita na linguagem de
99 alto nível do Maxima sendo logo traduzida e compilada para
100 linguagem de máquina. Use @code{load ("dblint")} para poder usar este
101 pacote. Esta função usa o método da regra de Simpson
102 em ambas as direções x e y para calcular
104 @example
105 /b /s(x)
106 | |
107 | | f(x,y) dy dx
108 | |
109 /a /r(x)
110 @end example
112 A função @var{f} deve ser uma função
113 traduzida ou compilada de duas variáveis, e @var{r} e @var{s} devem
114 cada uma ser uma função traduzida ou compilada de uma
115 variável, enquanto @var{a} e @var{b} devem ser números em ponto
116 flutuante. A rotina tem duas variáveis globais que determinam o
117 número de divisões dos intervalos x e y: @code{dblint_x} e
118 @code{dblint_y}, ambas as quais são inicialmente 10, e podem ser
119 alteradas independentemente para outros valores inteiros (existem
120 @code{2*dblint_x+1} pontos calculados na direção x , e
121 @code{2*dblint_y+1} na direção y). A rotina subdivide o
122 eixo X e então para cada valor de X primeiro calcula @code{@var{r}(x)}
123 e @code{@var{s}(x)}; então o eixo Y entre @code{@var{r}(x)} e
124 @code{@var{s}(x)} é subdividido e o integral ao longo do eixo Y é
125 executado usando a regra de Simpson; então o integral ao longo do eixo
126 X é concluído usando a regra de Simpson com os valores
127 da função sendo os integrais em Y. Esse procedimento
128 pode ser numericamente instável por várias razões, mas
129 razoávelmente rápido: evite usar este progrma sobre
130 funções altamente oscilatórias e
131 funções com singularidades (pólos ou pontos de
132 ramificação na região). Os integrais em Y dependem de
133 quanto fragmentados @code{@var{r}(x)} e @code{@var{s}(x)} sejam; assim,
134 se a distância @code{@var{s}(x) - @var{r}(x)} variar rapidamente com
135 X, nesse ponto podrão surgir erros substanciais provenientes de
136 truncação com saltos de diferentes tamanhos nos vários
137 integrais Y. Pode incrementar-se @code{dblint_x} e @code{dblint_y} numa
138 tentativa para melhorar a convergência da região, com um aumento no
139 tempo de computação. Os valores da
140 função não são guardados, portanto se a
141 função desperdiçr muito tempo, terá de
142 esperar pela re-computação cada vez que mudar qualquer
143 coisa (pedimos desculpa por esse facto). É necessário que as
144 funções @var{f}, @var{r}, e @var{s} sejam ainda
145 traduzidas ou compiladas previamente chamando @code{dblint}. Isso
146 resultará em ordens de magnitude de melhoramentos de velocidade sobre
147 o código interpretado em muitos casos!
149 @code{demo (dblint)} executa uma demonstração de @code{dblint} aplicado a um problema exemplo.
150 @c demo (dblint_1) FAILS WITH Could not find `fltdfnk.mc' -- DON'T BOTHER TO MENTION IT. !!!
151 @c @code{demo (dblint_1)} executa outra demonstração.
153 @end deffn
155 @deffn {Função} defint (@var{expr}, @var{x}, @var{a}, @var{b})
156 Tenta calcular um integral definido.
157 @code{defint} é chamada por @code{integrate} quando limites de integração são especificados,
158 i.e., quando @code{integrate} é chamado como @code{integrate (@var{expr}, @var{x}, @var{a}, @var{b})}.
159 Dessa forma do ponto de vista do utilizador, isso é suficiente para chamar @code{integrate}.
160 @c SHOULD WE BOTHER TO DOCUMENT defint ??? NO FUNCTIONALITY HERE THAT IS NOT ALREADY PRESENT IN integrate !!!
162 @code{defint} retorna uma expressão simbólica,
163 e executa um dos dois: ou calcula o integral ou a forma substantiva do integral.
164 Veja @code{quad_qag} e funções rellacionadas para aproximação numérica de integrais definidos.
166 @end deffn
168 @c NEEDS EXPANSION AND EXAMPLES
169 @deffn {Função} erf (@var{x})
170 Representa a função de erro, cuja derivada é:
171 @code{2*exp(-x^2)/sqrt(%pi)}.
173 @end deffn
175 @defvr {Variável de opção} erfflag
176 Valor por omissão: @code{true}
178 Quando @code{erfflag} é @code{false}, previne @code{risch} da introdução da
179 função @code{erf} na resposta se não houver nenhum no integrando para
180 começar.
182 @end defvr
184 @c NEEDS WORK
185 @deffn {Função} ilt (@var{expr}, @var{t}, @var{s})
186 Calcula a transformação inversa de Laplace de @var{expr} em
187 relação a @var{t} e parâmetro @var{s}. @var{expr} deve ser uma razão de
188 polinómios cujo denominador tem somente factores lineares e quadráticos.
189 Usando a funções @code{laplace} e @code{ilt} juntas com as funções @code{solve} ou
190 @code{linsolve} o utilizador pode resolver uma diferencial simples ou
191 uma equação integral de convolução ou um conjunto delas.
193 @example
194 (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
195 t
196 /
197 [ 2
198 (%o1) I f(t - x) sinh(a x) dx + b f(t) = t
199 ]
200 /
201 0
202 (%i2) laplace (%, t, s);
203 a laplace(f(t), t, s) 2
204 (%o2) b laplace(f(t), t, s) + --------------------- = --
205 2 2 3
206 s - a s
207 (%i3) linsolve ([%], ['laplace(f(t), t, s)]);
208 2 2
209 2 s - 2 a
210 (%o3) [laplace(f(t), t, s) = --------------------]
211 5 2 3
212 b s + (a - a b) s
213 (%i4) ilt (rhs (first (%)), s, t);
214 Is a b (a b - 1) positive, negative, or zero?
216 pos;
217 sqrt(a b (a b - 1)) t
218 2 cosh(---------------------) 2
219 b a t
220 (%o4) - ----------------------------- + -------
221 3 2 2 a b - 1
222 a b - 2 a b + a
224 2
225 + ------------------
226 3 2 2
227 a b - 2 a b + a
228 @end example
230 @end deffn
232 @deffn {Função} integrate (@var{expr}, @var{x})
233 @deffnx {Função} integrate (@var{expr}, @var{x}, @var{a}, @var{b})
234 Tenta símbolicamente calcular o integral de @var{expr} em relação a @var{x}.
235 @code{integrate (@var{expr}, @var{x})} é um integral indefinido,
236 enquanto @code{integrate (@var{expr}, @var{x}, @var{a}, @var{b})} é um integral definido,
237 com limites de integração @var{a} e @var{b}.
238 Os limites não poderam conter @var{x}, embora @code{integrate} não imponha essa restrição.
239 @var{a} não precisa ser menor que @var{b}.
240 Se @var{b} é igual a @var{a}, @code{integrate} retorna zero.
242 Veja @code{quad_qag} e funções relacionadas para aproximação numérica de integrais definidos.
243 Veja @code{residue} para computação de resíduos (integração complexa).
244 Veja @code{antid} para uma forma alternativa de calcular integrais indefinidos.
246 O integral (uma expressão livre de @code{integrate}) é calculado se
247 @code{integrate} for bem sucedido.
248 De outra forma o valor de retorno é
249 a forma substantiva do integral (o operador com apóstrofo @code{'integrate})
250 ou uma expressão contendo uma ou mais formas substantivas.
251 A forma substantiva de @code{integrate} é apresentada com um símbolo de integração.
253 Em algumas circunstâncias isso é útil para construir uma forma substantiva manualmente,
254 colocando em @code{integrate} um apóstrofo, e.g., @code{'integrate (@var{expr}, @var{x})}.
255 Por exemplo, o integral pode depender de alguns parâmetos que não estão ainda calculados.
256 A forma substantiva pode ser aplicada a seus argumentos por @code{ev (@var{i}, nouns)}
257 onde @var{i} é a forma substantiva de interesse.
259 @c BEGIN EXPOSITION ON HEURISTICS
260 @code{integrate} calcula integrais definidos separadamente dos
261 indefinidos, e utiliza uma gama de heurísticas para
262 simplificar cada caso. Casos especiais de integrais definidos incluem
263 limites de integração iguais a zero ou infinito
264 (@code{inf} ou @code{minf}), funções trigonométricas
265 com limites de integração iguais a zero e @code{%pi} ou
266 @code{2 %pi}, funções racionais, integrais relacionados
267 com as definições das funções
268 @code{beta} e @code{psi}, e alguns integrais logarítmicos e
269 trigonométricos. O processamento de funções racionais
270 pode incluir cálculo de resíduos. Se um caso especial
271 aplicável não for encontrado, será feita uma tentativa para calcular o
272 integral indefinido e avaliá-lo nos limites de
273 integração. Isso pode incluir o cálculo de um limite
274 nos casos em que um dos limites do integral for para infinito ou menos
275 infinito; veja também @code{ldefint}.
277 Casos especiais de integrais indefinidos incluem funções
278 trigonométricas, exponenciais e funções logarítmicas,
279 e funções racionais. @code{integrate} pode também
280 fazer uso de uma pequena tabela de integais elementares.
282 @code{integrate} pode realizar uma mudança de variável
283 se o integrando tiver a forma @code{f(g(x)) * diff(g(x), x)}.
284 @code{integrate} tenta achar uma subexpressão @code{g(x)} de forma que
285 a derivada de @code{g(x)} divida o integrando. Essa busca pode fazer
286 uso de derivadas definidas pela função @code{gradef}.
287 Veja também @code{changevar} e @code{antid}.
289 Se nenhum dos procedimentos heurísticos conseguir calcular
290 o integral indefinido, o algoritmo de Risch é executado. O sinalizador
291 @code{risch} pode ser utilizado como um parâmetro para @code{ev}, ou
292 na linha de comando, nomeadamente, @code{ev (integrate (@var{expr},
293 @var{x}), risch)} ou @code{integrate (@var{expr}, @var{x}), risch}. Se
294 @code{risch} estiver presente, @code{integrate} chamará a
295 função @code{risch} sem tentar heurísticas
296 primeiro. Veja também @code{risch}.
297 @c END EXPOSITION ON HEURISTICS
299 @code{integrate} trabalha somente com relações funcionais representadas explicitamente com a notação @code{f(x)}.
300 @code{integrate} não respeita dependências implicitas estabelecidas pela função @code{depends}.
301 @code{integrate} pode necessitar conhecer alguma propriedade de um parâmetro no integrando.
302 @code{integrate} irá primeiro consultar a base de dados do @code{assume},
303 e , se a variável de interesse não está lá,
304 @code{integrate} perguntará ao utilizador.
305 Dependendo da pergunta,
306 respostas adequadas são @code{yes;} ou @code{no;},
307 ou @code{pos;}, @code{zero;}, ou @code{neg;}.
309 @code{integrate} não é, por padrão, declarada ser linear. Veja @code{declare} e @code{linear}.
311 @code{integrate} tenta integração por partes somente em uns poucos casos especiais.
313 Exemplos:
315 @itemize @bullet
316 @item
317 Integrais definidos e indefinidos elementares.
319 @example
320 (%i1) integrate (sin(x)^3, x);
321 3
322 cos (x)
323 (%o1) ------- - cos(x)
324 3
325 (%i2) integrate (x/ sqrt (b^2 - x^2), x);
326 2 2
327 (%o2) - sqrt(b - x )
328 (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
329 %pi
330 3 %e 3
331 (%o3) ------- - -
332 5 5
333 (%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
334 sqrt(%pi)
335 (%o4) ---------
336 2
337 @end example
339 @item
340 Uso de @code{assume} e dúvida interativa.
342 @example
343 (%i1) assume (a > 1)$
344 (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
345 2 a + 2
346 Is ------- an integer?
347 5
349 no;
350 Is 2 a - 3 positive, negative, or zero?
352 neg;
353 3
354 (%o2) beta(a + 1, - - a)
355 2
356 @end example
358 @item
359 Mudança de variável. Existem duas mudanças de variável nesse exemplo:
360 uma usando a derivada estabelecida por @code{gradef},
361 e uma usando a derivação @code{diff(r(x))} de uma função não especificada @code{r(x)}.
363 @example
364 (%i3) gradef (q(x), sin(x**2));
365 (%o3) q(x)
366 (%i4) diff (log (q (r (x))), x);
367 d 2
368 (-- (r(x))) sin(r (x))
369 dx
370 (%o4) ----------------------
371 q(r(x))
372 (%i5) integrate (%, x);
373 (%o5) log(q(r(x)))
374 @end example
376 @item
377 O resultado contém a forma substantiva @code{'integrate}. Neste
378 exemplo, Maxima pode extrair um factor do denominador de uma
379 função racional, mas não pode factorizar o restante ou
380 de outra forma achar o seu integral. @code{grind} mostra a forma
381 substantiva @code{'integrate} no resultado. Veja também
382 @code{integrate_use_rootsof} para mais informaçes sobre
383 integrais de funções racionais.
385 @example
386 (%i1) expand ((x-4) * (x^3+2*x+1));
387 4 3 2
388 (%o1) x - 4 x + 2 x - 7 x - 4
389 (%i2) integrate (1/%, x);
390 / 2
391 [ x + 4 x + 18
392 I ------------- dx
393 ] 3
394 log(x - 4) / x + 2 x + 1
395 (%o2) ---------- - ------------------
396 73 73
397 (%i3) grind (%);
398 log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$
399 @end example
401 @item
402 Definindo uma função em termos de um integral. O corpo
403 de uma função não é avaliado quando a
404 função é definida. Dessa forma o corpo de @code{f_1}
405 nesse exemplo contém a forma substantiva de @code{integrate}. O
406 operador de doi apóstrofos seguidos @code{'@w{}'} faz com que o
407 integral seja avaliado, e o resultado se transforme-se no corpo de
408 @code{f_2}.
410 @example
411 (%i1) f_1 (a) := integrate (x^3, x, 1, a);
412 3
413 (%o1) f_1(a) := integrate(x , x, 1, a)
414 (%i2) ev (f_1 (7), nouns);
415 (%o2) 600
416 (%i3) /* Note parentheses around integrate(...) here */
417 f_2 (a) := ''(integrate (x^3, x, 1, a));
418 4
419 a 1
420 (%o3) f_2(a) := -- - -
421 4 4
422 (%i4) f_2 (7);
423 (%o4) 600
424 @end example
425 @end itemize
427 @end deffn
429 @defvr {Variável de sistema} integration_constant_counter
430 Valor por omissão: 0
432 @c WHEN DOES integrationconstant1 SHOW UP IN THE OUTPUT OF integrate ???
433 @c integrate (a, x) YIELDS "a x", NOT "a x + integrationconstant1" !!!
434 @code{integration_constant_counter} é um contador que é actualizado
435 a cada vez que uma constante de integração (nomeada pelo
436 Maxima, por exemplo, @code{integrationconstant1}) é introduzida numa
437 expressão obtida após a integração indefinida de uma
438 equação.
440 @end defvr
442 @defvr {Variável de opção} integrate_use_rootsof
443 Valor por omissão: @code{false}
445 Quando @code{integrate_use_rootsof} é @code{true} e o denominador de
446 uma função racional não pode ser factorizado, @code{integrate} retorna o integral
447 em uma forma que é uma soma sobre as raízes (não conhecidas ainda) do denominador.
449 Por exemplo, com @code{integrate_use_rootsof} escolhido para
450 @code{false}, @code{integrate} retorna um integral não resolvido de
451 uma função racional na forma substantiva:
453 @example
454 (%i1) integrate_use_rootsof: false$
455 (%i2) integrate (1/(1+x+x^5), x);
456 / 2
457 [ x - 4 x + 5
458 I ------------ dx 2 x + 1
459 ] 3 2 2 5 atan(-------)
460 / x - x + 1 log(x + x + 1) sqrt(3)
461 (%o2) ----------------- - --------------- + ---------------
462 7 14 7 sqrt(3)
463 @end example
465 Agora vamos escolher o sinalizador para ser true e a parte não
466 resolvida do integral será escrito como uma soma sobre as
467 raízes do denominador da função racional:
469 @example
470 (%i3) integrate_use_rootsof: true$
471 (%i4) integrate (1/(1+x+x^5), x);
472 ==== 2
473 \ (%r4 - 4 %r4 + 5) log(x - %r4)
474 > -------------------------------
475 / 2
476 ==== 3 %r4 - 2 %r4
477 3 2
478 %r4 in rootsof(%r4 - %r4 + 1, %r4)
479 (%o4) ----------------------------------------------------------
480 7
482 2 x + 1
483 2 5 atan(-------)
484 log(x + x + 1) sqrt(3)
485 - --------------- + ---------------
486 14 7 sqrt(3)
487 @end example
489 Alternativamente o utilizador pode calcular as raízes do denominador separadamente,
490 e então expressar o integrando em termos dessas raízes,
491 e.g., @code{1/((x - a)*(x - b)*(x - c))} ou @code{1/((x^2 - (a+b)*x + a*b)*(x - c))}
492 se o denominador for um polinómio cúbico.
493 Algumas vezes isso ajudará Maxima a obter resultados mais úteis.
495 @end defvr
497 @c NEEDS EXAMPLES
498 @deffn {Função} ldefint (@var{expr}, @var{x}, @var{a}, @var{b})
499 Tenta calcular o integral definido de @var{expr} pelo uso de
500 @code{limit} para avaliar o integral indefinido @var{expr} em relação a @var{x}
501 no limite superior @var{b} e no limite inferior @var{a}.
502 Se isso falha para calcular o integral definido,
503 @code{ldefint} retorna uma expressão contendo limites como formas substantivas.
505 @code{ldefint} não é chamada por @code{integrate},
506 então executando @code{ldefint (@var{expr}, @var{x}, @var{a}, @var{b})} pode retornar um resultado diferente de
507 @code{integrate (@var{expr}, @var{x}, @var{a}, @var{b})}.
508 @code{ldefint} sempre usa o mesmo método para avaliar o integral definido,
509 enquanto @code{integrate} pode utilizar várias heurísticas e pode reconhecer alguns casos especiais.
511 @end deffn
513 @c UMM, IS THERE SOME TEXT MISSING HERE ???
514 @c WHAT IS THIS ABOUT EXACTLY ??
515 @deffn {Função} potential (@var{givengradient})
516 O cálculo faz uso da variável global @code{potentialzeroloc[0]}
517 que deve ser @code{nonlist} ou da forma
519 @example
520 [indeterminatej=expressãoj, indeterminatek=expressãok, ...]
521 @end example
523 O
524 formador sendo equivalente para a expressão nonlist para todos os lados
525 direitos-manuseados mais tarde. Os lados direitos indicados são usados como o
526 limite inferior de integração. O sucesso das integrações pode
527 depender de seus valores e de sua ordem. @code{potentialzeroloc} é inicialmente escolhido
528 para 0.
530 @end deffn
532 @deffn {Função} residue (@var{expr}, @var{z}, @var{z_0})
533 Calcula o resíduo no plano complexo da
534 expressão @var{expr} quando a variável @var{z} assumes o valor @var{z_0}. O
535 resíduo é o coeficiente de @code{(@var{z} - @var{z_0})^(-1)} nas séries de Laurent
536 para @var{expr}.
538 @example
539 (%i1) residue (s/(s**2+a**2), s, a*%i);
540 1
541 (%o1) -
542 2
543 (%i2) residue (sin(a*x)/x**4, x, 0);
544 3
545 a
546 (%o2) - --
547 6
548 @end example
550 @end deffn
552 @deffn {Função} risch (@var{expr}, @var{x})
553 Integra @var{expr} em relação a @var{x} usando um
554 caso transcendental do algoritmo de Risch. (O caso algébrico do
555 algoritmo de Risch foi implementado.) Isso actualmente
556 manuseia os casos de exponenciais aninhadas e logaritmos que a parte
557 principal de @code{integrate} não pode fazer. @code{integrate} irá aplicar automaticamente @code{risch}
558 se dados esses casos.
560 @code{erfflag}, se @code{false}, previne @code{risch} da introdução da função
561 @code{erf} na resposta se não for achado nenhum no integrando para
562 começar.
564 @example
565 (%i1) risch (x^2*erf(x), x);
566 2
567 3 2 - x
568 %pi x erf(x) + (sqrt(%pi) x + sqrt(%pi)) %e
569 (%o1) -------------------------------------------------
570 3 %pi
571 (%i2) diff(%, x), ratsimp;
572 2
573 (%o2) x erf(x)
574 @end example
576 @end deffn
578 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
579 @deffn {Função} tldefint (@var{expr}, @var{x}, @var{a}, @var{b})
580 Equivalente a @code{ldefint} com @code{tlimswitch} escolhido para @code{true}.
582 @end deffn
584 @footnotestyle end
586 @node Introdução a QUADPACK, Definições para QUADPACK, Definições para Integração, Integração
587 @section Introdução a QUADPACK
590 @c FOLLOWING TEXT ADAPTED WITH HEAVY MODIFICATION FROM http://www.netlib.org/slatec/src/qpdoc.f
592 QUADPACK é uma colecção de funções para
593 aálculo numérico de integrais definidos unidimensionais. O pacote
594 QUADPACK resultou da junção de um projeto de R. Piessens
595 @footnote{Applied Mathematics and Programming Division, K.U. Leuven},
596 E. de Doncker @footnote{Applied Mathematics and Programming Division,
597 K.U. Leuven}, C. Ueberhuber @footnote{Institut fur Mathematik,
598 T.U. Wien}, e D. Kahaner @footnote{National Bureau of Standards,
599 Washington, D.C., U.S.A}.
601 A biblioteca QUADPACK inclída no Maxima é uma
602 tradução automática (feita através do programa
603 @code{f2cl}) do código fonte em de QUADPACK como aparece na SLATEC
604 Common Mathematical Library, Versão 4.1
605 @footnote{http://www.netlib.org/slatec}. A biblioteca Fortran SLATEC
606 é datada de Julho de 1993, mas as funções QUADPACK
607 foram escritas alguns anos antes. Existe outra versão de QUADPACK em
608 Netlib @footnote{http://www.netlib.org/quadpack}; não está claro no
609 que aquela versão difere da versão existente em SLATEC.
611 As funções QUADPACK incluídas no Maxima são toda automáticas,
612 no sentido de que essas funções tentam calcular um resultado para uma precisão específica,
613 requerendo um número não especificado de avaliações de função.
614 A tradução do Lisp do Maxima da iblioteca QUADPACK também inclui algumas funç@~es não automáticas,
615 mas elas não são expostas a nível de Maxima.
617 Informação adicionalsobre a bilioteca QUADPACK pode ser encontrada no livro do QUADPACK
618 @footnote{R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, e D.K. Kahaner.
619 @i{QUADPACK: A Subroutine Package for Automatic Integration.}
620 Berlin: Springer-Verlag, 1983, ISBN 0387125531.}.
622 @subsection Overview
624 @table @code
625 @item quad_qag
626 Integração de uma função genérica sobre um intervalo finito.
627 @code{quad_qag} implementa um integrador adaptativo globalmente simples usando a estratégia de Aind (Piessens, 1973).
628 O chamador pode escolher entre 6 pares de formulas da quadratura de
629 Gauss-Kronrod para a componente de avaliação da regra.
630 As regras de alto grau são adequadas para integrandos fortemente oscilantes.
632 @item quad_qags
633 Integração de uma função genérica sob um intervalo finito.
634 @code{quad_qags} implementa subdivisão de intervalos globalmente adaptativos com extrapolação
635 (de Doncker, 1978) por meio do algoritmo de Epsilon (Wynn, 1956).
637 @item quad_qagi
638 Integração de uma função genérica sobre um intervalo finito ou semi-finito.
639 O intervalo é mapeado sobre um intervalo finito e
640 então a mesma estratégia de @code{quad_qags} é aplicada.
642 @item quad_qawo
643 Integração de @math{cos(omega x) f(x)} ou @math{sin(omega x) f(x)} sobre um intervalo finito,
644 onde @math{omega} é uma constante.
645 A componente de avaliação da regra é baseada na técnica modificada de Clenshaw-Curtis.
646 @code{quad_qawo} aplica subdivisão adaptativa com extrapolação, similar a @code{quad_qags}.
648 @item quad_qawf
649 Calcula uma transformação de co-seno de Fourier ou de um seno de Fourier sobre um intervalo semi-finito.
650 O mesmo aproxima como @code{quad_qawo} aplicado sobre intervalos finitos sucessivos,
651 e aceleração de convergência por meio d algorítimo de Epsilon (Wynn, 1956)
652 aplicado a séries de contribuições de integrais.
654 @item quad_qaws
655 Integraçào de @math{w(x) f(x)} sobre um intervalo finito @math{[a, b]},
656 onde @math{w} é uma função da forma @math{(x - a)^alpha (b - x)^beta v(x)}
657 e @math{v(x)} é 1 ou @math{log(x - a)} ou @math{log(b - x)} ou @math{log(x - a) log(b - x)},
658 e @math{alpha > -1} e @math{beta > -1}.
659 Auma estratégia de subdivisão adaptativa é aplicada,
660 com integração modificada de Clenshaw-Curtis sobre os subintervalos que possuem @math{a} ou @math{b}.
662 @item quad_qawc
663 Calcula o valor principal de Cauchy de @math{f(x)/(x - c)} sobre um intervalo finito @math{(a, b)}
664 e um @math{c} especificado.
665 A estratégia é globalmente adaptativa, e a integração
666 modificada de Clenshaw-Curtis é usada sobre subamplitudes
667 que possuírem o ponto @math{x = c}.
668 @end table
670 @node Definições para QUADPACK, , Introdução a QUADPACK, Integração
671 @section Definições para QUADPACK
673 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
674 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
675 @deffn {Função} quad_qag (@var{f(x)}, @var{x}, @var{a}, @var{b}, @var{chave}, @var{epsrel}, @var{limite})
676 @deffnx {Função} quad_qag (@var{f}, @var{x}, @var{a}, @var{b}, @var{chave}, @var{epsrel}, @var{limite})
678 Integração de uma função genérica sobre um intervalo finito.
679 @code{quad_qag} implementa um integrador adaptativo globalmente simples usando a estratégia de Aind (Piessens, 1973).
680 O chamador pode escolher entre 6 pares de fórmulas da quadratura de
681 Gauss-Kronrod para a componente de avaliação da regra.
682 As regras de alto nível são adequadas para integrandos fortemente oscilatórios.
684 @code{quad_qag} calcula o integral
686 @ifhtml
687 @math{integrate (f(x), x, a, b)}
688 @end ifhtml
689 @ifinfo
690 @math{integrate (f(x), x, a, b)}
691 @end ifinfo
692 @tex
693 $$\int_a^b {f(x) dx}$$
694 @end tex
696 A função a ser integrada é @var{f(x)}, com variável
697 dependente @var{x}, e a função é para ser integrada entre os
698 limites @var{a} e @var{b}. @var{chave} é o integrador a ser usado
699 e pode ser um inteiro entre 1 e 6, inclusive. O valor de
700 @var{chave} selecciona a ordem da regra de integração de Gauss-Kronrod.
701 Regra de alta ordem são adequadas para integrandos fortemente oscilatórios.
703 O integrando pode ser especidficado como o nome de uma função Maxima ou uma função Lisp ou um operador,
704 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
706 A integração numérica é concluída adaptativamente pela subdivisão a
707 região de integração até que a precisão desejada for
708 completada.
710 Os argumentos opcionais @var{epsrel} e @var{limite} são o erro relativo
711 desejado e o número máximo de subintervalos respectivamente.
712 @var{epsrel} padrão em 1e-8 e @var{limite} é 200.
714 @code{quad_qag} retorna uma lista de quatro elementos:
716 @itemize
717 @item
718 uma aproximação para o integral,
719 @item
720 o erro absoluto estimado da aproximação,
721 @item
722 o número de avaliações do integrando,
723 @item
724 um código de erro.
725 @end itemize
727 O código de erro (quarto elemento do valor de retorno) pode ter os valores:
729 @table @code
730 @item 0
731 se nenhum problema foi encontrado;
732 @item 1
733 se foram utilizados muitos subintervalos;
734 @item 2
735 se for detectato um erro de arredondamento excessivo;
736 @item 3
737 se o integrando se comportar muito mal;
738 @item 6
739 se a entrada não for válida.
741 @end table
743 @c NEED CROSS REFS HERE -- EITHER CROSS REF A QUADPACK OVERVIEW, OR CROSS REF EACH OF THE quad_* FUNCTIONS
745 Exemplos:
747 @example
748 (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3);
749 (%o1) [.4444444444492108, 3.1700968502883E-9, 961, 0]
750 (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
751 4
752 (%o2) -
753 9
754 @end example
755 @end deffn
757 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
758 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
759 @deffn {Função} quad_qags (@var{f(x)}, @var{x}, @var{a}, @var{b}, @var{epsrel}, @var{limite})
760 @deffnx {Função} quad_qags (@var{f}, @var{x}, @var{a}, @var{b}, @var{epsrel}, @var{limite})
762 Integração de uma função geral sobre um intervalo finito.
763 @code{quad_qags} implementa subdivisão de intervalo globalmente adaptativa com extrapolação
764 (de Doncker, 1978) através do algoritmo de (Wynn, 1956).
766 @code{quad_qags} calcula o integral
768 @ifhtml
769 @math{integrate (f(x), x, a, b)}
770 @end ifhtml
771 @ifinfo
772 @math{integrate (f(x), x, a, b)}
773 @end ifinfo
774 @tex
775 $$\int_a^b {f(x) dx}$$
776 @end tex
778 A função a ser integrada é @var{f(x)}, com
779 variável dependente @var{x}, e a função é para ser integrada
780 entre os limites @var{a} e @var{b}.
782 O integrando pode ser especidficado como o nome de uma função Maxima ou uma função Lisp ou um operador,
783 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
785 Os argumentos opcionais @var{epsrel} e @var{limite} são o erro relativo
786 desejado e o número máximo de subintervalos, respectivamente.
787 @var{epsrel} padrão em 1e-8 e @var{limite} é 200.
789 @code{quad_qags} retorna uma lista de quatro elementos:
791 @itemize
792 @item
793 uma aproximação para o integral,
794 @item
795 o erro absoluto estimado da aproximação,
796 @item
797 o número de avaliações do integrando,
798 @item
799 um código de erro.
800 @end itemize
802 O código de erro (quarto elemento do valor de retorno) pode ter os valores:
804 @table @code
805 @item 0
806 nenhum problema foi encontrado;
807 @item 1
808 foram utilizados muitos subintervalos;
809 @item 2
810 foi detectato um erro de arredondamento excessivo;
811 @item 3
812 o integrando comporta-se muito mal;
813 @item 4
814 não houve convergência
815 @item 5
816 o integral provavelmente é divergente, o converge lentamente
817 @item 6
818 a entrada não foi válida.
819 @end table
821 @c NEED CROSS REFS HERE -- EITHER CROSS REF A QUADPACK OVERVIEW, OR CROSS REF EACH OF THE quad_* FUNCTIONS
823 Exemplos:
825 @example
826 (%i1) quad_qags (x^(1/2)*log(1/x), x, 0 ,1);
827 (%o1) [.4444444444444448, 1.11022302462516E-15, 315, 0]
828 @end example
830 Note que @code{quad_qags} é mais preciso e eficiente que @code{quad_qag} para esse integrando.
832 @end deffn
834 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
835 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
836 @deffn {Função} quad_qagi (@var{f(x)}, @var{x}, @var{a}, @var{inftype}, @var{epsrel}, @var{limite})
837 @deffnx {Função} quad_qagi (@var{f}, @var{x}, @var{a}, @var{inftype}, @var{epsrel}, @var{limite})
839 Integração de uma função genérica sobre um intervalo finito ou semi-finito.
840 O intervalo é mapeado sobre um intervalo finito e
841 então a mesma estratégia que em @code{quad_qags} é aplicada.
843 @code{quad_qagi} avalia um dos seguintes integrais
845 @ifhtml
846 @math{integrate (f(x), x, minf, inf)}
847 @end ifhtml
848 @ifinfo
849 @math{integrate (f(x), x, minf, inf)}
850 @end ifinfo
851 @tex
852 $$\int_a^\infty {f(x) dx}$$
853 @end tex
855 @ifhtml
856 @math{integrate (f(x), x, minf, a)}
857 @end ifhtml
858 @ifinfo
859 @math{integrate (f(x), x, minf, a)}
860 @end ifinfo
861 @tex
862 $$\int_\infty^a {f(x) dx}$$
863 @end tex
865 @ifhtml
866 @math{integrate (f(x), x, a, minf, inf)}
867 @end ifhtml
868 @ifinfo
869 @math{integrate (f(x), x, a, minf, inf)}
870 @end ifinfo
871 @tex
872 $$\int_{-\infty}^\infty {f(x) dx}$$
873 @end tex
875 usando a rotina Quadpack QAGI. A função a ser integrada é
876 @var{f(x)}, com variável dependente @var{x}, e a função é para
877 ser integrada sobre um intervalo infinito.
879 O integrando pode ser especidficado como o nome de uma função Maxima ou uma função Lisp ou um operador,
880 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
882 O parâmetro @var{inftype} determina o intervalo de integração como segue:
884 @table @code
885 @item inf
886 O intervalo vai de @var{a} ao infinito positivo.
887 @item minf
888 O intervalo vai do infinito negativo até @var{a}.
889 @item both
890 O intervalo corresponde a toda reta real.
891 @end table
893 Os argumentos opcionais @var{epsrel} e @var{limite} são o erro relativo
894 desejado e o número maximo de subintervalos, respectivamente.
895 @var{epsrel} padrão para 1e-8 e @var{limite} é 200.
897 @code{quad_qagi} retorna uma lista de quatro elementos:
899 @itemize
900 @item
901 uma aproximação para o integral,
902 @item
903 o erro absoluto estimado da aproximação,
904 @item
905 o número de avaliações do integrando,
906 @item
907 um código de erro.
908 @end itemize
910 O código de erro (quarto elemento do valor de retorno) pode ter os valores:
912 @table @code
913 @item 0
914 nenhum problema foi encontrado;
915 @item 1
916 foram utilizados muitos subintervalos;
917 @item 2
918 foi detectato um erro de arredondamento excessivo;
919 @item 3
920 o integrando comporta-se muito mal;
921 @item 4
922 não houve convergência
923 @item 5
924 o integral provavelmente é divergente, o converge lentamente
925 @item 6
926 a entrada não foi válida.
928 @end table
930 @c NEED CROSS REFS HERE -- EITHER CROSS REF A QUADPACK OVERVIEW, OR CROSS REF EACH OF THE quad_* FUNCTIONS
932 Exemplos:
934 @example
935 (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf);
936 (%o1) [0.03125, 2.95916102995002E-11, 105, 0]
937 (%i2) integrate (x^2*exp(-4*x), x, 0, inf);
938 1
939 (%o2) --
940 32
941 @end example
943 @end deffn
945 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
946 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
947 @deffn {Função} quad_qawc (@var{f(x)}, @var{x}, @var{c}, @var{a}, @var{b}, @var{epsrel}, @var{limite})
948 @deffnx {Função} quad_qawc (@var{f}, @var{x}, @var{c}, @var{a}, @var{b}, @var{epsrel}, @var{limite})
950 Calcula o valor principal de Cauchy de @math{f(x)/(x - c)} over a finite interval.
951 A estratégia é globalmente adaptativa, e a integração de
952 Clenshaw-Curtis modificada é usada sobre as subamplitudes
953 que possuírem o ponto @math{x = c}.
955 @code{quad_qawc} calcula o valor principal de Cauchy de
957 @ifhtml
958 @math{integrate (f(x)/(x - c), x, a, b)}
959 @end ifhtml
960 @ifinfo
961 @math{integrate (f(x)/(x - c), x, a, b)}
962 @end ifinfo
963 @tex
964 $$\int_{a}^{b}{{{f\left(x\right)}\over{x-c}}\>dx}$$
965 @end tex
967 usando a rotina Quadpack QAWC. A função a ser integrada é
968 @code{@var{f(x)}/(@var{x} - @var{c})}, com variável dependente @var{x}, e a função
969 é para ser integrada sobre o intervalo que vai de @var{a} até @var{b}.
971 O integrando pode ser especidficado como o nome de uma função Maxima ou uma função Lisp ou um operador,
972 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
974 Os argumentos opcionais @var{epsrel} e @var{limite} são o erro relativo
975 desejado e o máximo número de subintervalos, respectivamente.
976 @var{epsrel} padrão para 1e-8 e @var{limite} é 200.
978 @code{quad_qawc} retorna uma lista de quatro elementos:
980 @itemize
981 @item
982 uma aproximação para o integral,
983 @item
984 o erro absoluto estimado da aproximação,
985 @item
986 o número de avaliações do integrando,
987 @item
988 um código de erro.
989 @end itemize
991 O código de erro (quarto elemento do valoor de retorno) pode ter os valores:
993 @table @code
994 @item 0
995 nenhum problema foi encontrado;
996 @item 1
997 foram utilizados muitos subintervalos;
998 @item 2
999 foi detectato um erro de arredondamento excessivo;
1000 @item 3
1001 o integrando comporta-se muito mal;
1002 @item 6
1003 a entrada não foi válida.
1005 @end table
1007 Exemplos:
1009 @example
1010 (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5);
1011 (%o1) [- 3.130120337415925, 1.306830140249558E-8, 495, 0]
1012 (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), x, 0, 5);
1013 Principal Value
1014 alpha
1015 alpha 9 4 9
1016 4 log(------------- + -------------)
1017 alpha alpha
1018 64 4 + 4 64 4 + 4
1019 (%o2) (-----------------------------------------
1020 alpha
1021 2 4 + 2
1023 3 alpha 3 alpha
1024 ------- -------
1025 2 alpha/2 2 alpha/2
1026 2 4 atan(4 4 ) 2 4 atan(4 ) alpha
1027 - --------------------------- - -------------------------)/2
1028 alpha alpha
1029 2 4 + 2 2 4 + 2
1030 (%i3) ev (%, alpha=5, numer);
1031 (%o3) - 3.130120337415917
1032 @end example
1034 @end deffn
1036 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
1037 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
1038 @deffn {Função} quad_qawf (@var{f(x)}, @var{x}, @var{a}, @var{omega}, @var{trig}, @var{epsabs}, @var{limit}, @var{maxp1}, @var{limlst})
1039 @deffnx {Função} quad_qawf (@var{f}, @var{x}, @var{a}, @var{omega}, @var{trig}, @var{epsabs}, @var{limit}, @var{maxp1}, @var{limlst})
1041 Calcula uma transformação de co-seno de Fourier ou de um seno de Fourier sobre um intervalo semi-finito.
1042 usando a função QAWF do pacote Quadpack.
1043 A mesma aproxima como em @code{quad_qawo} quando aplicada sobre intervalos finitos sucessivos,
1044 e aceleração de convergência por meio d algorítimo de Epsilon (Wynn, 1956)
1045 aplicado a séries de contribuições de integrais.
1047 @code{quad_qawf} calcula o integral
1049 @ifhtml
1050 @math{integrate (f(x)*w(x), x, a, inf)}
1051 @end ifhtml
1052 @ifinfo
1053 @math{integrate (f(x)*w(x), x, a, inf)}
1054 @end ifinfo
1055 @tex
1056 $$\int_a^\infty f(x) w(x) dx$$
1057 @end tex
1059 A função peso @math{w} é seleccionada por @var{trig}:
1061 @table @code
1062 @item cos
1063 @math{w(x) = cos (omega x)}
1064 @item sin
1065 @math{w(x) = sin (omega x)}
1066 @end table
1068 O integrando pode ser especidficado como o nome de uma função Maxima ou uma função Lisp ou um operador,
1069 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
1071 Os argumentos opcionais são:
1073 @table @code
1074 @item epsabs
1075 Erro absoluto de aproximação desejado. Padrão é 1d-10.
1076 @item limit
1077 Tamanho de array interno de trabalho. (@var{limit} - @var{limlst})/2 é o
1078 maximo número de subintervalos para usar. O Padrão é 200.
1079 @item maxp1
1080 O número máximo dos momentos de Chebyshev. Deve ser maior que 0. O padrão
1081 é 100.
1082 @item limlst
1083 Limite superior sobre número de ciclos. Deve ser maior ou igual a
1084 3. O padrão é 10.
1085 @end table
1087 @c MERGE THESE LINES INTO PRECEDING TABLE
1088 @var{epsabs} e @var{limit} são o erro relativo
1089 desejado e o número maximo de subintervalos, respectivamente.
1090 @var{epsrel} padrão para 1e-8 e @var{limit} é 200.
1092 @code{quad_qawf} retorna uma lista de quatro elementos:
1094 @itemize
1095 @item
1096 uma aproximação para o integral,
1097 @item
1098 o erro absoluto estimado da aproximação,
1099 @item
1100 o número de avaliações do integrando,
1101 @item
1102 um código de erro.
1103 @end itemize
1105 O código de erro (quarto elemento do valor de retorno) pode ter os valores:
1107 @table @code
1108 @item 0
1109 nenhum problema foi encontrado;
1110 @item 1
1111 foram utilizados muitos subintervalos;
1112 @item 2
1113 foi detectato um erro de arredondamento excessivo;
1114 @item 3
1115 o integrando comporta-se muito mal;
1116 @item 6
1117 a entrada não foi válida.
1119 @end table
1121 Exemplos:
1123 @example
1124 (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos);
1125 (%o1) [.6901942235215714, 2.84846300257552E-11, 215, 0]
1126 (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
1127 - 1/4
1128 %e sqrt(%pi)
1129 (%o2) -----------------
1130 2
1131 (%i3) ev (%, numer);
1132 (%o3) .6901942235215714
1133 @end example
1135 @end deffn
1137 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
1138 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
1139 @deffn {Função} quad_qawo (@var{f(x)}, @var{x}, @var{a}, @var{b}, @var{omega}, @var{trig}, @var{epsabs}, @var{limite}, @var{maxp1}, @var{limlst})
1140 @deffnx {Função} quad_qawo (@var{f}, @var{x}, @var{a}, @var{b}, @var{omega}, @var{trig}, @var{epsabs}, @var{limite}, @var{maxp1}, @var{limlst})
1142 Integração de @math{cos(omega x) f(x)} ou @math{sin(omega x) f(x)} sobre um intervalo finito,
1143 onde @math{omega} é uma constante.
1144 A componente de avaliação da regra é baseada na técnica modificada de Clenshaw-Curtis.
1145 @code{quad_qawo} aplica subdivisão adaptativa com extrapolação, similar a @code{quad_qags}.
1147 @code{quad_qawo} calcula o integral usando a rotina
1148 Quadpack QAWO:
1150 @ifhtml
1151 @math{integrate (f(x)*w(x), x, a, b)}
1152 @end ifhtml
1153 @ifinfo
1154 @math{integrate (f(x)*w(x), x, a, b)}
1155 @end ifinfo
1156 @tex
1157 $$\int_a^b f(x) w(x) dx$$
1158 @end tex
1161 A função peso @math{w} é seleccionada por @var{trig}:
1163 @table @code
1164 @item cos
1165 @math{w(x) = cos (omega x)}
1166 @item sin
1167 @math{w(x) = sin (omega x)}
1168 @end table
1170 O integrando pode ser especidficado como o nome de uma função Maxima ou uma função Lisp ou um operador,
1171 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
1173 Os argumentos opcionais são:
1175 @table @code
1176 @item epsabs
1177 Erro absoluto desejado de aproximação. O Padrão é 1d-10.
1178 @item limite
1179 Tamanho do array interno de trabalho. (@var{limite} - @var{limlst})/2 é o
1180 número máximo de subintervalos a serem usados. Default é 200.
1181 @item maxp1
1182 Número máximo dos momentos de Chebyshev. Deve ser maior que 0. O padrão
1183 é 100.
1184 @item limlst
1185 Limite superior sobre o número de ciclos. Deve ser maior que ou igual a
1186 3. O padrão é 10.
1187 @end table
1189 @c MERGE THESE LINES INTO PRECEDING TABLE
1190 @var{epsabs} e @var{limite} são o erro relativo
1191 desejado e o número máximo de subintervalos, respectivamente.
1192 @var{epsrel} o padrão é 1e-8 e @var{limite} é 200.
1194 @code{quad_qawo} retorna uma lista de quatro elementos:
1196 @itemize
1197 @item
1198 uma aproximação para o integral,
1199 @item
1200 o erro absoluto estimado da aproximação,
1201 @item
1202 o número de avaliações do integrando,
1203 @item
1204 um código de erro.
1205 @end itemize
1207 O código de erro (quarto elemento do valor de retorno) pode ter os valores:
1209 @table @code
1210 @item 0
1211 nenhum problema foi encontrado;
1212 @item 1
1213 foram utilizados muitos subintervalos;
1214 @item 2
1215 foi detectato um erro de arredondamento excessivo;
1216 @item 3
1217 o integrando comporta-se muito mal;
1218 @item 6
1219 a entrada não foi válida.
1221 @end table
1223 Exemplos:
1225 @example
1226 (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
1227 (%o1) [1.376043389877692, 4.72710759424899E-11, 765, 0]
1228 (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), x, 0, inf));
1229 alpha/2 - 1/2 2 alpha
1230 sqrt(%pi) 2 sqrt(sqrt(2 + 1) + 1)
1231 (%o2) -----------------------------------------------------
1232 2 alpha
1233 sqrt(2 + 1)
1234 (%i3) ev (%, alpha=2, numer);
1235 (%o3) 1.376043390090716
1236 @end example
1238 @end deffn
1240 @c THERE ARE OPTIONAL ARGUMENTS WHICH MAKES LISTING THE VARIANTS A LITTLE TEDIOUS
1241 @c NEED A MORE CONVENIENT (AND NONAMBIGUOUS) NOTATION FOR OPTIONAL ARGUMENTS
1242 @deffn {Função} quad_qaws (@var{f(x)}, @var{x}, @var{a}, @var{b}, @var{alpha}, @var{beta}, @var{wfun}, @var{epsabs}, @var{limite})
1243 @deffnx {Função} quad_qaws (@var{f}, @var{x}, @var{a}, @var{b}, @var{alpha}, @var{beta}, @var{wfun}, @var{epsabs}, @var{limite})
1245 Integração de @math{w(x) f(x)} sobre um intervalo finito,
1246 onde @math{w(x)} é uma certa função algébrica ou logarítmica.
1247 Uma estratégia de subdivisão globalmente adaptativa é aplicada,
1248 com integração modificada de Clenshaw-Curtis sobre os subintervalos que possuírem os pontos finais
1249 dos intervalos de integração.
1251 @code{quad_qaws} calcula o integral usando a rotina
1252 Quadpack QAWS:
1254 @ifhtml
1255 @math{integrate (f(x)*w(x), x, a, b)}
1256 @end ifhtml
1257 @ifinfo
1258 @math{integrate (f(x)*w(x), x, a, b)}
1259 @end ifinfo
1260 @tex
1261 $$\int_a^b f(x) w(x) dx$$
1262 @end tex
1264 A função peso @math{w} é seleccionada por @var{wfun}:
1266 @table @code
1267 @item 1
1268 @math{w(x) = (x - a)^alpha (b - x)^beta}
1269 @item 2
1270 @math{w(x) = (x - a)^alpha (b - x)^beta log(x - a)}
1271 @item 3
1272 @math{w(x) = (x - a)^alpha (b - x)^beta log(b - x)}
1273 @item 4
1274 @math{w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)}
1275 @end table
1277 O integrando pode ser especificado como o nome de uma função Maxima ou uma função Lisp ou um operador,
1278 uma expressão lambda do Maxima, ou uma expressão geral do Maxima.
1280 O argumentos opcionais são:
1282 @table @code
1283 @item epsabs
1284 Erro absoluto desejado de aproximação. O padrão é 1d-10.
1285 @item limite
1286 Tamanho do array interno de trabalho. (@var{limite} - @var{limlst})/2 é o
1287 número máximo de subintervalos para usar. O padrão é 200.
1288 @end table
1290 @c MERGE THESE LINES INTO PRECEDING TABLE
1291 @var{epsabs} e @var{limit} são o erro relativo
1292 desejado e o número máximo de subintervalos, respectivamente.
1293 @var{epsrel} o padrão é 1e-8 e @var{limite} é 200.
1295 @code{quad_qaws} retorna uma lista de quatro elementos:
1297 @itemize
1298 @item
1299 uma aproximação para o integral,
1300 @item
1301 o erro absoluto estimado da aproximação,
1302 @item
1303 o número de avaliações do integrando,
1304 @item
1305 um código de erro.
1306 @end itemize
1308 O código de erro (quarto elemento do valor de retorno) pode ter os valores:
1310 @table @code
1311 @item 0
1312 nenhum problema foi encontrado;
1313 @item 1
1314 foram utilizados muitos subintervalos;
1315 @item 2
1316 foi detectato um erro de arredondamento excessivo;
1317 @item 3
1318 o integrando comporta-se muito mal;
1319 @item 6
1320 a entrada não foi válida.
1322 @end table
1324 Exemplos:
1326 @example
1327 (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1);
1328 (%o1) [8.750097361672832, 1.24321522715422E-10, 170, 0]
1329 (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
1330 alpha
1331 Is 4 2 - 1 positive, negative, or zero?
1333 pos;
1334 alpha alpha
1335 2 %pi 2 sqrt(2 2 + 1)
1336 (%o2) -------------------------------
1337 alpha
1338 4 2 + 2
1339 (%i3) ev (%, alpha=4, numer);
1340 (%o3) 8.750097361672829
1341 @end example
1343 @end deffn