métodos computacionais numéricos e algébricos com maple · ... definimos 3 como sendo o único...
TRANSCRIPT
Métodos Computacionais Numéricos e Algébricos com Maple
CCT - UDESC
Fernando Deeke Sasse [email protected]
Departamento de Matemática, UDESC - Joinville
Aritmética ComputacionalO cálculo numérico, uma das principais ferramentas da computação científica é caracterizado pela manipulação de representações não exatas de números reais. Isso implica em diversos obstáculos para a construção de algoritmos computacionais eficientes. Além de termos que nos preocupar com otempo gasto e com a quantidade de memória utilizados, devemos estar também estar preocupados com a veracidade das soluções. Assim como alguns algoritmos discretos são inerentemente muito lentos (polinomiais vs. exponenciais), veremos que alguns algoritmos de ponto flutuante são também muito inacurados (estáveis vs. instáveis). Algumas vezes este problema pode ser corrigido através da elaboração de um algoritmo mais otimizado. Em alguns problemas discretos a dificuldade pode ser intrínseca (NP-completo) ou então inerente (mal condicionalmento), como acontece em previsão de tempo a longo prazo. Para lidar efetivamente com computação científica devemos ser capazes de classificar nossos algoritmos e problemas convenientemente.
Começaremos estudando em maior detalhe a forma como computadores armazenam e realizam operações básicas com números. Finalmente estudaremos erros em algoritmos.
Sistemas de ponto flutuante em geralNa aritmética usual temos a liberdade de utilizar números com um número infinito de dígitos não-
periódicos. Por exemplo, definimos 3 como sendo o único número positivo que multiplicado por ele mesmo resulta o inteiro 3. Na aritmética computacional, entretanto, cada nú- mero é
representável somente através de um número fixo, finito de dígitos. Como 3 não tem uma representação de dígitos finita, uma representação aproximada é escolhida pela máquina, cujo quadrado não é exatamente 3, embora uma boa aproximação em geral. O objetivo desta seção é examinar alguns casos onde a representação finita de dígitos pode trazer problemas não triviais. Erros de arredondamento ocorrem quando uma calculadora ou computador é utilizado para realizar cálculos envolvendo números reais. Em um computador típico, somente um subconjunto relativamente pequeno dos números reais é utilizado para a representação de todos os números reais. Este subconjunto contém somente os números racionais, positivos e negativos. Um fato importante, que veremos logo a seguir, é que certos erros aparentemente inexplicáveis devem-se ao fato de que diferentes sistemas computacionais utilizam diferentes sistemas de aritmética de ponto flutuante, via hardware ou software.
Normalmente os dados de entrada são enviados ao computador pelo usuário no sistema decimal. O computador os converte para binário, onde são efetuadas as computações. Os resultados finais são convertidos para o sistema decimal e transmitidos ao usuário. Estes processos de conversão são uma fonte de erro dos cálculos.
A representação de um número no formato de ponto flutuante pode ser dada na forma
onde os di são dígitos ou bits cujos valores podem variar de 0 a BK1, sendo B a base
(normalmente 2,10 ou 16), p é o número de dígitos (precisão) e e é o expoente inteiro que está dentro de um certo intervalo e1 < e < e2. O termo d1 d2 $$$dp é denominado mantissa. Outra forma
para esta representação é:
Esta representação é denominada normalizada quando o bit de mais alta ordem é 1. No presente caso, d1 = 1. Com estas convenções acima, vamos denotar sistemas de ponto flutuante particulares
na forma F B, p, e1, e2 . Neste sistema o menor número não nulo, possível de ser representado, é
e o maior número é
Consideremos alguns exemplos. Quando um número é muito pequeno para ser representado pelo sistema da máquina, ele é considerado zero, e temos nesse caso um underflow. Quando ele é grande demais para ser representável pela máquina, temos overflow e a computação pára.
Exemplo 1 Consideremos o sistema F(10, 3,-5, 5). Os números são representados na seguinte
forma:0. d1 d2 d3 10e, 0% dj % 9, K5 %e% 5.
O número de menor magnitude normalizada nesta máquina é dado porn1 = 0.100$10K5,
e o de maior magnitude é n2 = 0.999$105 .
Consideremos as limitações da máquina com as entradas dos seguintes números:
(a) x = 235.89 = 0.23589$105
Como a máquina só pode representar três dígitos na mantissa, os dígitos 8 e 9 são eliminados, de modo que o número representado é 0.235$105, se for utilizado o truncamento, e 0.236$105 se for utilizado o arredondamento.
(b) x = 0.345 10K7. Este número não pode ser representado nesta máquina porque o expoente -7 é menor que o menor admitido -5. Este é um caso de underflow, e tais números são considerados como zero pela máquina.
(c) x = 0.562$108. Este número não pode ser representado pela máquina pois o expoente +8 é maior do que o máximo +5. Neste caso temos overflow, e a computação pára.
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Exemplo 2Consideremos o sistema normalizado definido por F (2, 3, -1, 2). As possíveis mantissas são: 0.100 , 0.101 , 0.110 , 0.111 e os possíveis expoentes são -1, 0, 1, 2.
O menor número nesta representação (binária) é n 1 = 0.100$2K1,
que na representação decimal equivale a
1$2K1$2K1 =
14
.
O maior número nesta representação é n 2 = 0.111$22,
que na representação decimal equivale a
1$2K1C1$2K2
C1$2K3$22 =
72
.
Portanto, a região entre -1/4 e 1/4 é chamada região de underflow, enquanto que a região com números maiores que 7/2 e menores que -7/2 é chamada de região de overflow.
Determinemos todos os números de possível ocorrência nesta máquina. Mostraremos que sua distribuição não é linear:
restart:with(combinat);L := [op(permute([1, 0])), [0, 0], [1, 1]];LL := [seq([1, op(L[i])], i = 1 .. 4)];nm:=nops(LL):v:=0:lnum:={}:p:=3:e2:=-1:e1:=2:m[1]:=[1,0,0]:m[2]:=[1,0,1]:m[3]:=[1,1,0]:m[4]:=[1, 1,1]: for j from e2 to e1 do for i to nm do x[i,j]:=sum(op(k,LL[i])*2^(-k),k=1..p)*2^(j); v:=v+1: n[v]:=%%; lnum:=lnum union {n[v]} ; od;od;print('numeros'=lnum);
Vejamos como estes números estão distribuídos. with(plots);lnum;Lnum := convert(lnum, list);LnumS := sort(Lnum, `<`);nn := nops(LnumS);P := [seq([i, LnumS[i]], i = 1 .. nn)];pointplot(P);
Notemos que o zero não está definido no conjunto acima. Ele é especialmente definido na máquina e não é normalizado. Façamos alguns cálculos envolvendo números representáveis neste sistema. Por exemplo, 1/2+7/4 = 9/4. Este número não pertence ao conjunto dos números
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
decimais representáveis pelo sistema, que determinamos acima. De fato, 9/4 em binário é dado por
convert(evalf(9/4), binary);
ou seja, 0.1001$22, que possui uma mantissa maior que a admitida pelo sistema. Se houver truncamento, este número será aproximado para 0.100$22, que representa 2. Se esta soma for feita utilizando-se a representação binária, obteremos
0.100$20C0.111$21 = 0.100$22 = 2
Exemplo 3Consideremos o sistema normalizado definido por F (2, 4, -3, 3). Determinemos todos os númerospossíveis deste sistema e a sua distribuição na forma decimal.
restart:with(combinat);L := [op(permute([1, 0, 0])), op(permute([1, 0, 1]) ), op(permute([1, 1, 0])), [0, 0, 0], [1, 1, 1]];nm := nops(L);LL := [seq([1, op(L[i])], i = 1 .. nm)];v:=0:lnum:={}:e1:=-3:e2:=3:e2:=-1:e1:=2:p:=4: for j from e2 to e1 do for i to nm do x[i,j]:=sum(op(k,LL[i])*2^(-k),k=1..p)*2^(j); v:=v+1: n[v]:=%%; lnum:=lnum union {n[v]} ; od;od;print('numeros'=lnum);with(plots);lnum;Lnum := convert(lnum, list);LnumS := sort(Lnum, `<`);nn := nops(LnumS);P := [seq([i, LnumS[i]], i = 1 .. nn)];pointplot(P);
O menor número (em magnitude) de pontos flutuante que, quando adicionado ao número 1.0 produz um número de ponto flutuante diferente de 1.0 é denominado acuracidade (acurácia ou exatidão) de máquina ε
m . Um computador típico com B = 2 e comprimento de palavra de 32 bits
tem εm em torno de 10-8. Em outras palavras, a acuracidade de máquina ǫm é a acuracidade
fracional na qual números de pontos flutuantes são representados, correspondendo a uma mudança de 1 no bit menos significativo da mantissa. Em geral qualquer operação aritmética entrenúmeros de pontos flutuantes pode ser pensada como sendo a introdução de um erro fracional de ao menos ǫm (erro de arredondamento).
No exemplo anterior, somando 1+1/4, obtemos 5/4. de modo que a precisão de máquina é 1/4 (coincidindo com o menor número representável no sistema.)
É importante notar que ǫm não é o menor número de ponto flutuante que pode ser representado
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
em uma dada máquina. Este último depende de quantos bits podem ser armazenados no expoente, enquanto que εm depende de quantos bits há na mantissa. A acuracidade (acurácia, exatidão) de
máquina de um sistema de ponto flutuante pode ser determinada por um simples algoritmo. Em Maple podemos definir o procedimento que usa o sistema de ponto flutuante de hardware (IEEE-754)
Digitsd 20 : epsilon:=1: while evalhf(epsilon+1)>1 do epsilon:=evalhf(epsilon/2); od: evalhf(epsilon);
Notemos que neste caso o sistema de ponto de flutuante de hardware é do tipo estendido (80bits). No sistema que usa sistema de ponto flutuante de software (decimal) temos:
Digitsd 10 : epsilon:=1: while evalf(epsilon+1)>1 do epsilon:=evalf(epsilon/2); od: epsilon;
As diferenças nestes valores se devem ao fato de que representações em diferentes bases são usadas.
Representação de ponto flutuante binária IEEE 754Quando em 1985 a Intel deciciu introduzir um coprocessador de ponto flutuante para seu novo microprocessador 8086, denominado 8087 FPU, um novo sistema de ponto flutuante binário foi introduzido (Kahn, Coonan, Stone), sendo logo adotado como padrão pelo IEEE (Institute for Electrical and Electronic Engineers). Foram definidos os formatos denominados simples, duplo e estendido.
Formato simplesO formato simples IEEE, ou precisão simples, denominado "float"em C, é definido de tal modo que cada número é armazenado em uma palavra de 32 bit (4 bytes) na seguinte forma:
K1 s 2EK127$ 1Cm ,
sendo a distribuição de bits dada por
Notemos que a mantissa está entre 1 e 2. O bit 1 mais à esquerda é já implícito, e portanto não necessita ser armazenado. Vejamos o expoente. Embora um número binário de 8 bits possa ter valores decimais entre 0000 00002 e 1111 11112 = 25510 , estes valores extremos são
reservados para números especiais, como veremos logo adiante. Para números normais os bits do expoentem pode estar entre 0000 00012 e 0111 11112 . Ou seja, 1!E! 254, pois
restart
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
EM : = sum( 2^k, k = 1 . . 7) ;O número 127 é denominado bias do expoente e foi introduzido para permitir expoentes negativos. Ou seja, o expoente Eb = EK127 pode estar no intervalo K126!EB! 127.
O número de dígitos significativos da parte fracionária da mantissa, representáveis na base decimal é
fsolve(2^23 = 10^x, x);ou seja, aproximadamente 7 dígitos. O maior valor da mantissa é dado por
Digits := 8;m[max] := evalf(sum(2^(-k), k = 1 .. 23));
Portanto, o maior número decimal que pode ser representado com precisão simples é :x[max] := (1+m[max])*2^(EM-127);
O menor número neste sistema é
xmin d 1.$2 1K127
Notemos que embora xmax e xmin sejam representados por 8 dígitos, a aritmética é realizada a 7
dígitos. A acuracidade de máquina deve ser da ordem de 2K23, pois o número 1 é representado por 1.0000 0000 0000 0000 000$ 20. O próximo número que este sistema consegue distinguir de 1 é 1.0000 0000 0000 0000 001$20, que corresponde a 2K23 ou
2. K23
Formato duploConhecido em C como "double", este formato é implementado em 64 bits (8 bytes) da seguinte forma:
K1 s 2EK1023$ 1Cm ,
sendo a distribuição de bits dada por
Consideremos o expoente. Embora um número binário de 11 bits possa ter valores decimais entre 0000 0000 0002 e 1111 1111 1112 = 204710 , estes valores extremos são reservados
para números especiais, como veremos logo adiante. Para números normais os bits do expoentem pode estar entre 0000 0000 0012 e 1111 1111 1102 . Ou seja, 1!E!2046,
poisrestartEM := sum(2^k, k = 1 .. 10);
O bias do expoente é 1023. Ou seja, o expoente Eb = EK1023 pode estar no intervalo
K1022!Eb!1023.
O número de dígitos significativos da parte fracionária da mantissa, representáveis na base decimal é
fsolve(2^52 = 10^x, x);ou seja, entre 15 e 16 dígitos. O maior valor da mantissa é dado por
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Di gi t s : = 16;m[max] := evalf(sum(2^(-k), k = 1 .. 52));
Portanto, o maior número decimal que pode ser representado com precisão simples é :x[max] := (1+m[max])*10^(EM-1023);
O menor número neste sistema é
xmin d 1.$2K1022
A acuracidade de máquina é 1.00 ...0012$20 = 2K52
2. K52
Formato estendidoConhecido em C como "long double", este formato é implementado em 80 bits (10 bytes) da seguinte forma:
K1 s * 2EK16383 * (m),sendo o a distribuição de bits dada porsinal expoente mantissa[s] [eeee...eeee] [1.mmmm...mmmm]1 bit 15 bits 64 bits
O número de dÌgitos significativos da parte fracionária da mantissa, representáveis na base decimal é
evalf 63 * log10 2 ;Ou seja, a precisão decimal na parte fracionária da mantissa é de 18 ou 19 dígitos. Esta é a precisão utilizada para cálculos realizados por chips Intel.
Números Especiais nos formatos simples e duplo
O padrão IEEE-754 reserva valores de todos os bits zero e todos os bits 1 para denotar valores especiais nos formatos simples e duplo
1 ZeroZero não representado diretamente, devido ao bit embutido que sempre tem valor 1. O zero é um valor especial com um campo de expoentes zero E e um campo de mantissa zero. Os valores K0 e C0 são distintos.
2 Números denormalizadosSe o expoente é tem bits todos 0, mas a mantissa é não zero, então o valor é chamado um número denormalizado, que não possui um bit 1 antes do ponto binário. Isso representa o númer
K1 s 2K126$ m
onde m é a mantissa (fração). Note que o expoente é K126, e não K127 como resultaria simplesmente fazendo E = 0.
ExercíciosResolva os problemas 15 e e 16 (Exercícios 1.2) do livro de Burden-Faires, Análise Numérica, 8 ed. páginas
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
Erros
Erros por má manipulação de pequenas magnitudes
A aritmética realizada por uma calculadora ou programa de computação numérica é diferente
daquela usada em cursos de álgebra e cálculo. Por exemplo, sabemos sabemos que 22
= 2 . Façamos este cálculo no computador, com precisão de 10 dígitos:
n:=2^(1/2);n:=evalf(n);n^2;
Obviamente, o pequeno erro na resposta final, denominado erro de arredondamento, ocorreu
porque 2 foi truncado a partir do décimo dígito. Devemos notar que, neste caso especial, um programa de computação algébrica como Maple é capaz de lidar com casos como esse sem problemas:
n:=2^(1/2);n^2;restart:
O problema não poderá ser evitado, entretanto quando o número de entrada estiver na forma de algarismos flutuantes. O default para cálculos com algarismos flutuantes no Maple é dez dígitos, mas este valor pode ser modificado arbitrariamente, através do comando Digits. Vejamos outros exemplos onde a limitação do número de dÌgitos induz a erros.
Exemplo. Dado um polígono regular de lados com comprimento a inscrito em um círculo de raioR= 1, o comprimento L de um lado de outro polígono inscrito com o dobro de número de lados é
dado por L = 2K 4Ka2 . Seja Ln o comprimento do lado de um polígono regular inscrito de
de n lados, e Pn = n Ln o seu perímetro. Então o comprimento do cÌrculo deve ser dado por
PN := 2 π = limn/N
n Ln
Façamos alguns cálculos para estimar valores numéricos de π, com dez dígitos. Seu valor, a esta precisão, evalf π é
evalf(Pi);Se n = 6, é fácil mostrar que L6 = 1 e P6 = 6. Portanto,
O O
Como podemos ver acima, a partir de um certo valor de n o erro relativo atinge um valor miínimo,depois aumentando até o colapso total a partir da iteração 17. A razão para o colapso é evidente: um lado de um polígono de 393216 lados é tão pequeno que dez casas depois da vírgula não são suficientes para representá-lo.
O crescimento do erro a partir da iteração 10 ocorre devido à perda de precisão por truncamento (o número de dígitos significativos diminui).
Exemplo. Calculemos numericamente, com 10 dígitos, a derivada dey = ln x em alguns pontos. Sabemos do cálculo que o resultado exato é 1/x. Utilizando a definição de derivada,
ddx
y x = limh/0
ln xCh K ln xh
.
Teoricamente, quanto menor h, melhor é a aproximação de (2.1) para 1/x. Numericamente, no entanto, não é isso que acontece pois, a partir de certo ponto, a precisão do sistema não será mais suficiente para representar h. Isso pode visto através do seguinte cálculo numérico em Maple desta derivada em x = 2 para h cada vez menor
Digits := 8; yp := vector(10); h := .1; x := 2; for i to 10 do yp[i] := ypp(h) = evalf((ln(x+h)-ln(x))/h); h := (1/5)*h
OOOO OOOO
OOOO OOOO
OOOO OOOO
O O
O O
O O
O O
O O
OOOO OOOO
O O
O O
OOOO OOOO
OOOO OOOO
O O
OOOO OOOO
end do; evalm(yp);
Erros devido a arredondamento podem aparecer de uma forma mais sutil e inesperada, como aquela devido à inexistência de uma representação finita em binário para números que a possuem na forma decimal.
Exemplo. O número 0.1 na representação decimal não possui uma representação finita binária:convert(.1, binary, 27);
Assim, ao realizarmos uma soma numérica envolvendo 0.1 podemos esperar que ocorra um erro no resultado devido ao fato dela ser realizada no formato binário (truncado). Usando o comando evalhf do Maple, que faz avaliações numéricas com o sistema de ponto flutuante de hardware (binário) temos, por exemplo,
evalhf(.1+.1); evalf(.1+.1);Obviamente, quanto mais termos 0.1 forem adicionados maior será o erro. Note que o comando evalf comum do Maple não resulta em erro, pois utiliza o padrão de ponto flutuante de software de base decimal.
Exemplo. Façamos o seguinte somatório com uma precisão de 10 dígitos:
>i = 1
100000
xi
para diferentes valores de xi=0.111111. Para isso basta escrevermos o seguinte código :
Digits:=10:x:=0.1111111:S:=0:for i from 1 to 100000 doS:=S+xod:Sap:=S;Sreal:=x*100000;
Como em todos os exemplos anteriores, a discrepância pode ser sanada aumentando-se o número de dígitos. A razão para o erro é que no final do processo iterativo temos um número muito grande somado com outro pequeno. Num sistema numérico dois números antes de serem somadosdevem ser convertidos para a mesma potência de base. Por exemplo, com precisão de 10 dígitos:
10^6C0.1;
Erros por cancelamentos catastróficosConsideremos em Maple a expansão de ex em série de potências:
Digitsd 10 :s := x->Sum(x^n/factorial(n), n = 0 .. 40);
Notemos que esta fórmula é em geral boa para 0 < x. Por exemplo,evalf s 3 ; evalhf s3
No entanto, para certos números negativos temos uma catastrófica discrepância:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
evalf sK25 ; evalhf sK25
quando o resultado correto é Digitsd 19 :evalf exp K25
Uma explicação para tal este erro é o cancelamento catastrófico dos termos correspondentes a n = 24 e n = 25 em n = 24 e n = 25 em aritmética de ponto flutuante tanto binária quanto decimal. De fato, usando a aritmética racional doMaple temos corretamente:
(-25)^24/factorial(24)+(-25)^25/factorial(25);Por outro lado, "pequenos" problemas já surgem com a aritmética de ponto flutuante decimal do Maple:
Digitsd 19 :(-25.)^24./factorial(24.)+(-25.)^25./factorial(25.) ;
Quando as avaliações são feitas todas em ponto flutuante binário de hardware temos uma catástrofe:
evalhf(evalhf((-25)^24/factorial(24))-evalhf((-25)^25/factorial(25)));
Este problema pode ser resolvido em computação numérica usando o fato de que a expansão em série de Taylor para ex é estável para x positivo. Ou seja, para avaliar a expansão para x < 0 devemos fazer a expansão de ex e depois calcular o recíproco. Ou seja,
evalhf(1/evalhf(exp(25)));
Mal-condicionamento e instabilidadeNos exemplos anteriores os erros catastróficos podem sempre ser evitados por meio de alguma modificação do algoritmo. Em alguns problemas, no entanto, erros são inerentes, algoritmos podem ficar instáveis para certos valores de um dado parâmetro.
Exemplo: equação de Verhulst. A equação de Verhulst é um modelo simplificado de dinâmica de populações
xn = RC1 xnK1KR xnK12 .
No script de Maple a seguir realizamos 100 iterações, utilizando aritmética deponto flutuante de hardware, invocada através do comando HFloat.
restart :verh:=proc(R) local xf,Lr,Lf,Le2,n,xe,xe3,xe2,Rf,Le,i,pe,pe2; Digits := 100; xe[0] := HFloat(0.5); Rf := HFloat(R); Le := []; n := 100; for i to n do xe[i] := HFloat((HFloat(Rf+1.)-HFloat(Rf*xe[i-1] ))*HFloat(xe[i-1])); Le := [op(Le), [i, xe[i]]]; end do: with(plots);
OOOO OOOO OOOO OOOO
pe : = poi nt pl ot ( Le, col or = bl ue, symbol = cr oss) ; display(pe);end:
O resultado é muito dependente do parâmetro R:verh 1.8verh 2.8
Quando R > 2.57, este sistema exibe comportamento caótico. Em tal situação o sistema é, por si mesmo, caótico, de modo que não há como reestruturar o problema utilizando aritmética de ponto flutuante de hardware.
Exercícios1. Reproduza a planilha em Maple para cálculo de π através de um código.2. Utilize Scilab ou Maple e reproduza a seguinte tabela para o processo iterativo de Verhulst (2.3), gerada em Java 1 Utilize Maple com 40 dígitos para reproduzir os resultados corretos. it. (R+1)x-R(xx) R+1)x-(Rx)x ((R+1)-(Rx))x x + R(x-xx) correto 0: 0.5000000000 0.5000000000 0.5000000000 0.5000000000 0.5000000000 10: 0.3846309658 0.3846309658 0.3846309658 0.3846309658 0.3846309658 20: 0.4188950250 0.4188950250 0.4188950250 0.4188950250 0.4188950250 30: 0.0463994725 0.0463994756 0.0463994787 0.0463994775 0.0463994768 40: 0.3201767255 0.3201840912 0.3201915468 0.3201885159 0.3201870617 50: 0.0675670955 0.0637469566 0.0599878799 0.0615028942 0.0622361944 60: 0.0011449576 0.2711150754 1.0005313342 1.2945078734 0.0049027225 70: 1.2967745569 1.3284619999 1.3296922488 0.1410079704 0.5530823827 80: 0.5530384607 0.8171627721 0.0219521770 0.0184394043 0.1196398067 90: 0.0948523432 0.1541841695 0.0483069438 1.2513933889 0.3109290854100: 0.0000671271 0.1194574394 1.2564956763 1.0428230334 0.7428865400
3. O Fracasso dos mísseis Patriot
Durante a primeira guerra do golfo pérsico, o sistema de mísseis Patriot fracassou (como foi admitido somente muito mais tarde), na defesa de Israel e Arábia Saudita dos foguetes SCUD iraquianos. O evento mais dramático para o exército norte-americano ocorreu em 25 de fevereiro de 1991 quando Patriots foram incapazes de impedir que um Scud caísse sobre uma barraca, matando 26 soldados em Dharan, Arábia Suadita. A causa para a ineficácia era que o software realizava cálculos com uma base de tempo de 1/10 s, que não possui representação finita binária. O problema foi piorado pelo fato do sistema de ponto flutuante usar somente 24 bits. De fato, a bateria de Patriots em Dahran esteve ligada por 100h aproximadamente. Note que 1/10 em representação binária é igual a 0.0001100110011001100110011001100.... Os 24 bits do Patriot armazenavam somente 0.00011001100110011001100, introduzindo um erro binário de 0.0000000000000000000000011001100, ou seja, 0.000000095 decimal. Em 100 horas isso implica num erro de 0.34s. Um Scud tipicamente viaja a 1676m/s. Ou seja, neste tempo um Scud viaja mais do que meio quilômetro, uma distância grande o suficiente para deixá-lo fora do raio dedetecção do Patriot. De fato, uma operação contínua de mais de 20h implicava já em um alvo fora do alcance do míssil.
Exercício Reproduza os resultados apresentados na tabela abaixo:
Effect of Extended Run Time on Patriot Operation
OOOO OOOO OOOO OOOO
Hours Seconds Calculated Time Inaccuracy Approximate Shift in Range Gate (seconds) (seconds) (meters)
0 0 0 0 0
1 3600 3599.9966 .0034 7 8 28800 28799.9725 .0025 55
20(a) 72000 71999.9313 .0687 137
48 172800 172799.8352 .1648 330
72 259200 259199.7528 .2472 494
100(b) 360000 359999.6667 .3433 687
a. Continuous operation exceeding about 20 hours--target outside range gateb. Alpha Battery ran continuously for about 100 hours
4. Resolva os problemas 16, 17 e 18 (Exercícios 1.3) do livro de Burden-Faires, Análise Numérica, 8 ed. página 36.
Métodos Iterativos para Soluções de Equações Algébricas não-Lineares
IntroduçãoConsideraremos aqui métodos para resolver equações algébricas não-lineares f x = 0. Em partitular, determinaremos métodos interativos para determinar os valores x que satisfazem a equação, possivelmente dentro de um erro pré-determinado. Denominamos este problema como o da determinação da raiz ou zero de f x .
A existência e unicidade de soluções de equações não-lineares é frequentemente difícil de determinar, havendo uma enorme variedade de comportamentos possíveis. Além disso, uma equação não-linear possui um número de raízes que pode ir de zero a infinito.
Consideremos, por exemplo, a função não-linearf x = x2
K4 sin xCertamente um zero desta função é x = 0. No entanto, outros possíveis zeros desta função não podem ser determinados exatamente. Há vários modos de ao menos estimar o número de zeros. No entanto, um dos mais simples é através de um gráfico:
f d x2K4 sin x :
plot f, x =K1 ..2.3
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Como limx/GN f x =CN
vemos que, além de x = 0 há uma única outra raiz, que deve estar próxima a 1.8 ou 1.9. Para tentardeterminar esta raiz com maior acurácia, poderíamos fazer outro gráfico numa região mais próxima a este valor. Por exemplo:
plot f, x = 1.7 ..2Aqui já vemos que a solução deve ser próxima a 1.93.
f d sin x Kcos x$$2plot f, x = 4 ..6
A equação a seguir possui raízes múltiplas (6):
P6d expand 1Kx 6
plot P6 , x = 0.995 ..1.005
Exercício: Use gráficos e argumentos heurísticos para mostrar que (i) ex
C1 = 0 não tem solução real.(ii) eKx
Kx = 0 tem uma solução real.(iii) x2
K9 x2Kx3
K4 sin x =0 tem três soluções reais.(iv) 8 x3
K4$x2K3 xC2 = 0 tem uma solução real.
(v) sin x Kcos x2 = 0 tem 5 soluções no intervalo [0..4] e 6 soluções no intervalo [4..6].
Obviamente tal processo gráfico, embora útil para estimativas iniciais em técnicas que estudaremos mais adiante, não é eficiente para a determinação da raiz com uma acurácia de 18 dígitos.
Uma função não-linear f x pode ter múltiplas raízes, onde f x = 0 e f ' x = 0. Isso signica que acurva tem uma tangente horizontal no eixo x. Se f x = 0 e f ' x s0, então diz-se que x tem umaraiz simples.
Mal condicionamento
Suponhamos que xap é uma solução aproximada de uma equação não-linear f x = 0. Isso
significa que f xap z 0 ou xapKxt z0 ,
onde xt é a verdadeira solução. A primeira relação corresponde ao fato de termos um pequeno
resíduo, enquanto que a segunda dá uma medida da proximidade da solução verdadeira (desconhecida). Tais critérios não são simultaneamente pequenos. Isso é ilustrado na Fig. 1, onde ambas as funções têm a mesma incerteza nos seus valores, mas muito diferentes valores para as respectivas localizações de suas raízes. O gráfico em azul representa uma função associada a uma equação bem condicionada. O gráfico em cor preta representa uma função associada a uma equação mal condicionada.
2. 2. 1. 1.
• •
x2,5 3 3,5 4
K0,10
K0,05
0
0,05
0,10
Fig. 1 Condicionamento
O condicionamento de um problema de determinação de raiz para uma dada função é o oposto do problema de avaliação da função: se o valor da função é insensitivo ao valor do argumento então araiz será sensitiva. Por outro lado, se o valor da função é sensitivo ao argumento, então a raiz é insensitiva. Esta propriedade faz sentido, pois os dois problemas são inversos um do outro: se y = f x , então encontrar x, dado y é tem o condicionamento oposto ao do problema de encontrary, dado x.
Geração dos Gráficos
Convergência de métodos iterativosAo contrário do que acontece com equações lineares, a maior parte da equações não-lineares não pode ser resolvida en número finito de passos. Portanto, usualmente devemos recorrer a um método iterativo que produz soluções mais acuradas a cada passo, a ser terminado quando a acurácia desejada for alcançada.
O custo computacional total da resolução do problema depende do:Custo por iteração.Número de iterações necessárias para a convergência.
Frequentemente há um "trade-off" entre esses dois fatores. Para comparar a efetividade dos métodos iterativos necessitamos caracterizar suas taxas de convergência. Definimos o erro ek numa iteração por
ek = xkKx) ,
onde xk é a solução aproximada na iteração k e x) é a solução verdadeira. Métodos iterativos para
equações não-lineares não produzem diretamente uma solução aproximada xk, mas sim um
intervalo que contém a solução, sendo que o comprimento deste intervalo diminui a cada iteração.Para tais métodos tomamos ek como sendo o comprimento deste intervalo na iteração k. Um
método iterativo é dito convergente com taxa r se
limk/N
ekC1
ekr = C ,
onde C é uma constante finita, não nula. Alguns casos de interesse são: Se r = 1 e C! 1, a taxa de convergência é linear.
• • • •
Se r O 1, a taxa de convergências é superlinear.Se r = 2, a taxa de convergência é quadrática.
Um modo de interpretar a distinção entre convergêncial linear e superlinear é que, assintoticamente, uma sequência que converge linearmente ganha um número constante de dígitosacurados por iteração, enquanto que uma sequência que converge superlinearmente ganha um número sempre maior de dígitos de acurados a cada iteração. Em particular, um método quadraticamente convergente dobra o número de dígitos de acurácia a cada iteração.
BissecçãoNa aritmética de precisão finita pode não haver um número de ponto flutuante x tal que f x seja exatamente zero. Uma alternativa é buscar um por um pequeno intervalo a, b no qual f tem uma mudança de sinal, de modo que garantidamente a correspondente função contínua deve ser zero em algum ponto deste intervalo.
Um intervalo para o qual o sinal de f difere nos seus extremos é chamado um bracket. O método da bissecção começa com bracket inicial e sucessivamente reduz seu tamanho até que uma solução tenha sido isolada com a acurácia desejada. A cada iteração a função é avaliada no ponto médio do intervalo corrente, e metade do intervalo é descartada, dependendo do sinal da função no ponto médio. Mais formalmente, o pseudocódigo é o seguinte:
while ((b-a)>tol) do c=a+(b-a)/2 if sign(f(a))=sign(f(c)) then a=c else b=c endend
O fluxograma do algoritmo é dado abaixo: (Shaharuddin Salleh, Albert Y. Zomaya, Sakhinah Abu Bakar. Computing for numerical methods using Visual c++, John Wiley & Sons, Inc., 2008):
A evolução do processo é ilustrada na figura abaixo ( ibid.):
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO OOOO OOOO
Exemplo Tentemos encontrar a menor raiz positiva da equação x2K4$sin x2
C2 = 0
SoluçãoUma análise gráfica preliminar é útil para a determinação do intervalo inicial:
restart :
f d x2K4$sin x2
C2 :plot f, x = 0.7 ..1
Vemos do gráfico que a menor raiz positiva está, por exemplo, no intervalo 0.7, 1. Implementaremos o pseudocódigo em Maple da seguinte forma:
Gd unapply f, xf(3);G(3.);Digits := 11;a:=0.7: b:=1.: i:=0:tol:=10^(-10):while abs((b-a))>tol do m:=(a+b)/2.; if sign(G(a))=sign(G(m)) then a:=m; else
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
b: =m; fi:i:=i+1od:
m, iPortanto, com precisão de 11 dígitos decimais, 32 iterações foram necessárias.
Transformemos o loop anterior num procedimento que tem como entradas uma expressão, o intervalo e a tolerância. A saída é a solução da equação e o número de iterações.
bis1:=proc(f,a,b,tol) local i,G,m,af,bf: i := 0: af:=evalf(a): bf:=evalf(b): G:=unapply(f,x): while abs(bf-af) > tol do m := (af+bf)/2.; if sign(G(af)) = sign(G(m)) then af := m else bf := m end if; i := i+1 end do: return([m,i]);end:
Para testar o procedimento resolvamos o mesmo problema novamente. Digitsd 11 :bis1(f,0.7,1,10^(-10));
O pseudocódigo a seguir implementa o algoritmo de bissecção na forma de um procedimento, de tal forma que o processo de convergência pode ser acompanhado. A entrada consiste na função, intervalo, número máximo de iterações e tolerância de erro.
procedure Bisseccao(f,a,b,nmax,tol) integer n, nmax; real a,b,c, fa, fb, fc, error fa )))) f a fb )))) f b fa )))) f a if sign(fa) = sign(fb) then output a,b, f a , f b output "funcao tem os mesmos sinais em a e b" return end if error ← bKKKK a for n = 0 to nmax do error )))) erro/2 c )))) a + error fc )))) f c output n, c, fc error if error !!!! tol then
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
output "convergencia" return end if if sign(fa) ssss sign(fc) then b )))) c fb )))) fc end if end doend procedure Bisseccao
Temos no algoritmo acima três critérios de parada. Uma implentação deste procedimento no Maple é a seguinte:
bis2 := proc (f, a, b, nmax, tol) local af, bf, F,c, erro,n; af := evalf(a); bf := evalf(b); F := unapply(f, x); if sign(F(af)) = sign(F(bf)) then printf(" a = %11.9f, b = %11.9f, F(a) = %11.9f , F(b) =%11.9f \n", a, b, F(af), F(bf)); error "Função tem os mesmos sinais em a e b. T ente novamente" end if ; erro:=bf-af: for n from 1 to nmax do erro:=erro/2.; c:=af+erro; printf(" n = %2.0f, c = %13.19f, f(c) = %13.9 f, erro =%13.9f \n", n, c, F(c), erro); #dados em ponto flu tuante, com 7 dígitos. if abs(erro)<tol then print(`Convergência foi alcançada`); break; end if; if sign(F(af))<> sign(F(c)) then bf:=c else af:=c fi: end do:end :
Exemplo: Façamos um teste para este procedimento, para encontrar a primeira raiz positiva da equação
x4K4 sin x K3 = 0.
Façamos um gráfico para ter uma idéia da localização da raiz:
f d x4K4$sin x C2
plot f, x =K2 ..2A primeira raiz positiva está entre 0 e 1, próxima a 0.5. Aplicando nosso procedimento temos:
bis2(f, 0, 1, 40, 10^(-9));A segunda raiz está em
bis2 f, 1, 1.5, 40, 10^K9 ;Resolvendo o mesmo problema com o procedimento bis1, temos
L1d bis1 f, 0, 1, 10^K9 ; L2d bis1 f, 1, 1.5, 10^K9
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
R1d L1 1 ; R2d L2 1O método da bissecção não faz uso das magnitudes dos valores das funções, mas somente dos seus sinais. Como resultado, a bissecção converge com certeza, mas o faz de forma lenta. Mais especificamente, a cada iteração o comprimento do intervalo contendo a solução (e consequentemente o erro) é reduzido pela metade. Isso significa que o método da bissecção é linearmente convergente, com r = 1 e C = 0.5.
Notemos ainda que dado um intervalo inicial a, b , o comprimento do intervalo após k iterações é
bKa
2k ,
Se um erro de tolerância for prescrito é possível determinar o número de passos necessários no método da bissecção. Suponha que desejamos x)Kck ! ε. Então devemos ter um número k de
iterações tal que
x)Kck %bKa
2k% ε
O número de iterações necessário para que o erro esteja dentro dentro do intervalo de tolerância ε é
kR log2bKa
εiterações, independente de f. No presente caso, de fato,
log 21.
10^ K9
Exemplo: Determinemos o número de iterações necessárias para resolver a equação para resolver
f x = x3C4 x2
K10 = 0com uma tolerância de 10K3, supondo a = 1 e b = 2.
f := x^3+4*x^2-10;
plot f, x =K3.5 ..2.5Necessitamos então um número de iterações
kR log2bKa
ε= log2
2K1
10K3
evalf log22K1
10K3
Portanto, 10 iterações garantirão uma aproximação com erro que não ultrapassa 10K3. De fato,
bis1 f, 1, 2, 10K3
bis2 f, 1, 2, 13, 10K3
Vejamos como o problema converge com uma precisão maior e menor tolerância:Digitsd 19 :
bis1 f, 1, 2, 10K18
Podemos comparar este resultado com o exato:evalf solve f, x
O dígito incorreto no processo iterativo é marcado a seguir:1.3652300134140968451.365230013414096846
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
Notemos que limitante inferior para o número de iterações k no método da bissecção não significa que a convergência possa ser alcançada muito antes.
Exemplo: Consideremos novamente o problema de buscar a raiz positiva de x3K0.165 x2
C0.000003993 = 0Digitsd 19 :
f d x3K0.165 x2
C0.000003993;
plot f, x =K0.02 ..0.02bis1 f, 0, 0.01, 10^K19 ;evalf solve f= 0, x
Os dígitos incorretos estão marcados abaixo:0.0049955536726590942640.004995553672659094289
Notemos que uma escolha diferente de intervalo pode mudar um pouco o resultado: bis1 f, 0.0049, 0.1, 10^K19 ;
0.004995553672659094312Equações com raízes múltiplas não podem ser resolvidas por este método. Por exemplo:
f d 1Kx 3
plot f, x = 0.6 ..1.4
Vantagens do método de bissecção
(i) O método é sempre convergente, podendo ser usado como um iniciador para métodos de maioracurácia.(ii) Como os intervalos contendo a raiz são reduzidos à metade a cada iteração, podemos predizer o erro na solução.
Desvantagens do método de bissecção
(i) A convergência é lenta (linear), pois a cada passo o intervalo contendo a raiz é somente reduzido à metade. (ii) O método não funciona para a determinar raízes múltiplas
Exercícios: Resolva todos os problemas ou todos os problemas ímpares (Exercícios 2.1) de Burden-Faires, Análise Numérica, 8 ed. páginas 51 e 52.
Métodos de ponto fixo Vamos considerar aqui o problema de determinar os valores de x tal que f x = 0, onde f x é uma função não-linear, bem comportada no intervalo a, b . Seja
g x = xCc x f x ,
onde c x s 0 em a, b . Então o problema de determinar os valores x = β, tais que f β = 0, é equivalente ao de encontrar valores de x para os quais β = g β .
O método iterativo consiste em partir de uma solução aproximada e determinar as outras
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
O O
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
aproximações por
xi C1 = g xi
De acordo com as diferentes escolhas para g x temos diferentes métodos de ponto fixo.
A convergência do processo iterativo no intervalo [a,b] é garantida se ddx
g x ! 1, em [a,b].
Além disso, pode-se mostrar que neste caso há somente um x = β neste intervalo tal que g β = β.
Se fizermos c x = 1 temos o chamado método da iteração linear. Neste caso, dada a função f x devemos escolher um g x tal que
g x = xCf x . Normalmente temos diversas escolhas possíveis para g x .
Exemplo. Determinemos as raízes reais de f x = x3
K5 xC3.
Façamos um gráfico para obter a localização aproximada das raízes:restart;f := x^3-5*x+2;plot(f, x = -3 .. 3);
Algumas possíveis escolhas de g x para formar as relações de iteração xi C1 = g xi
são obtidas isolando x de f x = 0 de diferentes formas:
(i) g x =x3C25
,
(ii) g x = 5 xK2
13 ,
(iii) g x =5 xK2
x2
Tomemos a escolha (i) de g x para tentar encontrar a raiz negativa que está no intervalo K3,K2 . Analisemos a condição suficiente para convergência neste intevalo, g' x !1:
g := (x^3+2)*(1/5);gp := abs(diff(f, x));plot(gp, x = -3 .. -2);
Este gráfico mostra que a convergência não é garantida. De fato:
gf := unapply(g,x);
r[1] := -3;for i to 7 do r[i+1] := evalf(gf(r[i]));end do;
Esta divergência pode ser ilustrada graficamente:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
path dddd NULL : for i from 1 to 7 do path dddd path, r i , r i CCCC 1 , r i CCCC 1 , r i CCCC1 ;end do:plot g x , x, path , x = KKKK10 ..2, y = KKKK10 ..6, color = red, green,
blue ;
No intervalo 0.5, 1, que contém a primeira raiz positiva, temos plot gp, x = 0 ..0.5
de modo que a convergência não é garantida. No intervalo 1.5, 2.5, que contém a segunda raiz positiva, temos
plot gp, x = 1.5 ..2.5e a convergência também não é garantida. Notemos, no entanto, o gráfico da iterações sugere que talvez a convergência para a primeira raiz positiva seja possível:
r[1] := -1; for i to 12 do r[i+1] := evalf(gf(r[i])) end do;
Ilustremos graficamente esta convergência:path := NULL; for i to 7 do path := path, [r[i], r[i+1]], [r[i+1], r[i+1]] end do; plot([g(x), x, [path]], x = -1.3 .. 2.2, y = -.5 .. 2.2, color = [red, green, blue]);
A convergência para esta mesma raiz também ocorre se partirmos de de x = 1, por exemplo:r 1 d 1; for i to 12 do r i C1 d evalf gf r i ; end do;path d NULL : for i from 1 to 7 do path d path, r i , r i C1 , r i C1 , r i C1 ;end do:plot g x , x, path , x =K1.3 ..2.2,y =K0.2 ..2.2,color = red, green, blue ;
Este mesmo gráfico, no entanto, sugere divergência se escolhermos x = 2.5: r 1 d 2.5; for i to 6 do r i C1 d evalf gf r i ; end do;
path d NULL : for i from 1 to 6 do path d path, r i , r i C1 , r i C1 , r i C1 ;end do:plot g x , x, path , x = 1.5 ..10,y =K0.2 ..12,color = red, green, blue ;
Utilizemos neste intervalo, a escolha (iii) para g x :
g x =5 xK2
x2
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
g d5 xK2
x2
gfd unapply g, x :gpd abs diff g, x
Analisemos a convergência no intervalo 1.9, 4: plot gp, x = 1.9 ..4
Portanto, a convergência é assegurada se partirmos de x = 3, por exemplo. De fato,
r 1 d 3; for i to 30 do r i C1 d evalf gf r i ; end do;
Notamos que a convergência é lenta. Uma explicação para este fato pode ser obtido do gráfico de interações:
path d NULL : for i from 1 to 12 do path d path, r i , r i C1 , r i C1 , r i C1 ;end do:plot g x , x, path , x = 1.5 ..3.5,y =K0.2 ..3,color = red, green, blue ;
Vemos aqui a convergência oscilante.
Exemplo. Determinar as raízes reais de f x = 5 sin x Kex
pelo método da iteração linear .Façamos um gráfico para ter noção da localização das raízes:
restart :f := 5*sin(x)-exp(x);plot(f, x = 0 .. 2);
Busquemos inicialmente a raiz contida no intervalo 0, 0.5 . Isolando x da função exponencial temos
ex = 5 sin x , x = ln 5 sin x .
O processo iterativo é, então, xi C1 = g xi = ln 5 sin xi
g d ln 5$sin xgfd unapply g, x
Analisemos a convergência no intervalo 0.1, 0.5:gpd abs diff g, xplot gp, x = 0.1 ..0.5
Ou seja, a convergência não é garantida neste caso. De fato,r 1 d 0.1; for i to 7 do r i C1 d evalf gf r i ; end do;
No intervalo que contém a segunda raiz positiva, 1.5, 1, 8 , por exemplo, temosplot gp, x = 1.5 ..1.8
A convergência é garantida. De fato,
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
r 1 d 1.8; for i to 8 do r i C1 d evalf gf r i ; end do;
Num gráfico de iterações,path d NULL : for i from 1 to 12 do path d path, r i , r i C1 , r i C1 , r i C1 ;end do:plot g x , x, path , x = 1.4 ..2,y = 1.5 ..1.7,color = red, green, blue ;
Exemplo. Determinar os zeros de
g d arctanexp x
5Transformemos a expressão numa função:
gfd unapply g, xAnalisemos a convergência no intervalo 0.1, 0.5:
gpd abs diff g, xplot gp, x = 0.1 ..0.5
A convergência é portanto garantida no intervalo 0.1, 0.5 , pois aí gp !1. De fato,
r 1 d 0.11; for i to 16 do r i C1 d evalf gf r i ; end do;path d NULL : for i from 1 to 10 do path d path, r i , r i C1 , r i C1 , r i C1 ;end do:plot g x , x, path , x = 0.1 ..0.3,y = 0.1 ..0.3,color = red, green, blue ;
Exercícios1. Utilizando o método da iteração linear, encontre todas as raízes reais de(i) f x = x5
Kx2K5 x K1,
(ii) f x = x2Ctan x KxC1
Faça a análise de convergência e ilustre graficamente a convergência.
Método de Newton-RaphsonOs métodos de ponto fixo consistem em definir um g x tal que
g x = xCc x f x ,
tal que x = g x é equivalente a f x = 0. O processo iterativo é então xi C1 = g xi .
Veremos agora que o método de Newton é um caso particular de método de iteração fixa, onde c x tem uma forma que otimiza o processo de convergência.
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Suponhamos que x) é uma raiz de f x . Como g' x = 1Cc' x f x Cc x f ' x ,
temosg' x) = 1Cc x) f ' x) .
A convergência mais rápida possível ocorre quando g' x) = 0, ou seja, quando escolhemos
c x) =K1
f ' x).
Como x) não é conhecido vamos definir
c x =K1
f ' x ,
de modo que
g x = x K f xf ' x
.
O processo iterativo é então
xi C1 = xiKf x i
f ' xi
Este é o chamado método da iteração de Newton ou Newton-Raphson.
Exemplo. Busquemos as raízes reais def x = xKsin x C2
restart;f := x-> 4*x^5-3*x^3-3*x^2-5*x+3 ;plot(f(x), x = -1.5 .. 1.5);Df := D(f);
Busquemos a raiz negativa. O processo iterativo pode agora ser implementado da seguinte forma:Digits := 40;it := x-> evalf(x-f(x)/Df(x)); x1 := -1.5; for i to 8 do x1 := it(x1) end do;
As outras raízes são dadas porit := x-> evalf(x-f(x)/Df(x)); x2 := .3; for i to 8 do x2 := it(x2) end do;it := x-> evalf(x-f(x)/Df(x)); x3 := 1.1; for i to 10 do x3 := it(x3) end do;
Portanto, as raízes são x1, x2, x3;
Definamos agora um procedimento que tem como entrada, a função, um ponto inicial e o número de iterações.
restart;Digits := 20;
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
newt on : = pr oc ( g, x0, N) local it, i, Dg, x; Dg := D(g); it := x-> evalf(x-g(x)/Dg(x)); x := x0; for i to N do x := it(x) end do; x end pr oc;
Exemplo. Determinemos as raízes reais de f x = exp x K1.5Karctan x .
f := exp(x)-1.5-arctan(x);plot(f, x = -1 .. 1.5);
Usando nosso procedimento, temosF := unapply(f, x);newton(F, .5, 10);
Procedimento Recursivo
Uma outra maneira de implementar o processo de Newton-Raphson é através de um procedimentorecursivo
x := proc (n) option remember; global f, x0; if n <= 0 then x0 else x(n-1)-f(x(n-1))/(D(f))(x(n-1)) end if end proc:
Por exemplo, vamos encontrar a primeira raiz positiva de f x = x sin x K ln x . f := x-> x*sin(x)-ln(x);plot(f(x), x = 1 .. 3);
O ponto inicial pode ser x = 2.5. x0 := 2.5;
Com 6 iterações,x(6);
Para ver a sequência de pontos gerados, seq(x(n), n = 0 .. 6);
ExercíciosNos exercícios 1 a 3 encontre todas raízes reais das equações abaixo, usando o método de Newton-Raphson, com tolerância de 10K8 . Determine também os pontos críticos (extremos relativos) no intervalo K4, 4 :1. f x = arctanx Ksin x C12. f x = sin x2
C1 CxK13. f x = x5
K4 x4C3 x3
Kx2CxK1
4. Verifique se o método de Newton-Raphson funciona para o caso de raízes múltiplas.
Polinômios e raízes complexasEmbora não tenhamos estudado a teoria dos processos iterativos para a obtenção de raízes complexas, o método de Newton é capaz de encontrar todas as raízes de um polinômio, reais e complexas.
Consideremos um polinômio de grau n, escrito na seguinte forma
OOOO OOOO OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
Pn x := a0Ca1 xCa2 x2 + . . . + an x
n . ans 0.
Então é possível mostrar que os zeros de Pn
x estão localizados, no plano complexo, dentro de
uma região circular definida por
x %1Cmaxak
an , 1% k , k% n.
Exemplo. Determinemos todas as raízes complexas do polinômioP x = 4 x4
K3 x3Cx2
K5 xK8.f d x/4 x^4K3 x^3Cx^2K5 xK8;
Inicialmente faremos um procedimento para coletar os coeficientes do polinômio:n:=degree(f(x));c[0]:=f(0);for k from 1 to n do c[k]:=coeff(f(x),x^k);
od; As raízes devem estar dentro de círculo, no plano complexo, de raio r, dado por
r0 := 1+max(seq(c[i]/c[n], i = 0 .. n-1));Podemos resumir estes comandos em um procedimento:
Raio := proc (f) local n, c, k, r0; n := degree(f(x)); c[0] := f(0); for k to n do c[k] := coeff(f(x), x^k) end do; r0 := 1+max(seq(c[i]/c[n], i = 0 .. n-1)) ; eval(r0) end proc;
Raio(f);Geramos ângulos aleatórios
r := rand(0 .. 1);theta := rand(0 .. 24);
N := 0;while N<degree(f(x)) doL:=[]:for m to 30 do R[m]:=(r()*(cos(theta())+I*sin(theta()))): x[m]:=newton(f,R[m],20): if abs(Im(x[m]))<10^(-30) then x[m]:=Re(x[m]) fi; if not evalf[5](x[m]) in evalf[5](L) then L:=[op(L),x[m]]; fi; od: N:=nops(L); od:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
op( L) ;O mesmo resultado pode ser obtido através do comando fsolve do Maple:
printlevel:=1:fsolve(f(x),x,complex);
Vamos agora fazer um procedimento que plota as raízes de um polinômio no plano complexo:raizplot:=proc(p::polynom(constant,x)) local R, points; R:=[fsolve(p,x,complex)]; points:=map(z->[Re(z),Im(z)],R); plot(points,style=point,symbol=circle);end:
Usando o comando randpoly gera um polinômio randômico temosy:=randpoly(x,degree=24);yf:=unapply(y,x);RR:=Raio(yf);with(plots):g1:=raizplot(y): g2:=polarplot([RR],t=0..2*Pi):display([g1,g2]);
1. A partir dos comandos definidos para obter as raízes de um polinômio, construa um procedimento que determina todas as raízes de um polinômio e as plota no plano complexo. .2. Utilize o método de Newton-Raphson para encontrar as 5 primeiras raízes reais positivas de f := x7 sin x K3 x2 .3. Determine todas as raízes de f = 47 x12
K16 x11C38 x6
K53 x4K42 x2
K37 x +9 e plote-as no plano complexo.
Método da SecanteEsta introdução é baseada em Peter Stone. Neste método devemos partir de duas aproximações x0 e x1 para uma raiz de f x = 0. Sejam y0 = f x0 e y1 = f x1 . Podemos considerar a linha que
junta os pontos (x0, y0) e (x1, y1) como uma aproximação linear para a função f x próximo a x0 e
x1, como mostra a figura abaixo:
OOOO OOOO OOOO OOOO
OOOO OOOO OOOO OOOO
y = f(x)
(x ,y )
(x ,y )
x
x
x
0 0
1 1
0
1
2
Esta reta tem equação
yKy1 =y0Ky1
x0Kx1 xKx1 .
Ela encontra o eixo x no ponto
x2 = x1Kx0Kx1
y0Ky1 y1
Podemos tomar o valor x2 como uma nova aproximação para a raiz r .
O processo pode então ser repetido com x2 e x1 substituindo x1 e x0 respectivamente.
A fórmula de iteração é dada por:
xnC1 = xnKxnK1Kxn
f xnK1 K f xn f xn ,
O procedimento secap use pode ser usado para um passo do método da secante:restart;secap := proc(a,b) local fa,fb; fa := f(a); fb := f(b); evalf(b - fb*(a - b)/(fa - fb));end proc:
Testemos este procedimento para determinar 2 : f := x-> x^2-2;plot(f(x), x = -1 .. 2);
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Tomemos dois pontos quaisquer próximos à raiz: a := 0.; b := 1.;c := secap(a, b);
Renomeamos a e b e repetimos o processo:a := b;b := c;
Portanto,c := secap(a, b);
Automatizaremos o processo daqui para frente:while abs(b-c) > 10^(-7) do a := b; b := c; c := secap(a, b) end do;
De fato, sqrt(2.);
Construiremos agora um procedimento que toma como entrada uma expressão algébrica, dois pontos iniciais, tolerância e número máximo de iterações.
Secante:= proc(expr::algebraic,x,x1,x2,Delta,it) local x3,nit,delta,f,x1t,x2t, xdg3,g3,f3,x_2,x_1, dg3; f:=unapply(expr,x); nit:=0: delta:=1: dg3:=f(x2t)-f(x1t): g3:=(x1t*f(x2t)-x2t*f(x1t))/dg3: f3:=unapply (g3,x1t,x2t); x_2:=x2: x_1:=x1: while nit < it and delta > Delta do x3:=f3(x_1,x_2); x_1:=x_2: x_2:=x3: nit:=nit+1: delta:=abs(x_2-x_1); od; print(x_2);end:
Apliquemos o método da secante ao problema de encontrar as raízes reais de f x = x5
K3 x4C5 x3
C7 x2KxC2 .
f := x^5-3*x^4+5*x^3+7*x^2-x+2;plot(f, x = -2 .. 2);Digits := 19;Secante(f, x, -1.5, -.5, 10^(-8), 10);
O processo iterativo da secante está implementado na biblioteca Student do Maple: with(Student[NumericalAnalysis]):f := x^2-2;Secant(f, x = [1, 8], tolerance = 10^(-7));Secant(f, x = [1.1, 8], tolerance = 10^(-7), output = sequence);
O processo pode visualizado geometricamente:Secant(f, x = [0, 1], tolerance = 10^(-3), output = plot);
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
Iniciando o processo com o intervalo K1, 2 , temosSecant(f, x = [-1, 2], tolerance = 10^(-3), output = plot);
Suponhamos que agora queremos que o critério de parada seja f xk ! ε
Secant(f(x), x = [-1, 2], tolerance = 10^(-8), stoppingcriterion = function_value);
O processo iterativo abaixo está animado:Secant(f, x = [-1, 2], output = animation, stoppingcriterion = function_value);
Exercícios
Nos exercícios 1 a 3 encontre todas raízes reais das equações abaixo, usando o método da secante,com tolerância de 10K8 . Determine também os pontos críticos (extremos relativos) no intervalo K4, 4 :
1. f x = arctanx Ksin x C12. f x = sin x2
C1 CxK13. f x = x5
K4 x4C3 x3
Kx2CxK1
4. Verifique se o método da secante funciona para o caso de raízes múltiplas.5. Verifique a diferença de tempo para os métodos de Newton-Raphson e secante. Por exemplo,
comparamos o tempo para a determinação de 53
usnado o método da secante e o comando fsolve do Maple:
g := x^3-5;Digits := 19;st := time();Secante(g, x, 1., 2., 10^(-9), 20);time() - st;st := time();fsolve(g, x = 1 .. 2);time()-st;
Métodos Diretos para Sistemas de Equações Lineares
Eliminação de Gauss Simples
Consideremos o sistema linear de equações algébricas.
xCyCz= 3
3 xC2 yC3 z= 2
2 xC4 yC5 z=K1
Um modo de resolver este sistema é fazer simplificações sucessivas até que ele possa ser resolvido por retrosubstituição. Qualquer sistema linear pode sofrer as seguintes operações, sem que sua solução seja alterada:
1. Multiplicação de qualquer equação por um número diferente de zero;2. Soma de equações;3. Troca da ordem das equações;4. Troca da ordem das variáveis.
Estas operações, chamadas de operações elementares, podem ser mais sistematicamente implementadas através da representação matricial. O sistema pode ser reescrito como A X = B, onde
A =
1 1 1
3 K2 2
2 4 5
, B =
3
2
K1
, X =
x
y
z
,
ou seja,
1 1 1
3 K2 2
2 4 5
x
y
z
=
3
2
K1
.
Para evitar ter que escrever a matriz de variáveis X a cada passo, definimos a matriz aumentada:
Au = A B =
1 1 1 3
3 K2 2 2
2 4 5 K1
.
O método de eliminação de Gauss consiste em usar as operações elementares sobre linhas para reduzir a matriz aumentada a uma forma triangular superior. Ou seja, começamos eliminando os elementos abaixo do primeiro elemento da linha 1. O primeiro elemento de cada linha é chamado de pivot. Uma vez realizado este passo, o procedimento se repete, agora zerando os elementos abaixo do pivot da segunda linha, e assim por diante, até a forma escalonada ser alcançada. Usemos este procedimento no nosso exemplo:
1. A linha 2 é somada à linha 1 vezes (-3):
Au1=
1 1 1 3
0 K5 K1 K7
2 4 5 K1
,
2. A linha 3 é somada à linha 1 vezes (-2):
Au2=
1 1 1 3
0 K5 K1 K7
0 2 3 K7
,
3. A linha linha 2 é somada à linha 1 vezes (2/5):
Au3=
1 1 1 3
0 K5 K1 K7
0 0135
K495
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
O sistema agora pode ser resolvido por retrosubstituição. A última linha implica:135
z=K495
, ou seja, z=K4913
.
Da segunda linha,
K5 yK 1 z=K7, y = 15
7Kz = 15
7C4913
=2813
.
Da primeira linha temos:
xCyCz= 3, x = 3KyKz= 3K2813
C4913
=6013
Portanto, a solução do sistema de equações é x =6013
, y =2813
, z=K4913
.
Repetiremos os passos acima utilizando comandos do Maple, utilizando o comandoRowOperation da biblioteca LinearAlgebra. A sintaxe do comando é evidente:
restart:with(LinearAlgebra):with(ArrayTools):A:=Matrix([[1,1,1],[3,-2,2],[2,4,5]]);B:=Vector([3,2,-1]);Au:=Concatenate(2,A,B);Au1:=RowOperation(Au,[2,1],-3);Au2:=RowOperation(Au1,[3,1],-2);Au3:=RowOperation(Au2,[3,2],2/5);
Podemos agora usar um comando de retrosubstituição:X:=BackwardSubstitute(Au3);X1:=evalf(%);
A matriz reduzida à forma que a diagonal da matriz de coeficientes é toda forma de 1 é chamadaforma echelon:
Au4:=RowOperation(Au3,3,5/13);Au5:=RowOperation(Au4,2,-1/5);evalf(%);
O procedimento abaixo fará a tarefa de triangularizar uma matriz aumentada qualquer automaticamente:
ngausst:=proc(A) local j,i,k,n,m; n:=RowDimension(A); for k to n-1 do #Loop sobre colunas for i from k+1 to n do # Loop sobre linhas m:=evalf(-A[i,k]/A[k,k]);# Multiplicadores da coluna k for j from k+1 to n+1 do # Atualiza os el ementos da linha i A[i,j]:=evalf(A[i,j]+m*A[k,j]); od; A[i,k]:=0: od; od; A;end:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
ngausst:=proc(A)
Testemos o procedimentoAts:=ngausst(Au);
O passo seguinte consiste em construir um procedimento que realize a retrosubstituição:retro:=proc(A) #entrada deve ser uma matriz triangu lar superior local n,x,s,j,i; n:=RowDimension(A); x:=Vector(n); x[n]:=evalf(A[n,n+1]/A[n,n]); for i from n-1 to 1 by -1 do s:=A[i,n+1]; for j from i+1 to n do s:=evalf(s-A[i,j]*x[j]); od; x[i]:=evalf(s/A[i,i]); od; x;end:
retro:=proc(A)
Testemos este procedimento na matriz triangular superior calculada anteriormente:X2:=retro(Ats);
O seguinte procedimento concatena a matriz de coeficientes com a matriz da parte não-homogênea:
gauss1:=proc(A,B) local Au,Auf; Au:=<A|B>; retro(ngausst(Au));end:
gauss1:=proc(A,B)
Por exemplo,X3:=gauss1(A,B);
Testemos este procedimento numa matriz grande aleatória:n:=100:N:=34.1:A:=RandomMatrix(n, n, generator = 0 .. N):B:=RandomMatrix(n, 1, generator = 0 .. N):
Aproveitamos para medir o tempo de CPU na execução do comando: tempoCPUi:=time():
X1:=gauss1(A,B);
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
t empoCPU: =( t i me( ) - t empoCPUi ) * seconds;Para mostrar o resultado na tela teríamos que aumentar o rtablesize: interface(rtablesize=200):
Através de comandos automáticos do Maple podemos resolver este sistema do seguinte modotempoCPUi:=time():At:=GaussianElimination(<A|B>);X2:=BackwardSubstitute(At);tempoCPU:=(time()-tempoCPUi)*seconds;
A solução pode também ser gerada pelo comando LinearSolve:tempoCPUi:=time():X3:=LinearSolve(A,B);tempoCPU:=(time()-tempoCPUi)*seconds;
Os cálculos acima foram feitos com precisão de 19 dígitos decimais, embora somente 10 sejam apresentados.
Exercícios
1. Resolva passo a passo, utilizando eliminação de Gauss, o sistema AX= B onde
A =
2 7 9 5
K1 21 8 K4
7 8 1 9
K4 7 9 1
e B =
1
5
1
0
.
Compare com o resultado fornecido pelo comando do Maple LinearSolve.
2. Construa uma variante dos procedimentos gauss1 (e consequentemente ngausst e retro) de modo que o resultado seja racional.Aplique o resultado ao sistema AX= B onde
A:=Matrix([[1/3,451/234,43/65],[3/7,13/5,56/3],[3/6 5,-8/47,5/31]]);B:=Vector([1/3,5/7,-4/5]);
e compare com resultado computado em floats, tanto em tempo de execução, quanto em acurácia.
3. Considere o sistema
A =
1.545 1.543 1.432 1.542
1.453 1.476 1.512 1.432
1.453 1.433 1.491 1.545
1.454 1.534 1.435 1.511
e B =
1.464
1.462
1.463
1.460
.
Resolva este sistema das seguintes formas:(i) Passo a passo, usando eliminação de Gauss, com 4 dígitos significativos.(ii) Usando os algoritmos construídos nesta seção, com 4 dígitos significativos e com 18 dígitos significativos.(iii) Racionalize a matriz (por exemplo, 1.545 = 1545/100, etc.) e resolva exatamente (em forma racional), usandos os comandos GaussianElimination e BackwardSubstitute. Converta o resultadopara float, usando 4 dígitos significativos e compare com (ii).
4. Considere um sistema linear da forma HX= B onde H é uma matriz de Hilbert definida por
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
n: =10:H:=Matrix(n,n,(i,j) ->1/(i+j)):
e B é B:=Vector(n,i->1/i):
Matrizes de Hilbert implicam em sistemas lineares mal-condicionados, ou seja, sistemas onde pequenas alterações nos coeficientes geram grandes mudanças nas soluções. (a) Obtenha a resposta exata (racional) do problema, usando o procedimento construído no Problema 1. (b) Resolva o problema com aritmética de ponto flutuando do Maple, usando 10 e 20 dígitos de precisão. (c) Compare os resultados obtidos em (a) e (b) calculando a norma (infinita) do resíduo e da diferença entre as soluções.
Pivotação ParcialVamos agora mostrar algumas limitações da eliminação da Gauss simples, vista na seção anterior.
1. Pivot nulo
Exemplo 1. Consideremos o sistema linear AX= B onde
with(LinearAlgebra):A:=Matrix([[0,3,5,5,7],[3,1,2,4,6],[0,0,6,8,2],[2,0 ,6,7,1],[3,6,0,0,3]]);B:=Vector([1,2,3,4,5]):
A aplicação do procedimento a este sistema resulta em ngausst(<A|B>);
Isso é esperado, pois o primeiro elemento é zero, de modo que o multiplicador tem um divisor porzero. Tal problema pode ser corrigido se fizermos uma troca de linhas:
A1:=RowOperation(A,[1,5]);R1:=ngausst(<A1|B>);
A solução é então dada por X2:=BackwardSubstitute(R1);
Outro problema que pode surgir no algoritmo de eliminação de Gauss simples está relacionado com erros associados a somas de números com magnitudes muito diferentes.
Exemplo. Consideremos o sistema AX= Y com
restart:with(LinearAlgebra):
ngausst:=proc(A)
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
retro:=proc(A)
gauss1:=proc(A,B)
Digits:=18:A:=Matrix([[3.4521*10^(-17),342.4233,54.3333],[34.4 25,411.7829,4.7829],[345.5243,432.6253,6.3425]]);B:=Vector([23.4363,56.7833,2.5439]);Au:=<A|B>;
Usando o procedimento de Gauss simples obtemos: Au1:=ngausst(<A|B>);
A solução é entãoretro(Au1);
A redução de Gauss obtida usando o comando do Maple é Au2:=GaussianElimination(<A|B>);
A diferença entre as duas matrizes eliminadas é, emparte devido a um fatores de escala multiplicativos (que não afetam a solução). Mas fora isso há outras diferenças, que se manifestam na solução:
BackwardSubstitute(Au2);Note que usamos o procedimento ngausst1 com precisão de 19 dígitos decimais, para que a comparação com a cálculo com em sistema de ponto flutuante de hardware, com presisão estendida (mantissa de 64 bits ≈ 18, 19 dígitos decimais) fosse justa.
Vejamos o que ocorre com nosso resultado se trocarmos a primeira pela segunda linha em nossa matriz original:
Au3:=RowOperation(Au,[1,2]);Au4:=ngausst(Au3);retro(Au4);
Ou seja, através de uma troca de linhas obtivemos o resultado correto com grande aproximação. Para entender o que aconteceu, voltemos ao caso original, com
A :=
3.452100000000000000 10-17 342.4233 54.3333
34.425 411.7829 4.7829
345.5243 432.6253 6.3425
Notemos que os multiplicadores que irão anular os elementos da primeira coluna, a partir da segunda linha, são de magnitude muito grande: :
m12:=-Au[2,1]/Au[1,1];Au1:=RowOperation(Au,[2,1],m12);m13:=-Au[3,1]/Au[1,1];Au2:=RowOperation(Au1,[3,1],m13):Au2[3,1]:=0:Au2;
Por exemplo, consideremos o cálculo do elemento Au2[2,2]:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
m12$ Au1 2, 2 =K9.972190840358042930 1017 C 34.425-9.972190840358042930E17+34.425;
Este c·lculo foi realizado da seguinte forma-9.972 190 840 358 042 930 E17 + 0.000 000 000 000 000 0 34425E17Como a precisão de casas decimais é de 18 dígitos, o últimos três dígitos são perdidos e 34.425 passa a ser aproximado por 34. De fato, todas as seguintes somas dão mesmo resultado:
-9.972190840358042930E17 + 0.00000000000000034425E1 7;-9.972190840358042930E17 + 0.00000000000000034E17;-9.972190840358042930E17 + 34.425;-9.972190840358042930E17 + 34.4;-9.972190840358042930E17 + 34;
As considerações anteriores sugerem que para evitar divisões por zero ou a geração de multiplicadores execessivamente grandes, devemos tentar trocar linhas de modo a obter os menores multiplicadores em cada estágio. Este processo é denominado pivotação
O algoritmo de pivotação mais geral procura pelo maior elemento em valor absoluto entre as componentes à direita e abaixo da posição do pivot e então as trocas apropriadas de linhas e colunas são efetuadas de modo a trazer este elemento à posição de pivot. Na prática, a pivotação parcial utilizando trocas de linhas é normalmente usada.
Devemos modificar o procedimento gauss1 de modo que ele procure pelo maior elemento em valor absoluto, sobre ou abaixo da posição do pivot.
Inicialmente vamos escrever um procedimento que faz somente a pivotação parcial de colunas, sem a redução de linhas. Em seguida, tal procedimento será incorporado a outro de eliminação de Gauss.
piv:=proc(Aa) local n, k, p, i, temp, m, j, x; n := RowDimension(Aa); x := Vector(n); for k from 1 to n-1 do #loop sobre colunas p:=k; for i from k+1 to n do #percorre os elementos da coluna k if (abs(Aa[i,k]) > abs(Aa[p,k])) then p:=i; fi; #omaior elemento da coluna tem sue índice de linha ar mazenadoem p od; if Aa[p,k]=0 then ERROR(`Matriz é singular`); fi; if (p<>k) then # troca linhas k e p for j from 1 to n+1 do temp:=Aa[k,j]; Aa[k,j] := Aa[p,j]; Aa[p,j] := temp; od; fi; od; Aa;end:
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
pi v: =pr oc( Aa) local n, k, p, i, temp, m, j, x; n := RowDimension(Aa); x := Vector(n); for k from 1 to n-1 do #loop sobre colunas p:=k; for i from k+1 to n do #percorre os elementos da coluna k if (abs(Aa[i,k]) > abs(Aa[p,k])) then p:=i; fi; #o maior elemento da coluna tem sue indice de linha armazena do em p od; if Aa[p,k]=0 then ERROR(`Matriz é singular`); fi; if (p<>k) then # troca linhas k e p for j from 1 to n+1 do temp:=Aa[k,j]; Aa[k,j] := Aa[p,j]; Aa[ p, j ] : = t emp;
Exemplo. Consideremos o sistema:A:=Matrix([[1,-1,2,-1, -1],[1,-2,3,-1/2,-1],[8,2,1, 0,1],[1,3,1,3,6],[2,4,-2,1,2]]):B:=Vector([-8,-20,-2,4,2]):Au:=<A|B>;piv(Au);
Note que a pivotação é feita somente até a coluna nK1 e sempre com elementos abaixo da diagonal para baixo, ou seja cada nova pivotação é incapaz de arruinar a anterior.
Vamos agora inserir o código anterior para que ele faça a pivotação para cada loop sobre colunas. Obviamente ele tem que ser inserido dentro do loop inicial sobre colunas. O procedimento de retrosubstituição já está incluído.
gauss2:=proc(A,Y) local n, k, p, i, temp, m, j, x, s,Aa; Aa:=<A|B>; n := RowDimension(Aa); x := Vector(n); for k from 1 to n-1 do p:=k; for i from k+1 to n do if (abs(Aa[i,k]) > abs(Aa[p,k])) then p:=i; fi; od; if Aa[p,k]=0 then ERROR(`Matriz é singular`); fi; if (p<>k) then # troca linhas k e p for j from 1 to n+1 do temp:=Aa[k,j]; Aa[k,j] := Aa[p,j]; Aa[p,j] := temp; od; fi; for i from k+1 to n do m := Aa[i,k]/Aa[k,k]; for j from 1 to n+1 do
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Aa[ i , j ] : = Aa[ i , j ] - m* Aa[ k, j ] ; od; od; od; x[n] := Aa[n,n+1] / Aa[n,n]; for i from n-1 to 1 by -1 do s := Aa[i,n+1]; for j from i+1 to n do s := s - Aa[i,j]*x[j]; od; x[i] := s/Aa[i,i]; od; x;end:
gauss2:=proc(A,Y)
Exemplo. Consideremos um problema envolvendo pivot pequeno:Digits:=10:A:=Matrix([[0.0000034521,342.4233,54.3333],[34332.4 25,4311.7829,4.7829],[342125.5243,432.6253,6.3425]]);B:=Vector([1,2,3]);gauss1(A,B);
gauss2(A,B);LinearSolve(A,B);
A diferença dos resultados, com ou sem pivotação, com precisão de 10 dígitos, é considerável.
Exemplo. Vejamos perfomance do nosso código com um sistema grande.nn:=90:N:=34.1:A:=RandomMatrix(nn, nn, generator = 0 .. N):B:=RandomMatrix(nn, 1, generator = 0 .. N):tempoCPUi:=time():gauss2(A,B);tempoCPU:=(time()-tempoCPUi)*seconds;
O procedimento que não realiza pivotação é mais rápido:tempoCPUi:=time():gauss1(A,B);tempoCPU:=(time()-tempoCPUi)*seconds;
O comando LinearSolve gera a solução:tempoCPUi:=time():LinearSolve(A,B);tempoCPU:=(time()-tempoCPUi)*seconds;
O procedimento abaixo, escrito por Peter Stone, realiza a eliminação de Gauss com pivotação parcial, descrevendo as operações realizadas a cada passo:
restart:with(LinearAlgebra):
OOOO OOOO
OOOO OOOO
GaussElimination := proc(AA,ra
Por xemplo, A := <<0.91,3.3,-1.3>|<5.3,-2.3,1.4>|<1.2,4.1,1.7>> ;B := <1,1,1>;Au := <A|B>;
J := GaussElimination(Au,info=true);
Pivotação por escala em Matlab
function x = gaussPiv(A,b)% Solves A*x = b by Gauss elimination with row pivoting.% USAGE: x = gaussPiv(A,b)if size(b,2) > 1; b = b’; endn = length(b); s = zeros(n,1);%----------Set up scale factor array----------for i = 1:n; s(i) = max(abs(A(i,1:n))); end%---------Exchange rows if necessary----------for k = 1:n-1[Amax,p] = max(abs(A(k:n,k))./s(k:n));p = p + k - 1;if Amax < eps; error(’Matrix is singular’); endif p ˜= kb = swapRows(b,k,p);s = swapRows(s,k,p);A = swapRows(A,k,p);end%--------------Elimination pass---------------for i = k+1:nif A(i,k) ˜= 0lambda = A(i,k)/A(k,k);A(i,k+1:n) = A(i,k+1:n) - lambda*A(k,k+1:n);b(i) = b(i) - lambda*b(k);endendend%------------Back substitution phase----------for k = n:-1:1b(k) = (b(k) - A(k,k+1:n)*b(k+1:n))/A(k,k);endx = b;
Exercícios
Resolva, passo a passo, utilizando pivotação parcial, os sistemas de equações abaixo, utilizando três dígitos significativos. Compare com a solução obtida através da racionalização do sistema.
1. 3.9 xC0.013 y = 35.2
K6.32 xC5.43 y = 34.5
2.
0.01 xC2 yCz= 15
3 xC2 yC3 z= 6.3
5 xC4.4 yC5 z= 46
3. Compare os resultados passo a passo dos problemas 1 e 2 com o resultado da aplicação do procedimento GaussElimination de Peter Stone
4. Resolva o sistema AX= B, passo a passo usando eliminação de Gauss simples e eliminação de Gauss com pivotação parcial
A :=
0.0000033455 69.383 45.231
5.3400 7.3402 3.4543
32.345 3.2345 31.456
, Bd
58.222
32.554
12.563
.
Use precisão de 8 dígitos significativos.
5. Resolva o sistema do problema 4 de forma automática (usando os procedimentos construídos anteriormente), sem e com pivotação parcial, com 8 dígitos de precisão. Verfique o resultado usando racionalização, usando os procedimentos do Maple GaussianElimination e BackwardSubstitute e o procedimento de Peter Stone.
6. Resolva o sistema usando eliminação de Gauss
Sistemas mal condicionadosSeja um sistema linear AX = B e sejam os autovalores X1 e X2 duas aproximações da solução exata
Xe. O modo mais natural para decidir qual a melhor aproximação seria calcular os resíduos:
R1 = BKA X1 e R2 = YKA X2 . Veremos a seguir que este não é necessariamente o caso.
Exemplo 1 Consideremos o seguinte sistema linear AX= B:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO wi t h( Li near Al gebr a) :A:=Matrix([[0.24,0.36,0.12],[0.12,0.16,0.24],[0.15, 0.21,0.25]]);B:=Vector([0.84,0.52,0.64]);
Consideremos agora dois candidatos a solução deste sistema:X1:=Vector([25,-14,-1]);X2:=Vector([-3,4,0.7]);
Os resíduos sãoR1:=A.X1-B;R2:=A.X2-B;
Seria natural pensar que a solução X1 é a melhor aproximação, pois seu resíduo é menor. No
entanto, a solução exata Xe é
Ar:=map(convert, (A,rational));Br:=map(convert, (B,rational));Ar2:=GaussianElimination(<Ar|Br>);Xe:=BackwardSubstitute(Ar2);
Portanto, a solução mais próxima da verdadeira é X2, apesar do seu resíduo ser maior.
Exemplo 2 Outro comportamento peculiar deste sistema refere-se a pequenas perturbações. Consideremos, por exemplo, uma pequena perturbação na matriz B:
Bp:=Br+Vector([0,0,1/100]);A solução do sistema agora é:
ABp:=GaussianElimination(<Ar|Bp>);Xp:=BackwardSubstitute(ABp);evalf(%);
A solução acima é a exata. Note o quanto ela mudou devido a uma pequena perturbação. Esta é uma típica característica de sistemas mal condicionados.
Matrizes de Hilbert, definidas por
Hij =1
i C j Ks ,
onde s é indeterminado (número ou variável), estão associadas a sistemas mal-condicionados.
Exemplo 3 Tomemos s= 1: restart:with(LinearAlgebra):
f := (i, j) -> 1/(i+j-1) :H10:=Matrix(20, f);B:=Vector(20,1);Au:=<H10|B>;
Inicialmente resolvamos o sistema com aritmética de ponto flutuante:Auf:=evalf(Au);
H102:=GaussianElimination(Auf);interface(rtablesize=200):X1:=BackwardSubstitute(H102);
Calculemos o resíduo:R1:= H10.X1-B;
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Ou, usando a norma infinito,Norm(R1,infinity);
Resolvamos agora os sistema exatamente, usando aritmética racionalH103:=GaussianElimination(Au):X2:=BackwardSubstitute(H103);
O resíduo agora é zero, por construção:R2:= Norm(H10.X2-B, infinity);
Vejamos a real diferença entre as soluções: X2-X1;
ouDX:=Norm(X2-X1,infinity);
Ou seja, a solução obtida com aritmética de ponto flutuante é desastrosamente errada.
Exercícios1. Considere uma matriz de Hilbert 60 x 60. Resolva um sistema envolvendo tal tipo de matriz dasseguintes formas: (i) Utilizando aritmética racional exata, utilizando os procedimentos GaussianElimination e BackwarSubstitute e LinearSolve Calcule o tempo de CPU.(ii) Idem, Utilizando aritmética de ponto flutuante do Maple, com precisão de 18 dígitos. (iii) Determine a precisão necessária de modo que a a norma do vetor diferença dos resultados nãotenha ordem de magnitude menor que 10 E-8. Use GaussianElimination e BackwarSubstitute e LinearSolve. Calcule o tempo de CPU
Sistemas Tridiagonais
Construção de uma matriz tridiagonalEm várias oportunidades no cálculo numérico, como na solução numérica de equações diferenciais, o processo de discretização resulta numa matriz grande esparsa, com elementos não-nulos concentrados em torno da diagonal. Uma classe de matrizes deste tipo é a chamada matriz banda ou tridiagonal. Sua forma geral é dada abaixo:
A =
d1 c1 0 . . . 0 0
a2 d2 c2 . . . 0 0
0 a3 d3 . . . 0 0
. . . . . .
0 0 . . . anK1 dnK1 cnK1
0 0 0 . . . an dn
,
As componentes [c1 . . . cnK1] constituem a super-diagonal. As componentes [a2 . . . an] a sub-diagonal e [d1 . . . dn] a diagonal principal. Um esquema gráfico é dado abaixo ( Peter Stone)
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
p1:=plot([[[.2,0],[0,0],[0,10]
Exemplo1 Vamos construir uma matriz tridiagonal de ordem 6 onde a diagonal principal tem elementos 1, 2,...n e as outras diagonais com componentes 1. Usaremos os comandos do pacote LinearAlgebra.
with(LinearAlgebra):n := 6:
Definimos uma matriz nula de ordem n: A := Matrix(n):
Definimos as componentes não nulas: for i from 1 to n-1 do A[i,i+1] := 1; A[i,i] := i; A[i+1,i] := 1;end do:A[n,n] := n:A;
Outro modo de executar essa mesma tarefa consiste em definir as três diagonais como listas e utilizá-las no procedimento do pacote LinearAlgebra chamado BandMatrix:
superdiag:=[seq (1, i=1..n-1)];subdiag:=superdiag;maindiag:=[seq(i,i=1..n)];BandMatrix([subdiag,maindiag,superdiag]);
Exemplo 2Vamos definir uma matriz tridiagonal de ordem 5 onde todos os elementos são números inteiros aleatórios entre -10 e 10, inclusive.
restart:with(LinearAlgebra):n:=5:A:=Matrix(n): randomize():r:=rand(-10..10):for i from 1 to n-1 do A[i,i+1] := r(); A[i,i] := r(); A[i+1,i] := r();end do:A[n,n]:=r():A;
Utilizando BandMatrix , definimos as listas de diagonais:randomize():maindiag := [seq(r(),k=1..n)];
superdiag:=[seq(r(),k=1..n-1)];subdiag:=[seq(r(),k=1..n-1)];BandMatrix([subdiag,maindiag,superdiag]);
Compactação de Matrizes TridiagonaisVamos definir agora a forma compacta de uma matriz tridiagonal, pois seria um desperdício
• •
OOOO OOOO
OOOO OOOO OOOO OOOO
• •
• •
alocar espaço de memória para componentes nulas de uma matriz. No final apresentaremos um procedimento que realiza sua expansão. A forma compacta é definida da seguinte forma:
Todas as componentes não-nulas de uma matriz tridiagonal n # n A são representadas em uma matriz B de dimensões 3 # n
As componentes da super-diagonal de A são colocadas na primeira coluna of B.
As componentes da digonal principal de A são colocadas na segunda coluna of B.
As componentes da sub-diagonal de A são colocadas na terceira coluna ofB.
Por exemplo, a matriz tridiagonal
A =
K10 K21 0 0 0 0
9 K17 K23 0 0 0
0 K23 K11 K21 0 0
0 0 25 13 K8 0
0 0 0 4 21 K18
0 0 0 0 K9 K19
pode ser convertida na matriz
B =
K21 K23 K21 K8 K18 0
K10 K17 K11 13 21 K19
0 9 K23 25 4 K9
.
Como a sub e superdiagonais têm uma componente a menos que a diagonal principal, ainda temoscomponentes nulas na forma compacta.
Vamos agora construir o procedimento Tridiagonal, que expande uma matriz tridiagonal a partir de sua forma compacta.
restart:with(LinearAlgebra):Tridiagonal := proc(A::Matrix) local m,n,T,i,j; if not type(A,'Matrix') then error "Argumento deve ser uma matriz" end if; m :=RowDimension(A); if m<>3 then error "Matriz deve ter 3 linhas" end if; n := ColumnDimension(A); if n<3 then error "Matriz deve ter ao menos 3 colunas" end if; T := Matrix(n); T[1,1] := A[2,1]; T[1,2] := A[1,1];
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
f or j f r om 2 t o n- 1 do T[j,j-1] := A[3,j]; T[j,j] := A[2,j]; T[j,j+1] := A[1,j]; end do; T[n,n-1] := A[3,n]; T[n,n] := A[2,n]; T;end proc:
Tridiagonal := proc(A::Matrix)
Por exemplo, se B é uma matriz diagonal na forma compacta: B := Matrix([[21,-32,-21,-8,-28,0],[10,-12,31,3,21, 32], [0,31,53,2,4,-79]]);
Tridiagonal(B);Vamos agora construir uma matriz tridiagonal compacta de ordem 6, onde a diagonal principal tem elementos 1, 2,..,n e as outras diagonais com componentes 1. Em seguida faremos a expansão.
n := 6:
C := Matrix(3,n):for i from 1 to n do C[1,i] := 1; C[2,i] := i; C[3,i] := 1;end do:C;
Tridiagonal(C);
Solução de um Sistema Tridiagonal
Um sistema linear envolvendo uma matriz de coeficientes que é tridiagonal pode ser dada atravésde 4 listas, três correspondentes é diagonal, e uma ao termo não-homogêneo. Sejam superdiag superdiag:= c1, ..., cnK1 , subdiag:= a2, ..., an , maindiag:= d1, ..., dn , e nonhom:= b1,
..., bn . Podemos então resolver o sistema por um método mais simples do que o de
eliminação e retrosubstituição já vistos:restart:with(LinearAlgebra):Tridiagsolve:=proc(A,bb) local j,n,k,x,a,c,d,b; b:=bb:
n:=nops(b); x:=Vector(n); a:=Row(A,3); d:=Row(A,2); c:=Row(A,1); for k to n-1 do d[k+1]:=d[k+1]-a[k+1]*c[k]/d[k];
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
b[ k+1] : =b[ k+1] - a[ k+1] * b[ k] / d[ k] ; end do; x[n]:=b[n]/d[n]: for j from n-1 to 1 by -1 do x[j]:=(b[j]-c[j]*x[j+1])/d[j]; end do: evalf(x);
end proc:
Tridiagsolve:=proc(A,bb)
Exemplo 3Por exemplo, tomemos o sistema AX= B com, A dada em forma compacta:
A := Matrix([[21,-32,-21,-8,-28,0],[10,-12,31,3,21, 32], [0,31,53,2,4,-79]]);
B:=[2,3,5,-3,2,1];
A solução é dada por Tridiagsolve(A,B);
Exercícios
1. Aplique o procedimento Tridiagsolve a um sistema envolvendo uma matriz de coeficientes tridiagonal 100 × 100, onde os coeficientes são números aleatórios entre -1000 e 1000, inclusive.
2. Compare o desempenho no paroblema anterior, no que se refere a tempo de CPU, deTridiagsolve com os procedimentos gauss2, GaussianElimination+BackwardSubstitution eLinearSolve do pacote LinearAlgebra. Antes de fazer as comparaes, defina as matrizes em ponto flutuante ou modifique gauss2 e Triagsolve para fazer a conversão a floats em cada cálculo.
Fatoração LU
1. Introdução
É possível mostrar que qualquer matriz quadrada A pode ser expressa com um produto de uma matriz triangular inferior L e uma matriz triangular superior U:
A = LU,com
L =
l11 0 0 ... 0
l21 l22 0 0 0
l31 l32 l33 0 0
: : : : :
ln1 ln2 ln3 ... lnn
, U =
u11 u12 u13 ... u1n
0 u22 u23 ... u2n
0 0 u33 ... u3n
: : : : :
0 0 0 ... unn
.
1. 1.
2. 2.
3. 3.
O processo de computar L e U para uma dada matriz A é conhecido como decomposição LU ou fatoração LU. Esta decomposição não é única, a menos que certas restrições seja impostas a L ou U. Tais restrições distinguem os diferentes tipos de decomposições. As decomposições mais utilizadas são:
Decomposição de Doolitle: Lii = 1, i = 1, 2, ... , n
Decomposição de Crout: Uii = 1, i = 1, 2, ... , n
Decomposição de Choleski: L = UT
Podemos utilizar a fatoração LU para resolver um sistema linear. Dado um sistema AX= B podemos fatorar a matriz A como A = L U , de modo que dividimos o nosso problema AX= LUX= B em duas partes:
UX= Y, LY= B. Inicialmente, usando a segunda equação, determinamos Y através de retrosubstituição. Finalmente, usando a primeira equação, determinamos X usando novamente retrosubstituição.
A vantagem da decomposição LU sobre o método da eliminação gaussiana é que uma vez que a matriz A está decomposta, podemos resolver o sistema AX= B para diversos diferentes valores diferentes de B com grande facilidade. O custo de cada solução adicional é relativamente pequeno,pois as estapas de retrosubstituição são computacionalmente mais simples do que o processo de decomposição.
2. Decomposição de Doolittle e matrizes elementares de eliminação
Para entender o processo de determinação das matrizes L e U, consideremos uma matriz A 4#4:
A =
4 1 K1 3
6 3 K1 3
K2 K1 5 2
3 K9 2 7
Para criar zeros abaixo da diagonal na primeira coluna, devemos multiplicar A pela matriz de eliminação elementar:
M1 =
1 0 0 0
K14
6 1 0 0
K14
K2 0 1 0
K14
3 0 0 1
=
1 0 0 0
K32
1 0 0
12
0 1 0
K34
0 0 1
.
Ou seja,
OOOO OOOO OOOO OOOO
OOOO OOOO
A1 =M1 A =
1 0 0 0
K32
1 0 0
12
0 1 0
K34
0 0 1
4 1 K1 3
6 3 K1 3
K2 K1 5 2
3 K9 2 7
=
4 1 K1 3
032
12
K32
0 K12
92
72
0 K394
114
194
.
De fato, with(LinearAlgebra):A1:=Matrix([[1,0,0,0],[-3/(2),1,0,0],[1/(2),0,1,0], [-3/(4),0,0,1]]).Matrix([[4,1,-1,3],[6,3,-1,3],[-2,-1,5,2], [3,-9,2,7]]);
Devemos agora criar zeros abaixo da diagonal da segunda coluna. Isso pode ser feito através da matriz
M2 =
1 0 0 0
0 1 0 0
023
12
1 0
023
394
0 1
=
1 0 0 0
0 1 0 0
013
1 0
0132
0 1
,
de modo que
A2 = M2M1A =
1 0 0 0
0 1 0 0
013
1 0
0132
0 1
4 1 K1 3
032
12
K32
0 K12
92
72
0 K394
114
194
=
4 1 K1 3
032
12
K32
0 0143
3
0 0 6 K5
.
De fato,
A2:=Matrix([[1,0,0,0],[0,1,0,0],[0,1/(3),1,0],[0,(1 3)/(2),0,1]]).Matrix([[4,1,-1,3],[0,3/2,1/2,-3/2],[0,-1/2, 9/2,7/2],[0,-39/4,11/4,19/4]]);
Devemos, finalmente, criar um zero abaixo da diagonal da terceira coluna. Isso pode ser feito através da matriz
M3 =
1 0 0 0
0 1 0 0
0 0 K314
6 0
0 0 1 1
=
1 0 0 0
0 1 0 0
0 0 1 0
0 0 K97
1
.
De modo que ,
OOOO OOOO
OOOO OOOO
A3 = M3A2 = M3M2M1A =
1 0 0 0
0 1 0 0
0 0 1 0
0 0 K97
1
4 1 K1 3
032
12
K32
0 0143
3
0 0 6 K5
=
4 1 K1 3
032
12
K32
0 0143
3
0 0 0 K627
De fato,
A3:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3,1) = 0, (3, 2) = 0, (3, 3) = 1, (3, 4) = 0, (4, 1) = 0, (4,2) = 0, (4, 3) = -9/7, (4, 4) = 1}). Matrix(4, 4, { (1, 1) =4, (1, 2) = 1, (1, 3) = -1, (1, 4) = 3, (2, 1) = 0, (2, 2) = 3/2, (2, 3) = 1/2, (2, 4) = -3/2, (3, 1) = 0, (3, 2) = 0,(3, 3) = 14/3, (3, 4) = 3, (4, 1) = 0, (4, 2) = 0, (4, 3) =6, (4, 4) = -5});
Façamos um resumo dos cálculos acima e obtenhamos conclusões gerais. Dada uma matriz A podemos fazer a redução gaussiana à sua forma triangular superior aplicando matrizes elementares que aniquilam os elementos abaixo da diagonal nas colunas sucessivas. Inicilamente aplicamos uma matriz M1 para obter uma matriz A1 com zeros abaixo da diagonal na coluna 1:
A1 = M1 A.
Aplicando M2 a A1 obtemos a matriz A2 , com zeros abaixo da diagonal das colunas 1 e 2:
A2 = M2 A1 = M2 M1 A .
Repetindo o processo nK1 vezes obtemos finalmente uma matriz triangular superior U: U = AnK1 = MnK1$$$M2 M1 A = MA
com M = MnK1$$$M2 M1 .
Supondo A = LU = L MA = L MnK1$$$M2 M1 A,
temosL = MK1 = M1M2$$$MnK1 K1 = MnK1
K1$$$M 2
K1M1K1
O cálculo das inversas é simples e não necessita ser formalmente computado: somente o sinal das componentes diferentes de 1 é trocado. Além disso, a multiplicação matricial não precisa ser formalmente computada: o resultado é simplesmente a justaposição das colunas de MnK1
K1 , M 2K1, M1
K1 . Ou seja, a matriz L é tem colunas formadas pelo negativo das colunas não
elementares de MnK1, $$$, M2 , M1. Voltando ao nosso exemplo, construímos as matrizes M1, M2 ,
M3 dadas abaixo:
M1:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = -3/2, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) = 1/2, (3, 2) = 0, (3, 3) = 1, (3, 4) = 0, ( 4, 1) =
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
- 3/ 4, ( 4, 2) = 0, ( 4, 3) = 0, ( 4, 4) = 1} ) ;M2:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3,1) = 0, (3, 2) = 1/3, (3, 3) = 1, (3, 4) = 0, (4, 1 ) = 0, (4, 2) = 13/2, (4, 3) = 0, (4, 4) = 1});M3:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3,1) = 0, (3, 2) = 0, (3, 3) = 1, (3, 4) = 0, (4, 1) = 0, (4,2) = 0, (4, 3) = -9/7, (4, 4) = 1});
De acordo com o que foi explicado acima, podemos calcular a matriz diagonal inferior com componentes diagonais iguais a 1,
L = M1M1M2K1 = M1
K1M2
K1 M3K1,
simplesmente justapondo o negativo das colunas de
O produto também é facilmente obtido simplesmente justapondo o negativo colunas não elementares de M1, M2 e M3 :
L =
1 0 0 0
32
1 0 0
K12
K13
1 0
34
K132
97
1
Podemos verificar esta afirmação fazendo a computação direta: L:=(1/M1).(1/M2).(1/M3);
3 Automatizando a fatoração LU de Doolitle.
Resolvamos o problema do exemplo anterior de forma computacional: restart:with(LinearAlgebra):A:=Matrix(4,4,[4,1,-1,3,6,3,-1,3,-2,-1,5,2,3,-9,2,7 ]);L:=Matrix(4,4);for i to RowDimension(L) do L[i,i]:=1 od:L;
Coluna 1m:=-A[2,1]/A[1,1];L[2,1]:=-m:U:=RowOperation(A,[2,1],m);
m:=-U[3,1]/U[1,1];
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
L[ 3, 1] : =- m:U:=RowOperation(U,[3,1],m);m:=-U[4,1]/U[1,1];L[4,1]:=-m:U:=RowOperation(U,[4,1],m);
Coluna 2m:=-U[3,2]/U[2,2];L[3,2]:=-m:U:=RowOperation(U,[3,2],m);m:=-U[4,2]/U[2,2];L[4,2]:=-m:U:=RowOperation(U,[4,2],m);m:=-U[4,3]/U[3,3];
Coluna 3L[4,3]:=-m:U:=RowOperation(U,[4,3],m);
De fato, GaussianElimination(A);L;L.U;
4. Procedimento para o processo de fatoração LU de Doolittle:
Podemos automatizar o processo descrito na seção anterior através de um procedimento:
LUfator:=proc(A) local n,L, U,k,i,m,c,j,v; n:=RowDimension(A); L:=Matrix(n,n); U:=A; for c to n do L[c,c]:=1 od: for i to n do #loop para colunas for k from i+1 to n do #loop sobre linhas m:=-U[k,i]/U[i,i]; L[k,i]:=-m: U:=RowOperation(U,[k,i],m); od: od: for j from 1 to n do #força os elementos abaixo da diagonal serem zero for v from j+1 to n do U[v,j]:=0: od: od: return(L,U)end:
LUfator:=proc(A)
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Exemplo: with(LinearAlgebra):A:=Matrix([[-3,2,3,4],[5,6,7,8],[4,-3,2,1],[5,4,2,1 ]]);F:=LUfator(A);
Verifiquemos este resultado: F[1].F[2]-A;
ExemploResolver o sistema de equações AX= B com
nn:=9:N:=70:A:=RandomMatrix(nn, nn, generator = 0 .. N);B:=RandomMatrix(nn, 1, generator = 0 .. N);
Inicialmente façamos a fatoração LU da matriz A :
LUfator:=proc(A)
Devemos definir a matriz A com coeficientes em pontos flutuantes, caso contrário o cálculo será feito com aritmética racional.
Af:=evalf(A):LU:=LUfator(Af);L:=LU[1]:U:=LU[2]:
Resolvamos o sistema LY= B : LB:=<L|B>;
Y:=ForwardSubstitute(LB);Resolvamos agora o sistema UX= Y
UY:=<U|Y>:X:=BackwardSubstitute(UY);
De fato, evalf(LinearSolve(A,B));
5. Inversão de matrizes através de fatoração LU
O problema de inverter uma matriz A pode ser entendido como o problema de determinar os vetores coluna v1, v2, $$$, v3 tais que
A v 1 v 2 $$$ vn = e 1 e 2 $$$ en ,
sendo e1 , e2, $$$ , en os vetores que definem as colunas da matriz identidade de ordem n . Ou seja,
a matriz inversa AK1 é dada por AK1 = v 1 v 2 $$$ vn .
Aqui o uso da fatoração LU é Por exemplo, seja
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
A :=
4 1 K1 3
6 3 K1 3
K2 K1 5 2
3 K9 2 7
Entãowith(LinearAlgebra):A := Matrix(4, 4, {(1, 1) = 4, (1, 2) = 1, (1, 3) = -1, (1,4) = 3, (2, 1) = 6, (2, 2) = 3, (2, 3) = -1, (2, 4) = 3, (3, 1) = -2, (3, 2) = -1, (3, 3) = 5, (3, 4) = 2, ( 4, 1) = 3, (4, 2) = -9, (4, 3) = 2, (4, 4) = 7});Af:=evalf(A):LU:=LUfator(Af);L:=LU[1]:U:=LU[2]:e[1]:=<1,0,0,0>;e[2]:=<0,1,0,0>;e[3]:=<0,0,1,0>;e[4 ]:=<0,0,0,1>;
Resolvamos o sistema LYi = ei i = 1 ..4 :
for i to 4 do LB[i]:=<L|e[i]>;od;
Façamos agora a substituição avançada: for i to 4 do V[i]:=ForwardSubstitute(LB[i]);od;
Resolvamos agora o sistema UX= Yfor i to 4 do UY[i]:=<U|V[i]>: X[i]:=BackwardSubstitute(UY[i]);od;
A matriz inversa é então dada porAI:=<X[1]|X[2]|X[3]|X[4]>;
Podemos verificar que esta solução é verdadeira: evalf(AI-1/A);
6. Fatoração LU de Doolittle com os comandos do Maple
No Maple a fatoração LU pelo método de Doolittle é denominada fatoração LU pelo método de eliminação gaussiana (default). Mostremos num exemplo:
with(LinearAlgebra):A:=Matrix([[2,4,5],[1,5,3],[6,2,1]]);LU:=LUDecomposition(A, method = 'GaussianEliminatio n');
Notemos que a primeira matriz, chamada matriz de permutação, é simplesmente a identidade, poisnão foi necessário fazer nenhuma troca de linhas para evitar divisão por zero durante a eliminaçãogaussiana. Podemos verificar o resultado:
P:=LU[1];L:=LU[2];U:=LU[3];P.L.U;
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Quando uma troca de linhas é necessária, a matriz de permutação leva em tal troca. Por exemplo:
A := Matrix(4, 4, {(1, 1) = 0, (1, 2) = 1, (1, 3) = 1, (1, 4) = -3, (2, 1) = -2, (2, 2) = 3, (2, 3) = 1, (2, 4 ) = 4, (3, 1) = 0, (3, 2) = 0, (3, 3) = 0, (3, 4) = 1, (4, 1) = 3,(4, 2) = 1, (4, 3) = 0, (4, 4) = 0});LU:=LUDecomposition(A, method = 'GaussianEliminatio n');
de modo que P:=LU[1]:L:=LU[2]:U:=LU[3]:P.L.U;
Façamos o cálculo da inversa com comandos embutidos do Maple, usando o método LU de Doolittle:
Gd LUDecomposition A, method= GaussianElimination;AI2d MatrixInverse Gevalf(%);
6. Exercícios
1. Compare a eficiência dos códigos de fatoração LU (do tipo Doolitle, com L ii = 1) que você
desenvolveu com aqueles que embutidos do seu sistema. Sugestão: Contabilize o tempo necessário para resolver um sistema linear aleatório de ordem 100×100.
2. A vantagem da decomposição LU sobre o método da eliminação gaussiana é que uma vez que amatriz A está decomposta, podemos resolver o sistema AX= B para diversos diferentes valores de B com grande facilidade. O custo de cada solução adicional é relativamente pequeno, pois as estapas de retrosubstituição são computacionalmente mais simples do que o processo de decomposição. Ilustre este fato utilizando:
(a) Dez diferentes sistemas lineares de equações de sua escolha com matriz de coeficientes de ordem 8×8. Contabilize o tempo necessário para realizar este cálculo utilizando eliminação gaussiana e fatoração LU (do tipo Doolitle:, com L ii = 1). Utilize os códigos que você
desenvolveu.
(b) Dez diferentes sistemas lineares de equações aleatórios, com matriz de coeficientes de ordem 200×200. Contabilize o tempo necessário para realizar este cálculo utilizando eliminação gaussiana e fatoração LU (do tipo Doolitle:, com L ii = 1). Utilize os códigos previamente
implementados (embutidos) no seu sistema.
3. Faça a inversão de uma matriz aleatória 300×300 utilizando fatoração LU de Doolittle. Compare com diferentes métodos.
Métodos Iterativos para Sistemas de Equações Lineares
Método de Jacobi
Descrição do Método
Definição do Processo IterativoSeja o sistema linear da forma AX= Y . A aproximação ou valor aproximado de uma solução x do sistema linear é um vetor (matriz coluna) que difere muito pouco do valor x. Podemos escrever o sistema linear na forma
>j = 1
n
aij xj = yi
ou
>j = 1
n
aij xj +aii xi = yi, i s j , i = 1 .. n .
Portanto,
xi =
yiK >j = 1
n
ai j xj
aii , i = 1 .. n .
O processo iterativo de Jacobi é definido da seguinte forma:
xikC1 =
yiK >j = 1
n
ai, j xjk
aii
Ou seja, dado um Xi inicial calculamos Xi C1 iterativamente. Se o sistema é não singular será sempre possível obter aii s0, trocando linhas.
Critério de Parada O processo iterativo é repetido até que Xi esteja suficientemente próximo de Xi C1. Um critério muito utilizado consiste em medir a medir a distância entre duas aproximações consecutivas, ouerro, da seguinte forma:
dk = max xikKxi
kC1 , i = 1 ..n
Tal operação pode ser realizada no Maple através do comando norm, que dá a norma infinito de um vetor ou matriz.Portanto, uma vez especificada a acuracidade ε desejada da solução as iterações continuam até que
dk! ε.
Podemos também estabelecer o critério de parada através do erro relativo drk:
drk =
dk
max xik
, i = 1 ..n
Em geral agregamos a este critério um número máximo de iterações.
Critério de convergênciaUma condição suficiente para a convergência do método de Jacobi é a seguinte:Critério das linhas: Seja
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
αk =>j = 1
n akj
akk , i s j.
Se α = max αk < 1, k = 1 ..n, o método de Jacobi gera uma sequência convergente para a solução
do sistema linear dado, independente da escolha da aproximação inicial X0. Portanto, muitas vezes devemos fazer uma conveniente troca de linhas e/ou colunas para que a convergência do processo seja garantida.
O seguinte procedimento realiza uma iteração de Jacobi:restart:with(LinearAlgebra):Jacobit:=proc(A,x,B,n) local k,Y,j,z; Y:=Vector(n,0); for j from 1 to n do z:=B[j]; for k from 1 to j-1 do z:=z-A[j,k]*x[k]; od; for k from j+1 to n do z:=z-A[j,k]*x[k]; od; Y[j]:=z/(A[j,j]): od; Y; end:
Jacobit:=proc(A,x,B)
Exemplo 1 Seja o sistema linear da forma AX= B onde A := Matrix([[4, 1, -2], [0, -2, -1], [-2, 1, 2]]);B := Vector([0, 10, -10]);n:=RowDimension(A);
Inicializemos a solução X:X := evalf(Vector([0, 0, 0])):
Então a primeira iteração resulta em Jacobit(A, X, B,n);
Após 1000 iterações obtemos: for i to 1000 do X := Jacobit(A, X, B,n) end do:X;
O resultado exato éLinearSolve(A,B);
Exemplo 2 Daremos aqui uma interpretação geométrica para o processo de Jacobi, com um sistema muito simples, definido por KxC2 y = 6, xC5 y = 1 . Apliquemos o método iterativo de Jacobi:
eq:=[y=x/2+3,y=-x/5+1];x[1]:=2.;y[1]:=4.;N:=20:for i to N do y[i+1]:=x[i]/2+3;
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
x [ i +1] : =- 5* y[ i ] +5;od:R:=[x[N+1],y[N+1]];
O processo parece convergir para a solução correta uma vez que esta é dada porevalf(solve(eq,[x,y]));
Vejamos o que acontece geometricamentepath := NULL:for i from 1 to 6 do path := path,[x[i],y[i]],[x[i+1],y[i+1]];end do:plot([x/2+3,-x/5+1,[path]],x=-16..30,y=-5..20,color =[red,green,blue]);
Os pontos correspondentes às sucessivas iterações não coincidem exatamente com as retas, pois não são soluções do sistema. À medida que o processo continua, no entanto, os vértices do caminho das iterações aproximam-se gradativamente de cada reta.Vamos agora escrever um procedimento que leve em conta o número de iterações e a convergência:
Jacobi:=proc(A,X,Y,N,erro) local it, XN,X1,n, epsilon; X1:=X; n:=RowDimension(A); XN:=Vector(n,0): it:=1: epsilon:=1: while it<N and epsilon>erro do XN:= evalf(Jacobit(A,X1,Y,n)); epsilon:=Norm(XN-X1,infinity); it:=it+1: X1:=XN: od; X1;end:
Jacobi:=proc(A,X,Y,N,erro)
Exemplo 3 Consideremos o sistema AX= Y da formaA:=Matrix([[5,0,0,-3,-1],[-1,4,0,0,-1],[0,0,2,-1,0] ,[-1,0,0,4,-2],[0,0,0,-1,2]]);Y:=Vector([2,3,-1,0,-1]);
Vejamos se o sistema tem convergência garantida:n:=RowDimension(A):for i from 1 to n do alpha[i]:=1/A[i,i]*(add(A[i,j],j=1..i-1)+add(A[i, j],j=i+1..n))od;abs(max(seq(alpha[i],i=1..n)));
Como esta valor é menor do que 1, o processo tem convergência garantida. Façamos um procedimento que faz tal verificação:
conv_jac:=proc(A) local n,i,alpha;
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
n: =RowDi mensi on( A) : for i from 1 to n do alpha[i]:=1/A[i,i]*(add(A[i,j],j=1..i-1)+add(A [i,j],j=i+1..n)); od: abs(max(seq(alpha[i],i=1..n)));end:
conv_jac:=proc(A)
conv_jac(A);Definamos um valor inicial para X:
X:=Vector([1.8,3,2,2,4]);erro:=10^(-9):N:=2000:X1:=Jacobi(A,X,Y,N,erro);
O método direto dá o resultadoX2:=LinearSolve(A,Y);X2f:=evalf(%);
O erro, relativamente ao valor exato é similar ao erro associado às duas últimas iterações:Norm(X1-X2f,infinity);
Exemplo 4 Façamos um teste de performance com uma matriz grande esparsa:
restart:with(LinearAlgebra):
Jacobit:=proc(A,x,B,n)
Jacobi:=proc(A,X,Y,N,erro)
n:=2000:A := Matrix(n, n, storage = sparse) ;for i to n do A[i,i]:=i^2/4.:od:for i from 2 to n-1 do A[i,i-1]:=0.05:od:A[4,5]:=2.1:A[5,2]:=3.2:A[100,99]:=1.1:A[992,883]:= 0.23:A;Y:=Vector(n,i->i/10.);X:=Vector(n,i->0.);erro:=0.0001:N:=100:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
tempoCPUi:=time();X1:=Jacobi(A,X,Y,N, erro):tempoCPU:=(time()-tempoCPUi)*second;X1;
O método iteravivo, implementado no sistema dá o resultado: tempoCPUi:=time();X3:=LinearSolve(A,Y, method = 'SparseIterative');tempoCPU:=(time()-tempoCPUi)*second;Norm(X1);norm(X1-X3);
O método direto dá
n:=2000:B := Matrix(n, n) ;for i to n do B[i,i]:=i^2/4.:od:for i from 2 to n-1 do B[i,i-1]:=0.05:od:B[4,5]:=2.1:B[5,2]:=3.2:B[100,99]:=1.1:B[992,883]:= 0.23:
tempoCPUi:=time();X4:=LinearSolve(B,Y);tempoCPU:=(time()-tempoCPUi)*second;Norm(X4-X3,infinity);
O maior tempo de processamento de nosso algoritmo é devido ao fato de que eles não são otimizados.
Usando eliminação de Gauss obtemosBu:=<B|Y>;
tempoCPUi:=time();Au1:=GaussianElimination(Bu);X5:=BackwardSubstitute(Au1);tempoCPU:=(time()-tempoCPUi)*second;Norm(X5-X4,infinity);
Exercícios
1. Seja o sistema linear AX= B, onde
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
A :=
5.1 0.4 1.8 K3.4 K1.9
K1.5 0.4 0.1 0.6 K1.1
0.4 0.3 22.5 K1.3 0.6
1.4 K0.3 K0.2 5.4 K2.4
0.4 0.1 0.8 1.4 5.7
, Y :=
K4.2
K3.6
K5.4
0.3
K6.2
4.4
(i) Verifique se o critério das linhas para convergência é satisfeito. (ii) Aplique o método iterativo de Jacobi para resolver este sistema, com um erro menor que 10 K8. (iii) Compare com o resultado exato, obtido através da eliminação de Gauss do sistema racionalizado.
Método de Gauss-SeidelO processo iterativo de Gauss-Seidel é definido de forma semelhante ao processo de Jacobi, com a diferença que os valores das componentes xi são atualizados à medida que vão sendo calculados.
Ou seja, o processo de Gauss-Seidel é o seguinte:
xikC1 =
yiK >j = 1
j K i
aij xjkC1
K >j = i C1
n
aij xjk
aii
Como veremos mais adiante, a convergência é mais rápida que no caso de Jacobi.
Façamos a implementação do procedimento que realiza uma iteração da Gauss-Seidel:restart;with(LinearAlgebra):gseidelit:=proc(A,x,b,n)local j, k, z, y; y := Vector(n, 0); for j to n do z := b[j]; for k to j-1 do z:=z-A[j,k]*y[k] od; for k from j+1 to n do z:=z-A[j,k]*x[k] od; y[j] := z/A[j, j]; od; y;end:
gseidelit:=proc(A,x,b,n)
Exemplo 1 Seja o sistema linear da forma AX= B onde A := Matrix([[4, 1, -2], [0, -2, -1], [-2, 1, 2]]);B := Vector([0, 10, -10]);
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
n: =RowDi mensi on( A) ;
Inicializemos a solução X:X0 := evalf(Vector([0, 0, 0])):
Então a primeira iteração resulta em X:=gseidelit(A, X0, B,n);
Após 1000 iterações obtemos: for i to 1000 do X := gseidelit(A, X, B,n) end do:X;
O resultado exato éLinearSolve(A,B);
Exemplo 2 Consideremos o sistema xCy =K6, 3xK y =K1 . Para fins de comparação tilizaremos os processos iterativos de Jacobi e Gauss-Seidel.
restart:with(LinearAlgebra):with(plots):eq:=[y=-x+6,x=y/3-1/3];x1[1]:=2.:y1[1]:=1.5:x2[1]:=2.:y2[1]:=1.5:N:=10:for i to N do x1[i+1]:=y1[i]/3-1/3; y1[i+1]:=-x1[i]+6;#Jacobi x2[i+1]:=y2[i]/3-1/3; y2[i+1]:=-x2[i+1]+6; #Gauss-Seidelod:R1:=[x1[N+1],y1[N+1]];R2:=[x2[N+1],y2[N+1]];
O processo parece convergir para a solução correta uma vez que esta é dada porevalf(solve(eq,[x,y]));
Notamos aqui que o método de Gauss-Seidel converge mais rapidamente do que o método de Jacobi, como esperado.Vejamos o que acontece geometricamente
path1 := NULL:path2:= NULL:for i from 1 to 8 do path1 := path1,[x1[i],y1[i]],[x1[i+1],y1[i+1]];path2 := path2,[x2[i],y2[i]],[x2[i+1],y2[i+1]];end do:plot([-x+6,3*x+1,[path1],[path2]],x=0..3,y=1..7,col or=[blue,green,red,black]);
No caso do processo de Gauss-Seidel , o gráfico mostra o fato de que, por construção, todos os pontos após a primeira iteração necessariamente se localizam sobre a reta correspondente à segunda equação de iteração, como podemos ver mais claramente no gráfico abaixo, onde a maiorrapidez de convergência do método de Gauss-Seidel é aparente.
p1:=plot([[path1],[path2]],color=[red,blue]):p2:=pointplot([path2],symbol=circle):display([p1,p2]);
O procedimento seguinte realiza iterações até que um dado número máximo de iterações ou o erro
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO OOOO OOOO
OOOO OOOO
atinja um erro determinado. GSeidel:=proc(A,X,Y,N,erro) local it, XN,X1,epsilon,n; X1:=X; n:=RowDimension(A): XN:=Vector(n,0): it:=1: epsilon:=1: while it<N and epsilon>erro do XN:= evalf(gseidelit(A,X1,Y,n)); epsilon:=Norm(XN-X1,infinity); it:=it+1: X1:=XN: od; X1;end:
gseidelit:=proc(A,x,b,n)
GSeidel:=proc(A,X,Y,N,erro)
Exemplo 3 Seja o sistemaA := Matrix([[4, 1, -2,2], [ 1 ,5,3,2], [0, -2,7, - 1], [-2,1, 3,9]]);B := Vector([2, 10, -10,4]);n:=RowDimension(A):X:=Vector(n,0);erro:=10^(-8):N:=100:X1:=GSeidel(A,X,B,N,erro);
O resultado exato, por método direto é:X2:=LinearSolve(A,B);
ouX2f:=evalf(X1);Norm(X2f-X1,infinity);
Critério de convergênciaPara o processo de Gauss-Seidel vale o critério das linhas, estabelecido para o processo de Jacobi.Um critério mais fraco do que esse (e portanto mais útil) é o de Sassenfeld. Sejam
β1 =1
a11 >
k= 2
n a1 k , βi =
1aii>
k= 1
i K1 ai kβk C>
k= i C1
n ai k , i = 2, 3, . . . n.
Ou seja,
β1 =a12C a13 C$$$Ca1 n
a11
β2 =a21β1C a23C$$$C a2 n
a22
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
β3
=a31β1
C a32 β2C$$$C a3 n
a33
β4
=a41β1
C a42 β2C a43β3
$$$C a3 n
a44
. . .
βn =
an1β1C an2β2
C an3β3$$$C an nK1 βnK1
ann
Exemplo 4 Consideremos o sistema AX= Y da formarestart:with(LinearAlgebra):
gseidelit:=proc(A,x,b,n)
GSeidel:=proc(A,X,Y,N,erro)
A:=Matrix([[5,0,0,-3,-1],[-1,4,0,0,-1],[0,0,2,-1,0] ,[-1,0,0,4,-2],[0,0,0,-1,2]]);Y:=Vector([2,3,-1,0,-1]);
Vejamos se o sistema tem convergência garantida, usando o critério de Sassenfeld:n:=RowDimension(A);beta[1]:=add(abs(A[1,k]),k=2..n)/A[1,1];n:=RowDimension(A):for i from 2 to n do beta[i]:=1/A[i,i]*(add(abs(A[i,j])*beta[j],j=1..i -1)+add(abs(A[i,j]),j=i+1..n))od;
abs(max(seq(beta[i],i=1..n)));Como este valor é menor do que 1, o processo tem convergência garantida. Façamos um procedimento que faz tal verificação:
conv_gs:=proc(A) local n,i,beta; n:=RowDimension(A): beta[1]:=add(abs(A[1,k]),k=2..n)/A[1,1]; for i from 2 to n do beta[i]:=1/A[i,i]*(add(abs(A[i,j])*beta[j],j=1 ..i-1) +add(abs(A[i,j] ),j=i+1..n)) od; max(seq(beta[i],i=1..n));end:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
conv_gs:=proc(A)
conv_gs(A);
Definamos um valor inicial para X:
X:=Vector([1.8,3,2,2,4]);erro:=10^(-9):N:=2000:X1:=GSeidel(A,X,Y,N,erro);
O método direto dá o resultadoX2:=LinearSolve(A,Y);X2f:=evalf(%);
O erro, relativamente ao valor exato é similar ao erro associado às duas últimas iterações:Norm(X1-X2f,infinity);
Exemplo 5Façamos um teste de performance com uma matriz grande esparsa, igual àquela usamos para testar o método de Jacobi.
restart:with(LinearAlgebra):
gseidelit:=proc(A,x,b,n)
GSeidel:=proc(A,X,Y,N,erro)
n:=2000:A := Matrix(n, n, storage = sparse) ;for i to n do A[i,i]:=i^2/4.:od:for i from 2 to n-1 do A[i,i-1]:=0.05:od:A[4,5]:=2.1:A[5,2]:=3.2:A[100,99]:=1.1:A[992,883]:= 0.23:A;Y:=Vector(n,i->i/10.);X:=Vector(n,i->0.);erro:=0.0001:N:=100:tempoCPUi:=time();X1:=GSeidel(A,X,Y,N, erro):tempoCPU:=(time()-tempoCPUi)*second;
Como esperado, a convergência aqui é mais rápida. X1;
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
O método iteravivo, implementado no sistema dá o resultado: tempoCPUi:=time();X3:=LinearSolve(A,Y, method = 'SparseIterative');tempoCPU:=(time()-tempoCPUi)*second;Norm(X1);norm(X1-X3);
Abaixo apresentamos um procedimento que realiza iterações de Gauss-Seidel em forma recursiva:restart:with(LinearAlgebra):
gs3:=proc(A,Y,x0,N,it,epsilon,d) local i,n,x,xnew,j,S,it1,d1; n:=RowDimension(A); x:=Vector(n,0); xnew:=Vector(n,0); x:=x0; if it>N or d<epsilon then x; else for j to n do S:=add(A[j,k]*xnew[k], k=1..j-1)+add(A[j,i] *x[i],i=j+1..n); xnew[j]:=evalf((Y[j]-S)/A[j,j]); od: x:=xnew; d1:=Norm(x-x0,infinity)/Norm(x,infinity); it1:=it+1; gs3(A,Y,x,N,it1,epsilon,d1); fi;end:
Exemplo 6 Testemos este procedimento recursivo no seguinte sistema: A:=Matrix([[20,4,6,7],[5,7,1,2],[1.5,4,21,-4],[4.7, 3,8,-10]]);x0:=Vector([0,0,0,0]);Y:=Vector([2,4,7,9]);st := time():gs3(A,Y,x0,20,1,5E-5,1);time()-st;
Exemplo 7 Testemos este procedimento num sistema esparso grande
n:=2000:A := Matrix(n, n, storage = sparse) ;for i to n do A[i,i]:=i^2/4.:od:for i from 2 to n-1 do A[i,i-1]:=0.05:od:A[4,5]:=2.1:A[5,2]:=3.2:A[100,99]:=1.1:A[992,883]:= 0.23: A[1502,1400]:=0.32:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
A;Y:=Vector(n,i->i/10.);x0:=Vector(n,i->0.);erro:=0.0001:N:=100:tempoCPUi:=time();X1:=gs3(A,Y,x0,20,1,5E-5,1);tempoCPU:=(time()-tempoCPUi)*second;
Exemplo 8 Considere o sistema linear AX= B onde A = 0.0563015390237106700, 0.118121730583927192, 0.190834891275908636,
0.0827801497380379336, 0.143009002659235301, 0.142225710236065034, 0.167560636615715131,
0.0721273142004405371, 0.0902681160711486519, 0.0563003118296981284, 0.421332345559586703,
0.0660847219213205606, 0.00951093462277321534, 0.0713737972365084128, 0.138948646626522038,
0.2321112222322222344,
B :=
1
1
1
1
(i) Verifique, passo a passo, se a convergência do método de Gauss-Seidel é garantida neste caso.
(ii) Em qualquer caso de resposta do item (i), aplique o método de Gauss-Seidel e determine se em 100 iterações o processo converge o número e apresente a solução (iii) Determine o número de iterações de Gauss-Seidel necessárias para que o erro seja menor que e = 10K9. (iv) Determine o número de iterações de Jacobi necessárias para que o erro seja menor que e = 10K9. (v) Determine a solução exata, obtida a partir da aplicação de um método direto ao sistema racionalizado e compare com a solução obtida com o método iterativo.
with(LinearAlgebra):A := (Matrix(4, 4, {(1, 1) = 0.863015390237106700e- 1, (1, 2) = .118121730583927192, (1, 3) = .190834891275908 636, (1,4) = 0.827801497380379336e-1, (2, 1) = .14300900265 9235301,(2, 2) = .942225710236065034, (2, 3) = .16756063661 5715131,(2, 4) = 0.721273142004405371e-1, (3, 1) = 0.902681160711486519e-1, (3, 2) = 0.563003118296981 284e-1, (3, 3) = .921332345559586703, (3, 4) = 0.660847219213205606e-1, (4, 1) = 0.951093462277321 534e-2, (4, 2) = 0.713737972365084128e-1, (4, 3) = .138948646626522038, (4, 4) = .9321112222322222344} )):B:=Vector(4,1):
(i) Para determinar se a convergência é garantida, usamos o critério de Sassenfeld:
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
n: =RowDi mensi on( A) ;beta[1]:=add(abs(A[1,k]),k=2..n)/A[1,1];for i from 2 to n do beta[i]:=1/A[i,i]*(add(abs(A[i,j])*beta[j],j=1..i -1)+add(abs(A[i,j]),j=i+1..n))od;abs(max(seq(beta[i],i=1..n)));
A convergência, portanto, não é garantida.
(ii) Apliquemos a iteração de Gauss-Seidel sucessivamente:
gseidelit:=proc(A,x,b,n)
X:=Vector(n,0):gseidelit(A,X,B,n);
Após 100 iterações obtemos:
for i to 100 do X := gseidelit(A, X, B,n) end do:X;
Ou seja, apesar do critério de convergência não ter sido satisfeito, o processo convergiu, de fato.
(iii) Para determinar o número de iterações para que seja menor que e = 10K9, devemos modificar o procedimento GaussSeidel, de modo que ele passe a contar o número de iterações.
GSeidelN:=proc(A,X,Y,N,erro) local it, XN,X1,epsilon,n; X1:=X; n:=RowDimension(A): XN:=Vector(n,0): it:=1: epsilon:=1: while it<N and epsilon>erro do XN:= evalf(gseidelit(A,X1,Y,n)); epsilon:=Norm(XN-X1,infinity); it:=it+1: X1:=XN: od; X1,it-1;end:
Apliquemos este procedimento ao nosso caso:X:=Vector(n,0):G:=GSeidelN(A,X,B,100,10^(-9));Xgs:=G[1];
Portanto, 20 iterações foram necessárias.
(iv) Para determinar o número de iterações para que seja menor que e = 10K9, devemos modificar o procedimento GaussSeidel, de modo que ele passe a contar o número de iterações.
Jacobit:=proc(A,x,B)
Jacobi:=proc(A,X,Y,N,erro)
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
l ocal i t , XN, X1, n, epsi l on; X1:=X; n:=RowDimension(A); XN:=Vector(n,0): it:=1: epsilon:=1: while it<N and epsilon>erro do XN:= evalf(Jacobit(A,X1,Y,n)); epsilon:=Norm(XN-X1,infinity); it:=it+1: X1:=XN: od; X1,it-1;end:
Portanto,X:=Vector(n,0):J:=Jacobi(A,X,B,100,10^(-9));XJac:=J[1];
Ou seja, são necessárias 75 iterações, para chegarmos ao mesmo resultado obtido através do processo de Gauss-Seidel.
(v) Para determinar a solução exata, racionalizemos o sistema:Ar:=convert(A,rational);ArB:=<Ar|B>;Xe:=LinearSolve(Ar,B);Xef:=evalf(%);
O erro da solução iterativa é, portanto,Norm(Xgs-Xef,infinity);
Ou seja, o resultado tem um erro bastante próximo ao esperado.
Exercícios
1. Considere o sistema AX= B com
A =
4.7 3.1 8.1 K11.6
5.2 7.3 1.1 2.5
14.2 4.1 K6.2 1.3
1.5 4.4 K21.2 K4.1
, B =
2.2
3.2
K3.7
4.9
,
(i) Faça o teste de convergência de Sassenfeld para a matriz de coeficientes. Verifique se a convergência pode ser garantida através de troca de linhas (ou colunas). (ii) Caso a convergência do sistema seja garantida, resolva o sistema usando o método iterativo deGauss-Seidel, passo a passo. Determine o número de interações necessárias k para que o erro
e = X kKX kK1
N = 10K4 seja alcançado. (iii) Verifique o número de interações necessárias para se chegar a este mesmo erro usando o método de Jacobi. (iv) Compare o resultado obtido em (ii) com aquele dado pela solução exata do sistema racionalizado (usando eliminação de Gauss, por exemplo).
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
2. Seja o sistema AX= Y, com
A =
1 2 1 1 0
3 7 0.3 1.1 2.1
0 1.2 8.3 2.2 5.3
2.5 2.7 0.7 9.8 2.1
1.1 2.1 0.7 1.4 8.2
, Y=
1
1
1
1
1
1
.
(i) Examine a convergência através do critério de Sassenfeld. (ii) Use um algoritmo que aplica o método de Gauss-Seidel a este sistema e que conta o número de passos usados até o erro
e = X kKX kK1
N = 10K9 ser alcançado. (iii) Determine o número de passos necessário para que o método de Jacobi atinja este mesmo erro. (iv) Compare o resultado obtido em (ii) com aquele dado pela solução exata do sistema racionalizado (usando eliminação de Gauss, por exemplo).
3. Dado o sistema AX= B, com
A ij =1
i C j C2 , B = 1 1 ... 1 '.
onde A é uma matriz 15 × 15 e B um vetor de 15 componentes com todas componentes de valor 1. É possível resolver este sistema usando o métodos iterativos de Jacobi e Gauss-Seidel?
Interpolação
Interpolação inocenteConsideremos a seguinte função tabelada:
x 1 2 3 4 5
f x 1 1.5 2 1.4 0.8
Determinemos um polinômio que passa por todos esses pontos e façamos o gráfico correspondente. Tal polinômio é denominado interpolante.
restart:with(LinearAlgebra):X:=[1,2,3,4,5];F:=[1,1.5,2,1.4,0.8];P:=x->sum(a[k]*x^k, k=0..4);P(2);eqs:=[seq(P(X[i])=F[i],i=1..5)];vars:=[seq(a[j],j=0..4)];A,B:=GenerateMatrix(eqs, vars);
OOOO OOOO
1. 1.
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
3. 3.
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
2. 2.
OOOO OOOO A;
Notemos que o a matriz de coeficientes é mal condicionada: ConditionNumber(A);R:=RandomMatrix(5, density = .75, generator = 0 .. .800);ConditionNumber(R);sol:=solve(eqs,vars);assign(sol);
O polinômio interpolante é então dado por P(t);
Façamos um gráfico que mostra os pontos e o polinômio interpolantewith(plots):pontos:=[seq([X[i],F[i]],i=1..5)];p1:=pointplot(pontos,color=blue,symbol=diamond);p2:=plot(P(t),t=0.5..5.5);display([p1,p2]);
Nas próximas seções faremos uma abordagem mais geral do problema da interpolação.
Problema geral da interpolaçãoO problema geral da interpolação é o seguinte: dado o conjunto de pontos:
ti , yi , i = 1 ..n.
Determine a função f t tal que f ti = yi , i = 1, ... ,n .
Esta equação é denominada equação de interpolação ou condição de interpolação. Ela impõe que a função f t passa pelos pontos do conjunto. Tal f t é denominada função interpolante.
Há numerosas aplicações que demandam a construção de uma função interpolante da o conjunto de dados:
Plotar uma curva suave através de um conjunto de dados discretos.Ler dados não presentes numa tabela.Manipulação numérica (integração, por exemplo) de dados tabulares.
Interpolação linearNo caso da interpolação linear a função interpolante é expressa como uma combinação linear de n funções de base φ
1, φ
2, ... , φ
n
f t =>j = 1
n
xj φjt = x1φ1
t Cx2φ2t C$$$Cxnφn
t .
Veremos logo adiante que para a interpolação linear, para o problema ser bem posto, o número de funções de base deve ser igual ao número de pontos dados. O problema de determinar a função interpolante então torna-se então aquele de determinar os coeficiente xj das funções de base. Tais
coeficientes são determinados pela condição de interpolação.
Exemplo 1 Interpolaremos os dados
t K1 0 1
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
y 1.4 0.8 1.7
por uma função da forma
f x = x1eKtC x2Cx3 e
t.
Podemos resolver este problema da seguinte forma:restart:with(plots):f:=t->x1*exp(-t)+x2+x3*exp(t);tt:=[-1,0,1];y:=[1.4,0.8,1.7];n:=nops(tt);for i to n do eq[i]:=x1*exp(-tt[i])+x2+x3*exp(tt[i])=y[i];od;sol:=solve([seq(eq[i],i=1..n)],[x1,x2,x3]);s:=sol[1];f(t);F(t):=subs(s,f(t));pontos:=[seq([tt[i],y[i]],i=1..n)];p1:=pointplot(pontos,symbol=circle,color=blue):p2:=plot(F(t),t=-2..2):display([p1,p2]);
Exemplo 2 Façamos uma interpolação para os mesmos dados do Exemplo 1, agora com as funções de base φ
1= 1, φ
2= t, φ
3= t2. Ou seja, a função interpolante é da forma
g x = x1C x2 tCx3 t2.
Resolvamos estre problema no Maple
for i to n do eq2[i]:=x1+x2*tt[i]+x3*tt[i]^2=y[i];od;sol2:=solve([seq(eq2[i],i=1..n)],[x1,x2,x3]);s2:=sol2[1];
Podemos agora determinar a função interpolante:g:=t->x1+x2*t+x3*t^2;G(t):=subs(s2,g(t));p3:=plot(G(t),t=-2..2,color=blue):display([p1,p3,p2]);
Notamos que, apesar das funções de base serem muito diferentes, as respectivas funções interpolantes são muito próximas entre si nas reigões próximas aos pontos de interpolação.
Em geral, na interpolação linear, a determinação dos coeficientes se dá pela resolução de um sistema de equações lineares. Ou seja, dados os pontos
f ti = yi , i = 1, ... ,n ,
e o conjunto de funções de base φ1, φ
2, ... , φ
n , nosso problema é determinar coeficientes xj tais
que a função
f t =>j = 1
n
xj φj t = x1φ1 t Cx2φ2 t C$$$Cxnφn t
satisfaça as condições de interpolaçãof ti = yi , i = 1, ... ,n .
Em termos das funções de base, as condições acima são expressas poryi = f ti = x1φ1 ti C$$$Cxnφn ti , i = 1, ... , n,
ou y1 = x1φ1 t1 C$$$Cxnφn t1y2 = x1φ1
t2 C$$$Cxnφnt2
$$$
yn = x1φ1tn C$$$Cxnφn
tn .
Este é um sistema de n equações lineares para os n coeficientes x1, ... , xn . Em termos matriciais
temos
y1
y2
:
yn
=
φ1
t1 φ2
t1 $$$ φn
t1
φ1
t2 φ2
t2 $$$ φn
t2
: : $$$ :
φ1 tn φ2 tn $$$ φn tn
x1
x2
:
xn
.
A matriz de coeficientes é chamada matriz de base.
Exercício 1 Interpole os dados
t 1.2 3.4 4.3 5.1 6.2
y 1.5 5.3 8.1 4.6 3.1
por uma função que é uma combinação linear de funções da forma tn, n = 0, ... , 3 .
Interpolação polinomial1. Base monomial
A base mais óbvia para os polinômios de grau menor ou igual a n é a base monomial φk = tkK1 , k = 1, ... , n ,
que resulta na usual representação do polinômio interpolante:
p t =>k= 1
n
xk t kK1 = x1Cx2 t Cx3 t
2C$$$xn t
nK1 .
Para pontos t1, ... , tn a matriz de base é
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
A =
1 t1 t 12 $$$ t1
n
1 t2 t 22 $$$ t2
n
: : :
1 tn t n2 $$$ tn
n
.
Notemos que o número de pontos determina o número de funções de base.
Construiremos um procedimento que computa a matriz de base para a base monomial em um conjunto de dados, fornecidos em um vetor.
restart:with(LinearAlgebra):monbasis:=proc(t) local n,A,m,k; n:=Dimension(t); A:=Matrix(n,n): for m from 1 to n do for k from 1 to n do A[m,k]:=t[m]^(k-1); od: od: A;end:
monbasis:=proc(t)
No Scilab podemos definir a função
function a = monbasis(t)
n = length(t)
a = zeros(n,n)
for j = 1:n
a(:,j) = t.^{j-1}
end
endfunction
Façamos um teste do procedimento:T:=Vector([1,2,3,4]);monbasis(T);
Suponhamos que a cada componente do vetor de dados T temos associado outro vetor Y, ou seja,
y Ti = Yi .
O procedimento abaixo resolve o sistema AX= Y ,
onde A é a matriz de base monomial e X é o vetor dos coeficientes da interpolação.
moninterp:=proc(T,Y)
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
l ocal X, A; A:=monbasis(T); X:=LinearSolve(A,Y);end:
moninterp:=proc(T,Y)
No Scilab,
function x = moninterp(t, y)
a = monbasis(t)
x = a\y
endfunction
SeY:=Vector([1,3,4,2]);moninterp(T,Y);
Regra de Horner
Uma vez encontrados os coeficientes do polinômio interpolante necessitamos de um procedimento para fazer sua avaliação. O método simples considera o polinômio
p t = x0Cx2 t Cx3 t2C$$$Cxn t
nK1,
avalia as potências, multiplica pelos respectivos coeficientes e faz a soma. A regra de Horner, por outro lado, avalia o polinômio da seguinte forma:
p t = x1Ct x2C t x3Ct x4Ct ... xnK1C t xn ... .
Tal método, além de evitar a soma de termos com ordens de magnitude muito diferentes, tem um custo computacional menor. No Scilab por exemplo a regra de Horner pode ser implementada da seguinte forma:
function y = moneval(x, t)
n = length(x);
y = zeros(t);
for i = n:-1:1
y = y.*t + x(i);
end
endfunction
No Maple temos um comando que realiza tal tarefa: with(numapprox);g:=t->x1+x2*t+x3*t^2+x4*t^3;hornerform(g);
Façamos um procedimento que, a partir dos dados, gera um polinômio interpolante na forma de Horner:
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
f i nt er p: =pr oc( T, Y) local p,x,n; n:=Dimension(T); x:=moninterp(T,Y); p:=hornerform(add(x[i]*t^(i-1),i= 1..n)); end:
finterp:=proc(T,Y)
Exemplo 3 Consideremos o conjunto de dados:
t 1.0 2.0 3.0 4.0 5.0 6.0
y 1.9 2.7 4.8 5.3 7.1 9.4
restart:with(numapprox):with(LinearAlgebra):
monbasis:=proc(t)
moninterp:=proc(T,Y)
finterp:=proc(T,Y)
T:=Vector([1.0 , 2.0 , 3.0 , 4.0 , 5.0 , 6.0]);Y:=Vector([1.9 , 2.7 , 4.8 , 5.3 , 7.1 , 9.4]);
O polinômio interpolante é dado por p:=finterp(T,Y);
Façamos um gráfico do polinômio interpolante, junto com os dados:with(plots):n:=Dimension(Y):pontos:=[seq([T[h],Y[h]],h=1..n)]:p1:=pointplot(pontos,symbol=circle,color=blue):p2:=plot(p,t=1..7):display([p1,p2]);
Notemos que a matriz de baseA:=monbasis(T);
tem número de condição ConditionNumber(A);
OOOO OOOO OOOO OOOO
o que mostra que o sistema AX= Y é mal condicionado. O resíduo é dado porX:=LinearSolve(A,Y);res:=Norm(A.X-Y,infinity);
2. Interpolação de LagrangeUm conjunto alternativo de funções de base para a interpolação polinomial é aquele formado por polinômios de Lagrange. Dado o conjunto de pontos ti , yi , i = 1, ... ,n , os polinômios de
Lagrange L1 t , ... , Ln t são definidos por
Lj t =tK t1 $$$ tK tj K1 tKtj C1 $$$ tKtn
tjKt1 $$$ tjK tj K1 tjKtj C1 $$$ tjKtn = ?
k= 1, ks j
n tKtktjKtk
.
Notemos que
Lj t1 =1, i = j
0, i s j, i, j = 1, ... , n.
Por exemplo, para n = 4 temos
L1 t = tK t2 tK t3 tK t4
t1Kt2 t1Kt3 t1K t4
L2 t = tK t1 tK t3 tK t4
t2Kt1 t2Kt3 t2K t4
L3 t = tK t1 tK t2 tK t4
t3Kt1 t3Kt2 t3K t4
L4 t = tK t1 tK t2 tK t3
t4Kt1 t4Kt2 t4K t3 .
Portanto, a matriz de base tem a notável propriedade de ser a matriz identidade:
L1 t1 L2 t1 $$$ Ln t1
L1 t2 L2 t2 $$$ Ln t2
: : $$$ :
L1 tn L2 tn $$$ Ln tn
=
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
.
Como consequência, os coeficientes da combinação linear que gera o polinômio interpolante são
xj = yj , j = 1, ... , n.
Portanto, o polinômio interpolante é
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
p t =>i = 1
n
yiLi t .
Embora os coeficientes da interpolação de Lagrange sejam exatamente os valores y dos dados, a avaliação do polinômio interpolante requer a avaliação de cada um do n polinômios de Lagrange.
O seguinte procedimento avalia o j-ésimo polinômio de Lagrange a partir de um vetor de dados:
restart:
PLagrange := proc(j,T,t)local z,T2,T1; T1:=convert(T,list): T2 := [op(1..j-1,T1),op(j+1..nops(T1),T1)]; mul((t-z)/(T1[j]-z),z=T2);end proc:?mul
PLagrange := proc(j,T,t)
Por exemplo, n := 4:t := 't':T := Vector([t[1],t[2],t[3],t[4]]);PLagrange(3,T,t);
Exemplo 4 Consideremos novamente o conjunto de dados:
t 1.0 2.0 3.0 4.0 5.0 6.0
y 1.9 2.7 4.8 5.3 7.1 9.4
restart:with(LinearAlgebra):Digits:=19:
PLagrange := proc(j,T,t)
T:=Vector([1.0 , 2.0 , 3.0 , 4.0 , 5.0 , 6.0]);Y:=Vector([1.9 , 2.7 , 4.8 , 5.3 , 7.1 , 9.4]);n:=Dimension(T);for i to n do L[i]:=PLagrange(i,T,t) od;
O polinômio interpolante é dado porp:=add(Y[i]*L[i], i=1..n);
Notemos que este polinômio é o mesmo que o determinado anteriormente:
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
p2: =si mpl i f y( p) ;p0 := 20.60000000000000076+(-40.24166666666666800+(29.82083333333333410+(-9.629166666666666886+(1.429166666666666696-0.7916666666666666814e-1*t)*t )*t)*t)*t;simplify(p2-p0);
O gráfico do polinômio interpolante é novamente dado por:with(plots):pontos:=[seq([T[h],Y[h]],h=1..n)]:P1:=pointplot(pontos,symbol=circle,color=blue):P2:=plot(p,t=1..7):display([P1,P2]);
Exemplo 5 Consideremos o problema de encontrar um polinômio interpolante para a função
sin x no intervalo 0,π
2. Tomemos 6 pontos igualmente espaçados:
restart:Digits:=19:with(LinearAlgebra):
PLagrange := proc(j,T,t)
O polinômio interpolante é dado por
d := evalf(Pi/2);h := d/6;XL:=[seq(h*(i-1),i=1..7)];YL:=[seq(sin(XL[i]),i=1..7)];X:=convert(XL,Vector);Y:=convert(YL,Vector);n:=Dimension(X);for i to n do L[i]:=PLagrange(i,X,x) od;
p:=add(Y[i]*L[i], i=1..n);p2:=simplify(p);p2f:=unapply(p2,x);
with(plots):pontos:=[seq([X[j],Y[j]],j=1..n)]:P1:=pointplot(pontos,symbol=circle,color=blue):P2:=plot(p2,x=-2..4,color=blue):P3:=plot(sin(x),x=-2..5,color=red):
display([P1,P2,P3]);A concordância entre a função original e o polinômio interpolante parece ser muito boa. Uma análise quantitativa do erro pode ser obtida fazendo-se o gráfico do erro absoluto:
plot(p2f(x)-sin(x),x=0..Pi/2,color=blue);O erro absoluto máximo é dado por
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
wi t h( numappr ox) :infnorm(p2f(x)-sin(x),x=0..Pi/2);
3. Interpolação de NewtonJá vimos dois métodos de interpolação polinomial usando diferentes funções de base. A base de Lagrange determina trivialmente os coeficientes da combinação linear, mas a avaliação do polinômio interpolante é custosa. Por outro lado, usando a base monomial, o polinômio interpolante é facilmente avaliado usando a regra de Horner, mas a computação dos coeficientes requer a solução de um sistema linear que é mal-condicionado. Um terceiro médodo, chamado interpolação de Newton, tem ambas as vantagens, com coeficientes da combinação linear facilmente determinados e polinômio facilmente avaliado.
Para um conjunto de dados ti , yi os polinômios da base de Newton π1, ... , π
n são
definidos por π
1= 1
π2
= tKt1
π3 = tKt1 tKt2:πn = tKt1 tKt2 $$$ tKtnK1
A matriz de base tem a seguinte forma:
O seguinte procedimento gera os polinômios de Newton:
restart:with(LinearAlgebra):with(numapprox):newton_pol:=proc(T) local pi,n,i; n:=Dimension(T); pi:=Vector(n): pi[1]:=1: for i from 1 to n-1 do pi[i+1]:=(t-T[i])*pi[i]; od: pi;end:
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
newton_pol:=proc(T)
Por exemplo, T:=Vector([seq(t[i],i=1..4)]);pi:=newton_pol(T);
O seguinte procedimento gera a a matriz de base de Newton:newton_basis:=proc(T) local A,m,n,k,i; n:=Dimension(T); A:=Matrix(n,n): for m to n do A[m,1]:=1: od: for k from 2 to n do for i from 1 to n do A[i,k]:=(T[i]-T[k-1])*A[i,k-1]; od: od: A;end:
newton_basis:=proc(T)
Por exemplo, A:=newton_basis(T);
Como a matriz de base é triangular inferior os coeficientes xi da combinação linear
p t =>i = 1
n
xi πit
podem ser determinado através de forward substitution. O comando LinearSolve do Maple já realiza tal tarefa automaticamente. O procedimento abaixo tem como entrada os dados de uma tabela e como saída os coeficientes da combinação linear das funções de base.
newton_coeff:=proc(T,Y) local X,A; A:=newton_basis(T); X:=LinearSolve(A,Y);end:
newton_coeff:=proc(T,Y)
Podemos agora gerar o procedimento que cria tem como entrada os dados de uma tabela e como resultado o polinômio interpolante gerado através de uma base de Newton, na forma de Horner:
newton_interp:=proc(T,Y) local p,x,n,pi; n:=Dimension(T);
OOOO OOOO
OOOO OOOO OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
x : =newt on_coef f ( T, Y) ; pi:=newton_pol(T); p:=hornerform(add(x[i]*pi[i],i=1..n)); p;end:
newton_interp:=proc(T,Y)
Exemplo 5 Consideremos o conjunto de dados:
t 1.0 2.0 3.0 4.0 5.0
y 1.9 2.7 4.8 7.1 9.4
Busquemos o polinômio interpolante para estes pontos, usando a base de Newton. restart:with(LinearAlgebra):with(numapprox):
newton_pol:=proc(T)
newton_basis:=proc(T)
newton_coeff:=proc(T,Y)
newton_interp:=proc(T,Y)
T:=Vector([1.0 , 2.0 , 3.0 , 4.0 , 5.0 ]) :Y:=Vector([1.9 , 2.7 , 4.8 , 5.3 , 7.1 ] ):newton_pol(T);newton_basis(T);newton_coeff(T,Y);p:=newton_interp(T,Y);
Façamos o gráfico do resultado: with(plots):n:=Dimension(T):pontos:=[seq([T[k],Y[k]],k=1..n)]:P1:=pointplot(pontos,symbol=circle,color=red):P2:=plot(p,t=0.5..5.1,color=blue):display([P1,P2]);
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
Notamos no exemplo acima que o extremo relativo do polinômio interpolante entre 1 e 2 não tem necessariamente relação com a disposição dos pontos. Tal problema ocorre devido ao alto grau do polinômio.
Exemplo 6 Determine uma conveniente aproximação polinomial para a função
f t =
1
tex
xdx
no intervalo [1.5, 6.0]. int(exp(x)/x,x);
Solução Escolhamos 6 pontos igualmente espaçados desta função para formar uma tabela:
f:=t->int(exp(x)/x, x = 1 .. t);
plot f t , t = 0 ..7 ;n:=5: x1:=1.5: x2:=6.0: L:=x2-x1;h:=L/n;
Os pontos são então dados por T:=[seq(x1+i*h,i=0..n)];
O valores de f t nesses pontos são dados por Y:=[seq(evalf(f(T[k])),k=1..n+1)];Tv:=convert(T,Vector);Yv:=convert(Y,Vector);
O polinômio interpolante é então dado porp:=newton_interp(Tv,Yv);
Façamos os gráficos dos pontos, do polinômio interpolante e da função original:with(plots):pontos:=[seq([Tv[k],Yv[k]],k=1..n+1)]:P1:=pointplot(pontos,symbol=circle,color=red):P2:=plot(p,t=0.5..6.5,color=blue):P3:=plot(f(t),t=0.5..6.5,color=red):display([P1,P2,P3]);
A concordância entre a função original e o polinômio interpolante parece ser razoável, ao menos visualmente. Uma análise quantitativa do erro pode ser obtida fazendo-se o gráfico do erro absoluto:
plot(f(t)-p(t),t=1.5..6,color=blue);O erro absoluto máximo é dado por
infnorm(f(t)-p(t),t=1.5..6);
4. Diferenças divididas5. Fenômeno de Runge
6. Pontos de Chebyshev
7. Interpolação por partes8. Exercícios
Ajuste de curvas a dados
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Diferenciação numérica
Integração Numérica
Quadratura de Gauss
Exercícios1. Calcule a integral Loading Student:-Calculus1
Métodos de Newton-CotesIntroduçãoAs fórmulas de Newton-Cotes formam os esquemas mais comuns de integração numérica. Eles consistem na estratégia de substituir um função complicada ou que não possui primitiva ou dada numa tabela, por uma função aproximada que é fácil de integrar, ou seja,
I =a
b
f x dxya
b
pn x dx ,
sendo pn x um polinômio da forma
pn x = a0Ca1 xC $$$CanK1 xnK1
Can xn.
O método mais simples consiste em escolher um polinômio constante, que corresponde à somade Riemann, um conceito usado para introduzir o conceito de integral definida.
Normalmente a aproximação é feita num pequeno intervalo. Uma integral definida num intervalo grande é então realizada somando-se as integrais aproximadas em um dado número de subintervalos. Tal soma de Riemann pode ser realizada de diferentes modos, correspondentes à posição escolhida que define a altura de cada retângulo. Por exemplo, consideremos a integral:
0
1
x2 dx .
O valor exato desta integral é
with(Student[Calculus1]);ApproximateInt(x^2, 0..1, 'partition' = 4, 'method' = lower, 'partitiontype' = subintervals, 'output' = ' plot','boxoptions' = ['filled' = ['transparency'=.5]]);
A soma de Riemann superior é dada porvalue(%);ApproximateInt(x^2, 0..1, 'partition' = 4, 'method' = upper, 'partitiontype' = subintervals, 'output' = ' plot','boxoptions' = ['filled' = ['transparency'=.5]]);
Uma melhor aproximação consiste na soma de Riemann de ponto médio:ApproximateInt(x^2, 0..1, 'partition' = 4, 'method' =
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
mi dpoi nt , ' par t i t i ont ype' = subi nt er val s, ' out put ' = 'plot', 'boxoptions' = ['filled' = ['transparency'= .5]]);
Método Trapezoidal
Um método que dá resultados ainda melhores que o da soma de Riemann é o chamado métododo trapézio, que consiste em aproximar a integral da função em cada intervalo por um polinômio de primeiro grau. A integral da função num intervalo qualquer é dada então pela soma das áreas de todos os trapézios. Por exemplo consideremos novamente a integral:
0
1
x2 dx
Tomando novamente 4 intervalos temosApproximateInt(x^2, 0..1, 'partition' = 4, 'method' = trapezoid, 'partitiontype' = subintervals, 'output' = 'plot', 'boxoptions' = ['filled' = ['transparency'= 0.9]]);
O valor exato da integral é 0.3333 ... . Deduziremos agora uma fórmula para calcular a integral de uma função qualquer f x , não divergente em um dado intervalo a, b . Num dado subintervalo xi , xi C1 a área do
correspondente trapézio é dada por
Ai =xi C1Kxi K1 f xi C1 C f xi
2 .
Suponhamos que temos nC1 pontos igualmente espaçadosx0 = a, x1, x2, ... , xn = b .
Consequentemente temos n subintervalos de tamanho h dado por
h =bKa
n .
A integral de f x no intervalo a, b é dada por
a
b
f x dx =x0
x1
f x dxCx1
x2
f x dxC$$$CxnK1
xn
f x dx .
Usando a aproximação do trapézio em cada subintervalo temos
a
b
f x dxyh f x0 Cf x1
2Ch
f x1 Cf x2
2C$$$Ch
f xnK1 C f xn
2
= h2
f x0 Cf xn C2>k= 1
nK1f xi .
Exemplo 1 Calcule a integral
0
1
x2 dx
utilizando o método do trapézio com n = 10 intervalos. Definamos o integrando:
f:=x->x^2;O espaçamento dos intervalos, para n = 10, é dado por
n:=10:a:=0:b:=1.:h:=(b-a)/n;
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
Definimos a malha de nC1 pontos:X:=[seq(a+i*h,i=0..n)];
Implementemos a fórmula do método do trapézio:S:=h/2*(f(X[1])+f(X[n-1])+2*sum(f(X[k]),k=2..n));
Definamos um procedimento que tem como entrada uma função, um intervalo, e o número de nós.
restart:trapezio:=proc(f,a,b,n) local h,k,X,S,g; g:=unapply(f,x): h:=(b-a)/n; X:=[seq(a+i*h,i=0..n)]; S:=evalf(h/2*(g(X[1])+g(X[n-1])+2*sum(g(X[k]),k= 2..n))); end:G:=x^2;
Portanto, com n = 20, trapezio(G,0,1,20);
Com n = 10000,trapezio(G,0,1,10000);
Observamos que a convergência para o valor correto 1/3 é muito lenta.
Erro no método trapezoidal simples
Esta dedução segue este vídeo (http://www.youtube.com/watch?v=NAIGuh5I3Io) do Prof. L. A. F. Coelho. Consideremos o erro cometido na aplicação do método trapezoidal aplicado a um único intervalo. Se pudéssemos saber que a primitiva de f x é F x , poderíamos escreverpara a integral no intervalo x0, x0Ch :
Iexata=x0
x0Ch
f x dx = F x0Ch KF x0 .
A integral aproximada é dada pela fórmula da área do trapézio:
Iaprox=h2
f x0 C f x0Ch .
O erro cometido na integração numérica é então definido porE = IexataK Iaprox .
Usando a expansão em série de Taylor temos
F x0Ch = F x0 CF' x0 hCF '' x0
2!h2
C F ''' x0
3!h3
C$$$ .
Como F ' x = f x ,
F x0Ch = F x0 C f x0 hCf ' x0
2h2
Cf '' x0
3! h3
C$$$ .
Portanto, a integral exata torna-se
Iexata= f x0 hCf ' x0
2h2
Cf '' x0
3! h3
C$$$ .
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
Por outro lado,
f x0Ch = f x0 C f ' x0 hCf '' x0
2h2
Cf ''' x0
3! h3
C$$$ ,
de modo que
Iaprox= h2
2 f x0 C f ' x0 hCf '' x0
2h2
Cf ''' x0
3! h3
C$$$
e
E = IexataK Iaprox=f '' x0
3! h3
Kf '' x0
4h3
CO h4 =Kf '' x0
12h3
CO h4 .
Truncando a série em Oh4 temos que, de acordo com o teorema de Taylor, o erro é dado por
E =Kf '' ξ
12h3,
onde x0! ξ! x0Ch.
Erro no método trapezoidal composto
Somando os erros individuais para os diversos trapézios temos, usando o fato de que para nC1 nós igualmente espaçados, h = bKa /n,
Et =KbKa 3
12 n3 >i = 1
n
f '' ξi ,
sendo ξium número no intervalo xi K1, xi . Na prática podemos estimar o erro maximizando
f '' x no intervalo a, b e escrever:
Emax=bKa 3
12 n3 >i = 1
n
maxi = 1,...,n f '' ξi ( bKa 3
12 n2 maxa%x%b f '' x
Na fórmula acima o somatório começa em i = 1, pois temos nC1 pontos e n intervalos. Cada ξi é definido dentro do intervalo xi, x i C1 .
Exemplo 1 Utilizando a regra do trapézio, calcule
1
2
eKx3Cx2 dx
com erro de no máximo 10K5. Solução Para calcular o erro máximo cometido devemos maximizar a segunda derivada de
f = eKx3Cx2 , ou seja, restart:f:=exp(-x^3+x^2);
A segunda derivada desta função é dada por d2f:=diff(f,x$2);
Façamos o gráfico desta função:plot(abs(d2f),x=1..2);
Vemos imediatamente que o valor máximo procurado MM = max f '' x , a % x%b = f '' 1 ,
ou seja,
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
M:=abs(evalf(subs(x=1,d2f)));Como
E max=bKa 3
12 n2 M ,
devemos agora calcular n : eq:=10^(-5)=(2-1)*M/(12*n^2);sol:=solve(eq,n);
Portanto, se n = 159 o erro será garantidamente menor que 10K5. Calculemos agora a integral, usando a fórmula
Iaprox = h2
f x0 C f xn C2>k= 1
nK1f xi .
Temos aqui :n:=159: a:=1:b:=2: h:=(b-a)/n:F:=x->exp(-x^3+x^2);X:=[evalf(seq(a+h*i,i=0..159))]:
Portanto, Iap:=h/2*(F(X[1])+F(X[160])+2*sum(F(X[i]),i=2..159) );
O Maple fornece uma aproximação ótima para esta integral:Iap2:=evalf(int(F(x),x=1..2));
Comparando este resultado com o do método do trapézio temos:Erro:=Iap-Iap2;
Ou seja, aproximadamente 2.8 #10K6 < 10K5.
Exemplo 2 Utilizando a regra do trapézio, calcule
0
1sin x
x dx
com erro de no máximo 10K5/2.
restart:f:=sin(x)/x;
A segunda derivada desta função é dada por d2f:=diff(f,x$2);
Façamos o gráfico desta função:plot(abs(d2f),x=0..1);
Vemos imediatamente que o valor máximo procurado MM = max f '' x , a % x%b = f '' 0 ,
ou seja,
M:=abs(evalf(limit(d2f,x=0)));Como
E max=bKa 3
12 n2 M ,
devemos agora calcular n : eq:=10^(-5)/2=(1-0)*M/(12*n^2);sol:=solve(eq,n);
Portanto, se n = 75 o erro será garantidamente menor que 10K5/2 Calculemos agora a integral, usando a fórmula
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
Iaprox = h2
f x0 C f xn C2>k= 1
nK1f xi .
Temos aqui :n:=75: a:=0:b:=1: h:=(b-a)/n:F:=x->sin(x)/x;X:=[evalf(seq(a+h*i,i=0..75))]:
Portanto, Iap:=h/2*(limit(F(t),t=0)+F(X[76])+2*sum(F(X[i]),i= 2..75));
O Maple fornece uma aproximação ótima para esta integral:Iap2:=evalf(int(F(x),x=0..1));
Comparando este resultado com o do método do trapézio temos:Erro:=Iap-Iap2;
Ou seja, aproximadamente 0.446 #10K5 < 10K5.
Exercício1. Calcule a integral
1
3
sin x
x2 dx
utilizando o método trapezoidal composto com erro menor que 10K6.
Métodos de Simpson-KeplerO método do trapézio consistia em aproximar a área sob a curva, entre a, b por um polinômio interpolante de primeiro grau (reta). A partir de agora vamos generalizar este procedimento utilizando polinômios de graus superiores.
Método de Simpson 1/3 simples
Aqui aproximamos a função f x por um polinômio do segundo grau p2 x , como mostrado
na Fig. 1 Ou seja,
I =a
b
f x dxya
b
p2 x dx ,
com p2 x =a0Ca1 x Ca2 x
2 .
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
Fig. 1
Necessitamos de três pontos que serão interpolados por p2 x . Além de a e b escolheremos o
ponto médio
m= aCb
2 .
Os coeficientes deste polinômio são definidos pelas condições de interpolação: p a = f a , p m = f m , p b = f b
Mais explicitamente, restart:p:=x->a0+a1*x+a2*x^2;EQ:=[p(a)=f(a),p((a+b)/2)=f(m),p(b)=f(b)];sol:=solve(EQ,[a0,a1,a2]);
O polinômio interpolante é então dado por assign(sol):p(x);
A integral correspondente é dada por
int(p(x),x=a..b);simplify(%);factor(%);
Portanto,
I =a
b
f x dxya
b
p2 x dx =16
bKa 4 f m Cf a Cf b .
Como h =bKa
2 ,
I =a
b
f x dxya
b
p2 x dx =h3
f a C4 f m Cf b
Método de Simpson 1/3 composto
O método desenvolvido acima pode agora ser aplicado de maneira composta. Na Fig. 2 ilustramos tal aplicação para n = 6.
Fig. 2 (Extraído de Pauls Online Notes)
Temos então três parábolas que interpolam cada tríade x0 , x1 , x2 ,
x2 , x3 , x4 , x4 , x5 , x6 .
e a integral total é a soma das áreas sob cada parábola:I = I1CI2C I3
com
I1 =h3
f x0 C4 f x1 C f x2 ,
I2 =h3
f x2 C4 f x3 C f x4 ,
I1 =h3
f x4 C4 f x5 Cf x6 .
Portanto,
I =h3
f x0 C4 f x1 C2 f x2 C4 f x3 C2 f x4 C4 f x5 Cf x6 .
Notemos que os pontos com índices ímpares têm coeficiente 2 e os índices têm coeficiente 4. De modo geral temos
I =h3
f x0 C4 >j = 1
n2
f x2 j K1 C2 >j = 1
n2
K1
f x2 j Cf xn .
Para implementar esta fórmula no Maple, devemos notar que os pontos da malha têm índices que começam com índice 1 e não 0. Vamos então reescrever a fórmula acima como
I =h3
f x1 C4 >j = 1
n2
f x2 j C2 >j = 1
n2
K1
f x2 j C1 C f xnC1 .
Exemplo 3 Resolvamos novamente a integral do Exemplo 1
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
1
2
eKx3Cx2 dx ,
agora utilizando o método de Simpson 1/3. Tomemos 158 intervalos, para fazer uma comparação deste resultado com o do Exemplo 1.
restart:f:=x->exp(-x^3+x^2);
a:=1:n:=158:h:=evalf(1/n):x:=[evalf(seq(a+h*i,i=0..n))]:
A integral aproximada é então dada porIap1 :=(1/3)*h*(f(x[1])+4*(sum(f(x[2*j]),j=1..(1/2) *n))+2*(sum(f(x[2*k+1]),k=1..(1/2)*n-1))+f(x[n+1]));
O valor dado pelo Maple é:Iap2:=evalf(int(f(t),t=1..2));
O erro é dado por Iap1-Iap2;
Ou seja, o erro diminuiu quadraticamente, relativamente àquele cometido pelo método trapezoidal, com um número similar de intervalos.
De fato, o erro no método de Simpson 1/3 composto é dado por
E =bKa 5
180 n4max
ξ2 a, bf 4
ξ .
Exemplo 4Resolvamos a integral
0
1
eKsin x dx ,
pelo método de Simpson 1/3 composto, com erro de até 10K5. restart:f:=exp(-sin(x));d4:=diff(f,x$4);plot(d4,x=0..1);
Certamente o maior valor em módulo desta função é 3, em x = 0. Entãoeq:=10^(-5)=1/(180*n^4)*3;
e o número de intervalos deve sernn:=fsolve(eq,n,0..10);
Portanto, devemos ter ao menos n = 8 (n deve ser sempre um número par neste método). Definamos
F:=unapply(f,x);Com
a:=0:n:=8:h:=evalf(1/n);x:=[evalf(seq(a+h*i,i=0..n))];
a integral aproximada é então dada por Iap1 :=(1/3)*h*(F(x[1])+4*(sum(F(x[2*j]),j=1..(1/2) *n))+2*(sum(F(x[2*k+1]),k=1..(1/2)*n-1))+F(x[n+1]));
A integral dada pelo Maple é Iap2:=evalf(int(F(t),t=0..1));
OOOO OOOO
OOOO OOOO OOOO OOOO
O erro é Iap2-Iap1;
que é menor do que o limite superior estabelecido (como esperado).
Método de Simpson-Kepler 3/8 simples
Aqui aproximamos a função f x por um polinômio do terceiro grau p3 x , que intepola 4
pontos entre a = x0 e x3 = b, como mostrado na Fig. 3.
x
(x ,y )
(x ,y )
(x ,y )
(x ,y )
x x x x
1 1
2 2
3 3
0 1 2 3
y = f(x)y = p(x)
Fig. 3 Regra de Simpson 3/8
Ou seja,
I =x0
x3
f x dxyx0
x3
p3 x dx ,
com p2 x = a0Ca1 x Ca2 x
2Ca3 x
3.
Suponhamos que os quatro pontos que serão interpolados por p3 x são igualmente espaçados:
x0 = a , x1 = aCh, x2 = aC2 h , x3 = aC3 h .
Ou seja, Fazendo x0 = a e x3 = b, os coeficientes deste polinômio são definidos pelas condições de
interpolação: p x0 = f x0 , p x1 = f x1 , p x2 = f x2 , p x3 = f x3
Mais explicitamente, restart:X:=[a,a+h,a+2*h,a+3*h];
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO OOOO OOOO
Y: =map( f , X) ;Geramos agora o polinômio que interpola estes pontos:
p:=interp(X,Y,x);Integrando no intervalo x0, x1 temos
I1:=int(p,x=a..a+3*h);Este resultado pode ser consideravelmente simplificado:
I2:=simplify(I1);
Portanto,
I =x0
x3
f x dxyx0
x3
p3 x dx =a
aC3 h
p3 x dx
=38
h f a C3 f aCh C3 f aC2 h Cf aC3 h ,
com h =x3Kx0
3 .
Método de Simpson-Kepler 3/8 composto
Fazendo a composição do método de Simpson-Kepler 3/8 no intervalo a, b , com n = 3 m intervalos de comprimento
h =bKa3 m
,
temos
I =3 h8 >
k= 1
m
f x3 kK3 C3 f x3 kK2 C3 f x3 kK1 C f x3 k .
O erro tem a seguinte expressão:
E =KbKa fˆ4 ξ h4
80 ,
com ξ2 a, b . Este erro é da mesma ordem daquele cometido no método de Simpson 1/3. Notemos que o número de intervalos agora pode ser ímpar, mas deve ser divisível por 3.
Exemplo 5Resolvamos a integral
0
1
eKsin x dx ,
pelo método de Simpson 3/8 composto, com erro de até 10K5. restart:f:=exp(-sin(x));d4:=diff(f,x$4);plot(d4,x=0..1);
Certamente o maior valor em módulo desta função é 3, em x = 0. Entãoeq:=10^(-5)=1/(80*n^4)*3;
e o número de intervalos deve sernn:=fsolve(eq,n,0..10);
Portanto, devemos ter ao menos n = 9 (n deve ser sempre um número divisível por 3 neste
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
OOOO OOOO
método). DefinamosF:=unapply(f,x);
Com a:=0:n:=9:m:=n/3;h:=evalf(1/n);x:=[evalf(seq(a+h*i,i=0..n))];
a integral aproximada é então dada por (lembrando que devemos deslocar o índice de uma unidade para fazer a implementação):
Iap1 :=(3/8)*h*(sum(F(x[3*k-2])+3*F(x[3*k-1])+3*F(x [3*k])+F(x[3*k+1]),k=1..m));
A integral dada pelo Maple é Iap2:=evalf(int(F(t),t=0..1));
O erro é Iap2-Iap1;
que é menor do que o limite superior estabelecido (como esperado).
Exercícios