TCC LuizFernando

UNIVERSIDADE FEDERAL DE SANTA CATARINA
ESTUDO DE MTODOS ITERATIVOS

NO-ESTACIONRIOS DE RESOLUO DE
GRANDES SISTEMAS LINEARES ESPARSOS
AUTOR: LUIZ FERNANDO SPILLERE DE SOUZA
2001-2 || Estudo de Mtodos Iterativos No-Estacionrios de Resoluo de Grandes Sistemas Lineares Esparsos || UFSC
UNIVERSIDADE FEDERAL DE SANTA CATARINA
DEPARTAMENTO DE INFORMTICA E ESTATSTICA
CURSO DE CINCIAS DA COMPUTAO
TTULO: ESTUDO DE MTODOS ITERATIVOS NO-ESTACIONRIOS DE
RESOLUO DE GRANDES SISTEMAS LINEARES ESPARSOS
AUTOR: LUIZ FERNANDO SPILLERE DE SOUZA
ORIENTADOR: PROF. JABER C. DE OLIVEIRA
BANCA EXAMINADORA: PROF. DANIEL SANTANA DE FREITAS
PROF. JLIO FELIPE SZEREMETA
Florianpolis, 02 de maio de 2002
1
RESUMO
Este trabalho tem por objetivo comparar vrios precondicionadores para

os sistemas lineares esparsos resultantes da aplicao do mtodo dos elementos
espectrais a equaes diferenciais parciais. Aps introduzir os mtodos iterativos
estacionrios, exploramos os mtodos iterativos no estacionrios, com nfase nos
gradientes conjugados.
ABSTRACT
We present comparisons among several preconditioning techniques for

conjugate gradients used for solving sparse linear systems obtained from spectral
element PDE solvers. After introducing the stationary iterative methods, we explore the
nonstationary iterative methods, with emphasis in the conjugate gradients.
2
SUMRIO
Resumo 2
Abstract 2
Sumrio 3
Objetivos Gerais 4
1. Resoluo de Sistemas Lineares por Mtodos Diretos 5
1.1. Mtodo de Eliminao de Gauss 5
1.2. Mtodo de Eliminao de Gauss-Jordan 6
1.3. Mtodo de Gauss-Jordan na Inverso de Matrizes 7
1.4. Mtodo de Crout 7
1.5. Consideraes sobre Mtodos Diretos 8
2. Resoluo de Sistemas Lineares por Mtodos Iterativos 9
2.1. Introduo aos Mtodos Iterativos 9
2.1.1. Definies 11
2.1.2. Decomposio da Matriz A 12
2.2. Mtodo de Jacobi 13
2.3. Mtodo de Gauss-Seidel 14
2.4. Mtodos de Relaxao 15
2.4.1. Mtodo de Jacobi com Relaxao 16
2.4.2. Mtodo de Gauss-Seidel com Relaxao 17
2.4.3.Determinao do Fator de Relaxao 19
2.5. Mtodos Descendentes 19
2.5.1. Mtodo da Descendente mais Inclinada 22
2.5.2. Mtodo dos Gradientes Conjugados 23
2.5.3. Mtodo dos Gradientes Biconjugados 26
2.6. Armazenamento de Matrizes 28
2.6.1. Armazenamento Morse 29
2.7. Precondicionamento de Matrizes 31
2.7.1. Precondicionamento pela Diagonal Principal de A 34
2.7.2. Precondicionamento pelo Mtodo S.S.O.R. 35
2.7.3. Precondicionamento pelo Mtodo da Decomposio LU Incompleta. 37
2.7.4. Precondicionamento pela minimizao de I - AW na norma de Frobenius. 38
2.8. Consideraes sobre Mtodos Iterativos 41
3. Aplicao Prtica de Mtodos Iterativos 42
3.1. Teste de Funcionamento 42
3.2. Aplicao dos Mtodos Iterativos na Resoluo de Equaes Diferenciais 47
3.3. Aplicao dos Mtodos Iterativos na resoluo de matrizes geradas por Mtodos Espectrais 53
Concluses 56
Anexos 57
1) Implementao do Mtodo de Jacobi 57
2) Implementao do Mtodo de Gauss-Seidel 57
3) Implementao do Mtodo de Jacobi com Relaxao 58
4) Implementao do Mtodo de Gauss-Seidel com Relaxao 58
5) Implementao dos Mtodos Iterativos Estacionrios 59
6) Implementao do Mtodo de Gradientes Conjugados 65
7) Implementao do Mtodo de Gradientes Biconjugados 66
8) Implementao dos Precondicionadores 67
9) Implementao dos Mtodos Iterativos Estacionrios 71
Referncias Bibliogrficas 83
3
OBJETIVOS GERAIS
O objetivo deste trabalho estudar os mtodos numricos que

contemplem fundamentalmente a resoluo de sistemas lineares, focalizando no
aspecto da implementao computacional.
Para isso, aps uma breve apresentao dos mtodos diretos,

pretendemos inicialmente estudar os mtodos iterativos clssicos, com a finalidade de
familiarizar-nos com a aplicao de mtodos iterativos para a resoluo de sistemas
lineares esparsos.
Aps este estudo inicial, pretendemos estudar os denominados mtodos

no-estacionrios a fim de investigar as diferentes alternativas dos mtodos baseados
em gradientes visando resolver eficientemente grandes sistemas lineares esparsos
que resultam da soluo numrica de equaes diferenciais.
Nesse contexto, devemos tambm nos preocupar com as formas de

armazenamento de matrizes e o pr-condicionamento das mesmas, para que
possamos aplicar estes mtodos com a garantia de sua convergncia.
4
1. RESOLUO DE SISTEMAS LINEARES POR MTODOS DIRETOS
Nos mtodos diretos, a soluo obtida por uma seqncia finita de

operaes, que produziria a soluo exata se no houvesse os erros de arredondamento
decorrentes da aritmtica de ponto flutuante. A exigncia de obtermos uma soluo
correta traz luz a questo dos erros de representao finita dos nmeros reais e de
como estes se propagam atravs dos clculos. A minimizao do nmero de operaes
desejvel tanto a nvel de reduzir o tempo computacional necessrio para obter-se a
soluo do sistema, quanto no sentido de evitar maiores propagaes de erros de
representao. Neste aspecto, tirar vantagem da estrutura da matriz o ponto central no
desenvolvimento dos algoritmos.
Vamos ento, apresentar rapidamente os mais usuais mtodos diretos

para soluo numrica de sistemas lineares. Esses mtodos so conhecidos como
mtodos de eliminao e mtodos de fatorao.
1.1. Mtodo de Eliminao de Gauss
Dado um sistema linear qualquer da forma:
a11 x1 + a12 x 2 + L + a1n x n = b1

a x + a x + L + a x = b
21 1 22 2 2n n 2

M M M
a n1 x1 + a n 2 x 2 + L + a nn x n = bn
o mtodo de Gauss consiste em fazer operaes entre linhas deste sistema at

chegarmos a um novo sistema (que ter a mesma soluo que o inicial) com a forma
triangular:
a'11 x1 + a'12 x 2 + L + a'1n x n = b' 1

+ a' 22 x 2 + L + a' 2 n x n = b' 2

M
a' nn x n = b' n
5
Claro que a determinao da soluo do sistema linear triangular bvia
e direta: o valor de x n j est determinado na ltima equao. O valor de x n 1 ser
determinado na penltima, substituindo-se o valor de x n ; o valor de x n 2 ser obtido na
penltima linha com os valores j determinados de x n e x n 1 , e assim por diante at
determinamos x1 . Ento, desde que se consiga levar o sistema linear inicial na forma
triangular sem alterar suas solues, o nosso problema est resolvido.
1.2. Mtodo de Eliminao de Gauss-Jordan
Este mtodo uma complementao ao mtodo de Gauss. Ele transforma

o sistema dado em um outro diagonal, isto , onde todos os elementos fora da diagonal
so nulos. O mtodo de Gauss exigia apenas que se chegasse forma triangular.
Sabemos que o um sistema linear pode ser escrito na forma de uma

matriz aumentada:
a11 a12 L a1n M b1

a 21 a 22 L a 2 n M b2

a a La M b
n1 n 2 nn n
Ento procuraremos chegar a outra matriz, com os passos do mtodo de

eliminao de Gauss, com a forma diagonal:
a1 0 L 0 M 1

0 a2 L0 M 2
,

0 0L a M
n n
que ser associada a um sistema na forma:
1 2 3
x1 = x2 = x1 =
1 2 3
6
Isto quer dizer que se conseguirmos chegar da matriz aumentada para a
forma diagonal, a soluo do sistema imediata. Podemos, ainda, dividindo cada linha
pelo elemento da diagonal, chegar matriz identidade.
1.3. Mtodo de Gauss-Jordan na Inverso de Matrizes
Uma anlise rpida do mtodo de eliminao de Gauss nos mostra que,

ao invs de resolvermos um sistema linear completo, resolvemos, na realidade, um
sistema triangular. Isso quer dizer que, a partir do sistema linear dado, geramos outro,
que conserva suas solues originais.
De um modo mais formal, podemos dizer que samos de um sistema

geral
Ax = b
e chegamos a outro sistema:
A' x = b'
cuja matriz A' triangular, mas as solues so as mesmas que do sistema linear inicial.
Naturalmente a passagem de uma forma outra no pode ser arbitrria.

Para termos a garantia de que as razes so preservadas s permitimos operaes
elementares sobre as linhas do sistema. Cada uma dessas operaes, equivale
multiplicao da matriz do sistema por uma matriz elementar.
1.4. Mtodo de Crout
Observamos que no caso do mtodo de Gauss, podemos transformar uma

dada matriz A em outra A', triangular superior. Vamos agora, explicitar o que acontece
com as matrizes definidas anteriormente, para obter um novo mtodo direto, chamado
mtodo compacto de Banachievicz ou Doolittle. Ele representa a fatorao da matriz A
no produto L.U onde L triangular inferior e U triangular superior, isto :
7
Da mesma forma que fatoramos A em um produto L.U, , podemos
escrever A = L.U onde, agora fixamos os elementos u ii = 1 , fazendo com sejam
calculados no processo. Essa fatorao recebe o nome de mtodo de Crout .
1.5. Consideraes sobre Mtodos Diretos
Apresentamos os mtodos diretos, e estes, aps um certo nmero de

operaes fornecem a soluo exata de um sistema, pelo menos teoricamente. Isto
porque, quando fazemos muitas divises e multiplicaes, introduzimos erros de
arredondamento produzidos pelo computador. Por isso, os mtodos diretos s so
indicados para o caso em que temos um sistema pequeno, de modo que, em sua soluo
tenhamos de fazer um nmero reduzido de operaes; seno a soluo que vamos obter
muitas vezes se afasta da soluo real.
Para os sistemas maiores, esse efeito diminui com outros mtodos que
garantem em certos casos, qualquer preciso desejada. Estes mtodos so chamados
mtodos iterativos, onde usamos uma aproximao inicial da soluo e a melhoramos
quantas vezes sejam necessrias para chegarmos a uma preciso satisfatria.
8
2. RESOLUO DE SISTEMAS LINEARES POR MTODOS ITERATIVOS
Um mtodo iterativo quando fornece uma seqncia de aproximantes

da soluo, onde cada um dos quais obtido dos anteriores pela repetio do mesmo
tipo de processo. Um mtodo iterativo estacionrio se cada aproximante obtido do
anterior sempre pelo mesmo processo. Quando os processos variam de passo para passo
mas se repetem ciclicamente de n em n passos dizemos que o processo n-cclico.
Agrupando-se os s passos de cada ciclo num nico passo composto, obtemos um
mtodo estacionrio.
No caso de mtodos iterativos precisamos sempre saber se a seqncia

que estamos obtendo est convergindo ou no para a soluo desejada. Alm disso,
precisamos sempre ter em mente o significado de convergncia, como ser visto
posteriormente.
Os mtodos iterativos devem ser aplicados quando a matriz dos

coeficientes esparsa. Matrizes esparsas so aquelas que possuem muitos elementos
iguais a zero. Podem ser usados tambm para reduzir os erros de arredondamento na
soluo obtida por mtodos exatos e tambm podem ser aplicados para resolver
equaes diferenciais.
2.1. Introduo aos Mtodos Iterativos
Vamos estudar mtodos iterativos para a soluo de sistemas de equaes

lineares do tipo:
Ax = b , (1)
onde A uma matriz quadrada sendo que A n x n e b so vetores sendo que b n :
a11 x1 + a12 x 2 + L + a1n x n = b1

a x + a x + L + a x = b
21 1 22 2 2n n 2

M M M
a n1 x1 + a n 2 x 2 + L + a nn x n = bn
9
Um mtodo iterativo necessita de um nmero infinito de operaes para
fornecer a soluo de um sistema. Assim, a partir de uma estimativa inicial x ( 0 ) so
geradas sucessivos vetores x ( 1 ) , x ( 2 ) ,K , x ( k ) onde:
lim x ( k ) = x (2)
k
Como na realidade no possvel efetuar um nmero infinito de

operaes, os mtodos iterativos so interrompidos, o que implica em termos uma
soluo aproximada do sistema, porm, perfeitamente boa para a finalidade pretendida.
As principal vantagem dos mtodos iterativos esta no fatos destes

produzirem boas aproximaes com relativamente poucas iteraes e a matriz . Outra
vantagem que temos que a matriz A nunca alterada no decorrer do processo iterativo,
permitindo economia de memria e tempo de clculo. Esta caracterstica permite que
estes sejam particularmente adaptados para resolver sistemas de grandes dimenses com
matrizes esparsas.
De forma geral, os mtodos iterativos podem ser escritos como:
x ( k +1 ) = Gk x ( k ) + c k , k = 0,1, ..., (3)
onde G k uma matriz conhecida (matriz de iterao) e c k um vetor.
A equao (3) tambm pode ser vista como:
x ( k +1 ) = x ( k ) + Gk x ( k ) x ( k ) + c k
x( k +1 ) = x( k ) + ( Gk I )x( k ) + ck
x ( k +1 ) = x ( k ) + h ( k ) , (4)
onde h ( k ) = ( Gk I )x ( k ) + c k .
10
2.1.1. Definies
Definio: Um mtodo iterativo dito linear se x ( k +1 ) depende de x ( j ) ,

onde 0 j k . J um mtodo iterativo dito no linear se x ( k +1 ) independe de x ( j ) ,
onde 0 j k .
Definio: Um mtodo iterativo dito estacionrio se Gk e c k dependem
de k. J um mtodo iterativo dito no estacionrio se Gk e c k independem de k.
A expresso geral dos mtodos estacionrios dada por:
x ( k +1 ) = Gx ( k ) + c , k = 0,1, ..., (5)
considerando assim que G e c dependem do contador de iteraes k.
J a expresso gral dos mtodos no-estacionrios dada por:
x ( k +1 ) = Gk x ( k ) + c k k = 0,1, ..., (6)
considerando assim que Gk e c k independem do contador de iteraes k.
Definio: Um mtodo iterativo convergente se b e qualquer x ( 0 ) , a

sucesso x ( k ) convergir para um limite, independente de x ( 0 ) .
Definio: Um mtodo iterativo consistente se x ( k +1 ) = Gx ( k ) + c k e o
sistema: x = Gx + c (7)
tenham a mesma soluo.
A consistncia obriga que os sistemas (1) e (7) tenham a mesma soluo.
Como Ax = b podemos escrever:
x = A 1b
Temos tambm de x = Gx + c que:
11
x Gx = c
( I G )x = c
c = ( I G ) A 1b
2.1.2. Decomposio da Matriz A
Vamos agora nos preocupar em obter a matriz G. Uma forma usual de

construir esta matriz partir de uma decomposio aditiva da matriz A em duas
matrizes M e N tais que:
A=M-N (8)
Como Ax = b , temos:
( M N )x = b
Mx = b + Nx (9)
Ento, o mtodo iterativo sugerido :
Mx ( k +1 ) = b + Nx ( k ) (10)
Este sistema eqivale a:
x ( k +1 ) = M 1 Nx ( k ) + M 1b ,
que comparado ao sistema (5), podemos fazer a seguinte identificao:
G = M 1 N e c = M 1b (11)
Fazendo algumas modificaes em G, veremos que:
N=MA
G = M 1 ( M A )
G = M 1 M M 1 A , I = M 1 M
e finalmente:
G = I M 1 A e c = M 1b (12)
12
2.2. Mtodo de Jacobi
Definimos as matrizes L, D e U onde L formada pela parte triangular

inferior, D formada pela diagonal e U formada pela parte triangular superior da
matriz A, isto :
Podemos ento escrever:
A = D + L +U
O mtodo de Jacobi consiste em escolher para matriz M a diagonal de A:
M = D = diag A
Assim, de (8) podemos verificar que:
N = -(L + U)
A matriz de iterao do mtodo de Jacobi dada por:
G J = M 1 .N
G J = D 1 . ( L + U )
G J = D 1 .( L + U ) (13)
O processo iterativo do mtodo de Jacobi definido por:
x ( k +1 ) = D 1 ( L + U )x ( k ) + D 1b , (14)
Da expresso geral dos mtodos estacionrios (5) podemos escrever:
13
n
+ ( bi aij x j
( k +1 ) (k ) (k )
xi = xi ) aii (15)
j =1
Com base em (15), teremos ento o algoritmo do mtodo de Jacobi:
Escolha do valor inicial x (0) para a soluo x;

para k = 1,2,3 ...
para i = 1,2,...,n
=0
para j = 1,2,..., n
se i j ento = + ai , j x (j k 1 )
fim para
= ( bi ) / ai ,i
fim para
x( k ) =
calcular erro;
fim
Este algoritmo foi implementado e testado em Pascal, e seu cdigo ser

mostrado em anexo.
2.3. Mtodo de Gauss-Seidel
O mtodo de Gauss-Seidel uma modificao do mtodo de Jacobi, que

( k +1 )
utiliza para o clculo de uma componente de xi o valor mais recente de xi .
Ento, a matriz M o tringulo inferior da matriz A, justamente para

aproveitar os valores mais recentes e j calculados de xi :
M = (L + D)
Assim, de (8) podemos verificar que:
N = -U
A matriz de iterao do mtodo de Gauss-Seidel dada por:
GGS = I M 1 .A
14
GGS = I ( L + D ) 1 .A (16)
O processo iterativo do mtodo de Gauss-Seidel definido por:
x ( k +1 ) = ( L + D ) 1 Rx ( k ) + ( L + D ) 1 b (17)
Da expresso geral dos mtodos estacionrios (5) podemos escrever:
i 1 n
+ ( bi aij x j aij x j
( k +1 ) (k ) ( k +1 ) (k )
xi = xi ) aii (18)
j =1 j =i
Com base em (18), teremos ento o algoritmo do mtodo de Gauss-

Seidel:

para k = 1,2,3 ...
para i = 1,2,...,n
=0
para j = 1,2,..., n
se j < i ento = + a i , j x (j k )
se j > i ento = + ai , j x (j k 1 )
fim para
xi( k ) = ( bi ) / ai ,i
fim para
calcular erro;
fim

mostrado em anexo.
2.4. Mtodos de Relaxao
Aplicando os mtodos at aqui estudados, descobriu-se que era possvel

acelerar ou retardar a convergncia de um mtodo, somando aos valores de x ( k ) um
certo fator de correo, ao qual chamamos de w . Modificando conveniente esta
15
correo, podemos ento antecipar ou retardar a evoluo das iteraes, modificando
com isto a convergncia do mtodo.
2.4.1. Mtodo de Jacobi com Relaxao
(k )
Se afetarmos a correo aplicada a xi de um fator w , teremos:
1 1 w
M = D e N= D L U (19)
w w
Modificando ento o parmetro de relaxao w , teremos:
w < 1 : Sub relaxao

w > 1 : Sobre relaxao
A Matriz de iterao de Jacobi com relaxao dada por:
G J ( w ) = I M 1 . A
1
1
GJ ( w ) = I .D .A
w
GJ ( w ) = I wD 1 .A
Como:
G J = I D 1 . A
D 1 .A = I G J ,
ento podemos dizer que:
G J ( w ) = I w( I G J )
G J ( w ) = I wI + wG J
G J ( w ) = ( 1 w )I + wG J (20)
Aplicando a correo ao mtodo de Jacobi, teremos ento a expresso:
n
+ w ( bi a ij x j
( k +1 ) (k) (k )
xi = xi ) aii (21)
j =1
16
Mostraremos ento o algoritmo do mtodo de Jacobi com relaxao:

Escolha o valor da relaxao w;
para k = 1,2,3 ...
para i = 1,2,...,n
=0
para j = 1,2,..., n
se i j ento = + ai , j x (j k 1 )
fim para
= ( bi ) / ai ,i
fim para
x ( k ) = x ( k 1 ) + w( x ( k 1 ) )
calcular erro;
fim

mostrado em anexo.
2.4.2. Mtodo de Gauss-Seidel com Relaxao
Aplicando a mesma idia ao mtodo de Gauss-Seidel, teremos:
1 1 w
M = D+L e N= D U (22)
w w
Modificando ento o parmetro de relaxao w , teremos:
w < 1 : Sub relaxao

w > 1 : Sobre relaxao
A Matriz de iterao de Gauss-Seidel com relaxao dada por:
17
GGS ( w ) = M 1 .N
1
1 1 w
GGS ( w ) = .D + L . .D U
w w
1 w
.D U
GGS ( w ) =
w , que multiplicados por w :
1 D
.D + L
w
GGS ( w ) =
(1 w)I UwD 1
I + LwD 1
(
GGS ( w ) = I + wD 1 L ) . ( (1 w)I wD U )
1 1
(23)
Aplicando a correo ao mtodo de Gauss-Seidel, teremos ento a

expresso:
i 1 n
+ w ( bi aij x j aij x j
( k +1 ) (k ) ( k +1 ) (k )
xi = xi ) aii (24)
j =1 j =i
Mostraremos ento o algoritmo do mtodo de Gauss-Seidel com

relaxao:

Escolha o valor da relaxao w;
para k = 1,2,3 ...
para i = 1,2,...,n
=0
para j = 1,2,..., n
se j < i ento = + a i , j x (j k )
se j > i ento = + ai , j x (j k 1 )
fim para
= ( bi ) / ai ,i
x ( k ) = x ( k 1 ) + w( x ( k 1 ) )
fim para
calcular erro;
fim

mostrado em anexo.
18
2.4.3.Determinao do Fator de Relaxao
A rapidez da convergncia dos mtodos iterativos depende agora do fator

de relaxao w , de forma que o valor deste parmetro torne G mnima. Este seria
ento, um valor de w timo.
Contudo, este processo revela-se, na maioria dos casos, muito difcil ou

at mesmo impossvel. Embora existam estudos tericos que permitem obter valores
timos de relaxao, para certas classes de matrizes, somos obrigados a determinar estes
valores de uma maneira um pouco mais experimental, para sermos assim mais
abrangentes.
Uma maneira possvel de se fazer isto determinar o fator de relaxao

timo por experimentao numrica. Neste processo, determina-se o nmero de
iteraes necessrios obteno de uma dada preciso, para vrios valores de w . Ento,
calcula-se aproximadamente o valor deste parmetro w que produz o menor nmero de
iteraes. O custo da otimizao efetuada pode assim, ser diminudo para a soluo de
muitos sistemas.
A figura a seguir esclarece melhor esta idia:
2.5. Mtodos Descendentes
Os mtodos descendentes baseiam-se em acatar uma soluo x de um

sistema do tipo Ax = b, pela propriedade da minimizao de uma norma apropriada do
erro.
19
Por isso, so chamados de mtodos de descendente, pois a partir de uma
soluo inicial x0, estes procuram a soluo correta pela diminuio do erro.
Seja a norma vetorial dada por:
2
x S
= ( x , Sx ) ,
onde: S nxn uma matriz simtrica positivo definida, x ( k ) uma soluo aproximada
e e ( k ) o erro.
As normas vetoriais so utilizadas para se medir comprimentos de

vetores. Estamos acostumados a utilizar esta noo ao fazermos uso do valor absoluto,
estando num domnio unidimensional. No caso de mtodos iterativos de sistemas
lineares, a nossa preocupao consiste em obter uma estimativa da proximidade de um
ponto situado num espao vetorial multidimensional. Podemos estender a noo de
proximidade atravs de normas vetoriais que medem comprimentos em espaos
multidimensionais. possvel estender este conceito para matrizes.
A norma-1 definida por:
n
= xi
1
x
i =1
A norma-2 ou norma euclidiana (no corpo dos reais) definida por:
1
n 2
= ( xi ) 2
2
x
i =1
2
Sabemos, evidentemente que e ( k ) 0 , e sendo que essa igualdade
S
verificada quando e ( k ) = 0, ou seja, quando x ( k ) = x .
Por outro lado, podemos ter que:
Ae ( k ) = r ( k ) , (25)
onde r ( k ) chamado de resduo, podemos deduzir que:
20
2
e( k ) = ( e ( k ) , Se ( k ) ) = ( r ( k ) , Rr ( k ) )
S
em que pusemos:
R = A T SA 1 (26)
Isto significa que fazendo a minimizao do erro medido na norma S ,
equivalente a minimizao do resduo medido na norma R .
Nos mtodos descendentes parte-se de uma estimativa inicial x ( 0 ) da

soluo e gera-se uma sucesso de vetores x ( 1 ) ,..., x ( k ) ,... , caminhando sucessivamente
2
ao longo da diminuio do erro e ( k ) , de modo que essa sucesso convirja para x.
S
Para mostrar o que acabamos de dizer, suponhamos que tenha-se obtido

um valor x ( k ) e que pretendamos avanar para um valor seguinte x ( k +1 ) , caminhando
numa direo de pesquisa, na qual chamaremos de pk, j conhecida. A equao
paramtrica da reta que passa por x ( k ) e tem a direo de pk :
y = x ( k ) + p ( k ) (27)
onde a iterao seguinte e o respectivo erro so dados por:
x ( k +1 ) = x ( k ) + k p ( k ) (28)
e ( k +1 ) = e ( k ) + k p ( k ) (29)
Tambm fcil concluir que o resduo evolui ao longo das iteraes de

acordo com a equao:
r ( k +1 ) = b Ax ( k +1 )
(
r ( k +1 ) = b A x ( k ) + k p ( k ) )
( )
r ( k +1 ) = b Ax ( k ) k Ap ( k )
r ( k +1 ) = r ( k ) k Ap ( k ) (30)
Por conseguinte, as iteraes so calculadas atravs de:
21
x ( k +1 ) = x ( k ) + k p ( k ) , k = 0,1,... (31)
em que o valor de k dado por:
k =
(r , RAp ( k ) )
(k )
(32)
( p ( k ) ,(AT RA)p ( k ) )
2.5.1. Mtodo da Descendente mais Inclinada
Uma das formas de se achar a melhor direo de pesquisa seria escolher

que em cada ponto x ( k ) , a direo de p ( k ) que desce mais, aquela que esta alinhada
2
com a direo do gradiente da funo e ( k ) , mas no seu sentido oposto. Por isso estes
S
mtodos so chamados da descencente mais inclinada, ou simplesmente, mtodos de
gradiente.
Desta forma, a expresso iterativa dos mtodos de gradiente dada por:
x ( k +1 ) = Gk x ( k ) + c k (33)
em que:
Gk = I k S
c k = k SA 1b
22
verificando assim, que estes so mtodos no-estacionrios, isto , Gk e c k independem
de k.
Apresentaremos agora o algoritmo do mtodo de Gradientes:
Inicializa:
Estimar x ( 0 ) ;
Fixar uma tolerncia
r ( 0 ) = b Ax ( 0 )
enquanto r ( k +1 ) r b 2 :
para k = 0,1,2, ... faa
k = ( r ( k ) , r ( k ) ) /( r ( k ) , Ar ( k ) )
x ( k +1 ) = x ( k ) + k r ( k )
r ( k +1 ) = r ( k ) k r ( k )
fim para
fim
2.5.2. Mtodo dos Gradientes Conjugados
O mtodo dos gradientes conjugados um mtodo iterativo descendente,

aplicado aos casos onde a matriz de iterao A simtrica positivo definida. Este
mtodo prev uma escolha mais criteriosa das direes de pesquisa p ( k ) .
Para exemplificar, tomemos um problema bidimensional n=(2). As

2 2
linhas e ( k ) = r( k ) = constante, so elipses concntricas com centro em x.
A A 1
23
Suponhamos que dispomos de uma estimativa inicial x ( 0 ) e que de
acordo com o mtodo da descida mais inclinada, partiramos deste ponto e
2
pesquisaramos o mnimo de e ( k ) , ao longo da direo r ( 0 ) , chegando a x ( 1 ) .
A
Observando a figura acima, verificamos que a melhor progresso de x ( 1 ) no seria a

direo mais inclinada, mas sim uma direo p ( 1 ) que apontasse para o centro da elipse.
De fato, o novo ponto minimizador x ( 2 ) coincidiria com a soluo exata

de x, e assim o processo iterativo terminaria com apenas duas iteraes. Podemos,
ento, desta forma, escolher a posio ( 1 ) como:
p(1 ) = x x(1 ) (34)
Como se pode ver, atendendo a ortogonalidade dos resduos sucessivos

verificados anteriormente, temos:
0 = ( r ( 1 ) ,r ( 0 ) )
= ( r (1) , p( 0 ) )
= ( b Ax ( 1 ) , p ( 0 ) )
= ( A ( x x ( 1 ) ), p ( 0 ) )
de tal forma que:
( p ( 1 ) , Ap ( 0 ) ) = 0 (35)
As direes de busca so dadas por:
p ( k +1 ) = r ( k +1 ) + k p k (36)
onde dado por:
k =
(r ( k +1 )
, r ( k +1 ) ) (37)
(r (k )
,r ( k ) )
As iteraes do mtodo dos gradientes conjugados satisfazem a seguinte
estimativa de erro:
24
(cond A) 12 1 ( 0 )
e( k ) 2 e (38)
A (cond A) 12 + 1 A
2
Com isso, podemos ver que o mtodo dos gradientes conjugados calcula
a soluo exata em n iteraes. Sendo assim, por que ento considerar este mtodo
como iterativo e no como direto? A resposta a esta questo est no fato que a utilizao
deste mtodo em aritmtica de preciso finita, introduz erros de arredondamento que
destroem a exata conjugacidade das direes p ( k ) e a exata ortogonalidade dos resduos
r(k ) .
Nestas circunstncias, no certo que se obtenha a soluo exata em um

nmero finito de iteraes. Neste caso, recomendvel efetuar-se as iteraes
necessrias que satisfaam a critrios de convergncia adequados. Desta forma, este
mtodo que , em principio direto, adquire uma forma tipicamente iterativa.
Apresentaremos agora o algoritmo do mtodo de Gradientes

Conjugados:
Ler A, b
Estimar x ( 0 ) ;
Fixar uma tolerncia
k = 0
r ( 0 ) = b Ax ( 0 )
p( 0 ) = r ( 0 )
enquanto r ( k +1 ) < b 2 faa:
2
k=k+1
( )(
k = p ( k ) , r ( k ) / p ( k ) , Ap ( k ) )
x ( k +1 )
=x (k )
+k p (k )
r ( k +1 )
=r (k )
k Ap ( k )
2 2
k = r ( k +1 ) r( k )
p ( k +1 ) = r ( k +1 ) + k p ( k )
fim enquanto

mostrado em anexo.
25
2.5.3. Mtodo dos Gradientes Biconjugados
O mtodo dos Gradientes Biconjugados uma extenso do mtodo dos

gradientes conjugados, que capaz de resolver problemas onde as matrizes A no tem
que ser necessariamente simtricas positivo definidas. Embora a teoria desenvolvida
para esta classe de mtodos esteja ainda em fase de construo, podemos
simplificadamente mostrar como o mtodo funciona.
Como o prprio nome indica, este mtodo vai possuir duas direes de
~
pesquisa, sendo aqui denotadas por pk e p k , que podem ser calculadas
respectivamente como:
p ( k +1 ) = r ( k +1 ) + k p k (39)
~ ( k +1 ) ~ ( k +1 ) ~
p =r + k +1 p k (40)
Tambm teremos dois resduos, que sero calculados como:
r ( k +1 ) = r ( k ) k Ap ( k ) (41)
~ ( k +1 ) ~(k ) ~ (k )
r =r k AT p (42)
sendo que os coeficientes e , podem ser obtidos:
~ ( k +1 ) ( k +1 )
r ,r
k = (43)
~ (k )

p , Ap ( k )

~ ( k +1 ) ( k +1 )
r ,r
k = (k ) (44)
~
r , r ( k )

26
Notemos que, se a matriz A simtrica e positivo definida, ento
~ ~
p k = p k e r k = rk , e o mtodo dos gradiente biconjugados se torna igual ao mtodo
dos gradientes conjugados.
Apresentaremos agora o algoritmo do mtodo de Gradientes Biconjugados:
Ler A, b
Estimar x ( 0 ) ;
Fixar uma tolerncia
k = 0
r (1) = p(1) = b
~ (1) ~ (1)
r =p =b
~ T(1)
1 = r r (1)
2
k=k+1
~T ( k )
( k ) = p Ap ( k )
k = ( ( k ) ) / ( ( k ) )
r ( k +1 ) = r ( k ) k Ap ( k )
x ( k +1 ) = x ( k ) + k p ( k )
~ ( k +1 ) ~(k ) ~ (k )
r =r k AT p
~ T ( k +1 )
( k +1 )
= r r ( k +1 )
k = ( k +1 ) ( k )
p ( k +1 ) = r ( k +1 ) + k +1 p ( k )
~ ( k +1 ) ~ ( k +1 ) ~ (k )
p =r + k +1 p
fim enquanto

mostrado em anexo.
27
2.6. Armazenamento de Matrizes
Os mtodos de resoluo de sistemas lineares vistos at o presente

momento foram desenvolvidos num contexto de matrizes cheias, onde a questo da
eventual esparsidade da matriz no foi explorada. Neste tpico vamos desenvolver uma
metodologia que permita adaptar algoritmos escritos para matrizes cheias a matrizes
esparsas, que so potencialmente as que encontramos nos problemas de interesse.
As matrizes podem ser catalogadas pela forma que seus coeficientes no-
nulos se distribuem. Dividiremos as matrizes quanto forma em trs classes que cobrem
todas as formas que foram mencionadas e que estaro relacionadas diretamente com o
tipo de mtodo utilizado na resoluo do sistema linear associado. So elas:
a) matrizes tipo banda varivel montona: usadas no contexto de

mtodos diretos de resoluo pois armazenam todos os coeficientes situados no interior
da banda o que j prev a transformao de coeficientes inicialmente nulos por valores
no-nulos durante o processo de eliminao/fatorao. So utilizadas tambm no
contexto de mtodos iterativos, especialmente quando associados ao mtodo do
Gradiente Conjugado Pr-condicionado;
b) matrizes tipo morse: usadas no contexto de mtodos iterativos que,

como veremos, no alteram os coeficientes originais da matriz durante o processo de
resoluo. Armazenam apenas os coeficientes no-nulos mas devem tambm armazenar
a sua localizao individualmente;
c) matrizes tipo bloco: usadas no contexto tanto de mtodos diretos

quanto de iterativos e exploram a diviso da matriz em submatrizes;
Todas essas formas de armazenamento so diferentes maneiras de alocar

os coeficientes da matriz de modo mais eficiente, explorando as suas caractersticas
prprias de esparsidade. O resultado desta operao constitui-se para os algoritmos de
resoluo em duas vantagens: a de reduzir a memria necessria, eliminando os
coeficientes nulos que forem inertes para o processo de resoluo e por conseguinte, a
de reduzir o nmero de operaes necessrias para obter a soluo do sistema. Para
alcanar um gerenciamento da alocao dos coeficientes ativos da matriz sem entretanto
28
descaracterizar o algoritmo de resoluo, a idia fundamental consiste em estabelecer
para cada forma de armazenamento um mapeamento do tipo:
Ai , j vAi , j
onde Ai , j representa a matriz A sob a forma de estrutura de matriz computacional e
aloca por conseguinte todos os coeficientes ativos ou inertes sem distino enquanto que
vAi , j representa a matriz e sua esparsidade sob a forma de estrutura de vetor
computacional alocando apenas os coeficientes ativos.
Nos temas subseqentes iremos detalhar o mapeamento matrizes tipo

morse, pelo fato de estarmos estudando no contexto de mtodos iterativos, com a
finalidade de armazenam apenas os coeficientes no-nulos, que nossa finalidade
principal, na resoluo de equaes diferenciais.
2.6.1. Armazenamento Morse
Existem situaes, onde considerar que todos os coeficientes da matriz

sejam armazenados leva a um desperdcio de memria. Veremos que nos mtodos
iterativos, no ocorre o processo de preenchimento total da matriz e os seus
coeficientes. Desta forma, apenas os valores no-nulos precisariam ser de fato
armazenados. O armazenamento morse descrito nesta seo atinge exatamente este
objetivo.
No mtodo de armazenamento morse, considera-se que podem existir

vazios (coeficientes nulos) e s seriam armazenados coeficientes no nulos. Em cada
linha i, vo existir grupos de coeficientes no-nulos intercalados por vazios. Os limites
de cada grupo g sero indicados por min[g] e max[g]. Um vetor auxiliar loc[g] acumula
os coeficientes armazenados at o grupo g, fazendo o papel do vetor loc[i] do
armazenamento para a linha i. Para poder localizar os grupos ativos em cada linha i,
usaremos o vetor grp que acumula os grupos ativos em cada linha. O exemplo abaixo
ajuda a compreender as estruturas utilizadas para o armazenamento morse.
29
A localizao de um elemento ij da matriz A no vetor va pode ser obtido
pela afirmao:
"Elementos acumulados at o grupo anterior ao atual (aquele que contm

a coluna j na linha i) + Elementos acumulados no grupo atual at a coluna j"
e expresso pela relao:
ij = loc[Grupo( i , j )] + j
Para determinarmos Grupo(i,j), pode-se usar o algoritmo:
funcao grupo(i,j)
para g de grp[i-1]+1 at grp[i]
se j menor_igual max[g] ento retorne g
fim_para
fim_funcao
Obs:
Define-se grp[0]=0;
O vetor loc pode ser obtido de uma vez por todas, conhecidos os vetores grp, min e
max;
Exemplo: na matriz exemplificada acima A[5,10] = va[loc[12]+10] = va[17+10] =

va[27].
30
2.7. Precondicionamento de Matrizes
Uma forma de tornar um mtodo iterativo mais rpido consiste em

transformar o sistema A x = b num sistema equivalente, onde a matriz tenha um nmero
de condio mais favorvel.
Para ilustrar o que acabamos de dizer, podemos utilizar o mtodo dos

gradientes conjugados, que de acordo com a expresso (38), as iteraes satisfazem a
seguinte estimativa de erro:
(cond A) 12 1 ( 0 )
e (k )
2 e
A (cond A) 12 + 1 A
2
Logo, se pudermos diminuir (cond 2 A) consequentemente o erro e ( 0 )

A
tambm ir diminuir, proporcionando uma rpida convergncia.
Esta transformao conseguida premultiplicando e posmultiplicando a

matriz A por duas matrizes P e Q inversveis do seguinte modo:
(PAQ) (Q)-1 x = P b (45)
O sistema transformado corresponde, portanto a :
Ax = b
com A = PAQ , x = Q 1 x , b = Pb
As matrizes P e Q devem ser escolhidas de modo a proporcionar matriz
A melhores propriedades de convergncia em relao a matriz original A.
Este procedimento conhecido como precondicionamento de sistema de

equaes original, sendo P e Q conhecidas pelo nome de matrizes de
precondicionamento. No caso onde Q = I , chamamos de precondicionamento esquerdo,
j se P = I , chamamos de precondicionamento direito.
31
Por razes de economia computacional, conveniente que o algoritmo de
precondicionamento deve evitar a formao explcita de A , e trabalhar apenas com a
matriz original A.
Considerando que no mtodo dos gradientes conjugados, a matriz

transformada tem de continuar a ser simtrica e positivo definida, o precondicionamento
tambm dever preservar esta propriedade. De fato, podemos obter isso, fazendo com
que:
P=S
Q = PT = ST
e desta forma, podemos chegar a:
Ax = b
com A = SAS T , x = S T x , b = Sb
( )
Tendo em vista que cond 2 A << (cond 2 A) , fcil verificar que:
(0) (0) (0)

p =r = b Ax = Sr ( 0 )
Por outro lado, se escolhermos
(0) (0)
p( 0 ) = S T p = ST r = S T Sr ( 0 )
o que sempre possvel, temos que:
(p (0)
,Ap
(0)
) = (p (0)
, Ap ( 0 ) )
Tambm vlida a relao
(r (0)
,r
(0)
) = (r (0)
,r ( 0 ) )
em que pusemos
Wr
(0)
= r(0) com (
W = ST S )1
32
A partir da, podemos obter sem dificuldade
0 = r ( (0)
)
, r ( 0 ) p ( 0 ) , Ap ( 0 )
x(1 ) = x( 0 ) + 0 p( 0 )
r ( 1 ) = r ( 0 ) 0 Ap ( 0 )
0 = r ( (1)
,r ( 1 ) ) (r (0)
,r ( 0 ) )
(1)
p(1) = r + 0 p( 0 )
mantendo estas expresses para as iteraes seguintes.
Mostraremos ento, o mtodo dos gradientes conjugados

precondicionado:
Ler A, b
Estimar x ( 0 ) ;
Fixar uma tolerncia
k = 0
r ( 0 ) = b Ax ( 0 )
~(0)
Resolver W r = r(0)
~(0)
p (0)
=r
2
k=k+1
~(k )
k = r , r ( k ) / ( p ( k ) , Ap ( k ) )

x ( k +1 )
= x + k p( k )
(k )
r ( k +1 ) = r ( k ) k Ap ( k )
~ ( k +1 )
Resolver W r = r( k )
~ ( k +1 ) ( k +1 ) ~(k ) (k )
k = r ,r

r ,r

~ ( k +1 )
p =r ( k +1 )
+ k p( k )
fim enquanto
33
Nota-se que em cada iterao, necessrio resolvermos um sistema
auxiliar:
~ ( k +1 )
Wr = r( k )
sendo por isso desejvel que seja sistema 'fcil' de ser resolvido.
As situaes extremas correspondem a:
W = I : recuperamos o mtodo dos gradientes conjugados
W = A : obtemos a soluo em uma nica iterao, porm com o

custo de ter que inverter a matriz A, o que no nos interessa.
O objetivo ficar entre este dois extremos, sem recorrer a custos

computacionais elevados.
Convm reparar que
A = SAS T = S T ( W 1 A )S T (46)
e, portanto
A = W 1 A
Logo, podemos concluir que:
cond 2 A = cond 2 W 1 A ( ) (47)
Apresentaremos a seguir, algumas formas de escolhermos esta matriz W,

( )
de modo a tornar cond 2 W 1 A to pequeno quanto possvel, sem recorrer a custos
computacionais demasiadamente elevados.
2.7.1. Precondicionamento pela Diagonal Principal de A
Pode-se dizer que este o mais simples dos precondicionadores , onde a

matriz de precondicionamento W escolhida, a diagonal principal de A, ou como
tambm chamada, matriz D.
34
Este tipo de precondicionamento indicado para resolver sistemas onde a
matriz a possui um nmero de condio baixo, porm no sendo ideal para ser calculado
apenas pelo mtodo dos gradientes conjugados. Nestes casos, podemos usar como
precondicionador, a matriz diagonal principal de A. Assim, a inversa aproximada de A,
denotada por W-1, calculada pela simples inverso da matriz diagonal D.
Para implementar este precondicionador, devemos resolver o sistema

~ ( k +1 )
auxiliar W r = r ( k ) com a sub-rotina mostrada a seguir:
~ ( k +1 )
sub-rotina Resolver W r = r( k ) ;
se i=j ento D = Aij ;
W = D;
~ ( k +1 )
r = W 1 r ( k ) ;
fim da sub-rotina;
Este algoritmo de precondicionamento foi implementado e testado em

Pascal, e seu cdigo ser mostrado em anexo.
2.7.2. Precondicionamento pelo Mtodo S.S.O.R.
Vamos considerar agora o mtodo S.S.O.R. (Simetric Sucessive Over

Relaxation) que aplica os conceitos de sobre-relaxao para matrizes simtricas.
Para este caso, vamos considerar que a matriz A pode ser escrita como:
A=D+L+U
onde:
D = a matriz diagonal
L = a matriz triangular inferior
U = a matriz triangular superior
Quando resolvemos sistemas onde a matriz A simtrica, temos que L =

U, logo, podemos escrever:
35
A = D + L + LT
No precondicionamento por S.S.O.R., a inversa aproximada de A ,

denotada por W-1, :
W-1 = M -1 D M T,
onde:
M = (D - w L) . (w (2 - w) )(-1/2)
em que w o coeficiente de relaxao.
~ ( k +1 )
Para simplificar os clculos de W r = r ( k ) , vamos dividi-lo em trs
etapas:
(1) Resolve-se (D - w L) x* = w r(k)
(2) Calcula-se x** = D x*
~ ( k +1 ) ~ ( k +1 )
(3) Resolve-se (D - w LT) r = w (2 - w) x** ;para obter r .
A sub-rotina do mtodo de precondicionamento S.S.O.R. ser mostrada a

seguir:
~ ( k +1 )
estabelecer w;
x* =(D - w L)-1.w.r(k); {subst. direta}
x** = D.x*;
~ ( k +1 )
r =(D-wLT)-1.w.(2-w).x**; {subst. inversa}
fim da sub-rotina;

36
2.7.3. Precondicionamento pelo Mtodo da Decomposio LU
Incompleta.
No precondicionamento pela decomposio LU incompleta, a inversa

aproximada de A , denotada por W-1, uma decomposio LU de Choleski, no da
matriz A, mas sim, de uma matriz ligeiramente diferente de A. Esta matriz obtida
preservando-se a esparsidade da matriz A, ou seja, no modificando seus elementos
nulos.
Como estamos trabalhando com uma matriz A simtrica, a decomposio

LU pode ser escrita como sendo uma decomposio LLT .Para este caso, vamos
considerar que a matriz A pode ser escrita como:
A = L LT + E
em que E representa a diferena entre a matriz original A.
A matriz W escolhida como sendo:
W = L LT
A esparsidade deve ser respeitada, os coeficientes nulos da matriz A so

mantidos e a matriz W chamada de decomposio LU incompleta:
~ ( k +1 )
Desta forma, resolvemos W r = r ( k ) em duas etapas:
(1) L z(k+1) = r(k+1) ;para obter z(k+1)
~ ( k +1 ) ~ ( k +1 )
(2) LT r = z(k+1) ;para obter r
A sub-rotina do mtodo de precondicionamento pela decomposio LU

incompleta ser mostrada a seguir:
~ ( k +1 )
fazer a decomposio LLT incompleta;
z(k+1)=L-1.r(k+1); {subst. direta}
~ ( k +1 )
r =L- T.z(k+1); {subst. inversa}
fim da sub-rotina;
37
2.7.4. Precondicionamento pela minimizao de I - AW na

norma de Frobenius.
Um outro precondicionamento obtido pela minimizao de I - AW pela

norma de Frobenuis. O objetivo encontrar uma matriz W em que o resduo I - AW
calculado seja pequeno:
F(M) = || I - A W ||2F
Uma forma de minimizar esta norma de Frobenius pelo algoritmo dos

resduos mnimos. Neste caso, escolhemos arbitrariamente uma matriz inicial W e
calculamos o resduo G da seguinte maneira:
G=I-AW
Em seguida, calculamos o coeficiente , que auxilia a encontrar a nova

matriz W:
( G T .A.G )
= 2
A.W F
A nova matriz W dada por:
W (k+1) = W (k) + .G
A sub-rotina do mtodo de precondicionamento pela minimizao de I -

AW pela norma de Frobenuis , utilizando o mtodo dos resduos mnimos mostrada a
seguir:
~ ( k +1 )
escolha de W inicial;
escolha de ;
2
enquanto G F > faa
C = A . W;
G = I - C ;
38
2
= ( G T .A.G ) C F ;
W = W + .G;
fim enquanto;
~ ( k +1 )
r = W 1 r ( k ) ;
fim da sub-rotina;

Outra segunda forma de minimizar esta norma de Frobenius pelo

algoritmo da descida mais ngreme. Tambm escolhemos uma matriz inicial W e
calculamos o resduo G da seguinte maneira:
G = A T . ( I - A W)
Em seguida, calculamos o coeficiente , que auxilia a encontrar a nova

matriz W:
2
G
= F
2
A.G F
A nova matriz W dada por:
W (k+1) = W (k) + .G
A sub-rotina do mtodo de precondicionamento pela minimizao de I -

AW pela norma de Frobenuis , utilizando o mtodo da descida mais ngreme mostrada
a seguir:
~ ( k +1 )
escolha de W inicial;
escolha de ;
2
enquanto G F > faa
C = A . W;
R = I - C;
G = AT . R ;
2 2
= G F
AG F
;
39
W = W + .G;
fim enquanto;
~ ( k +1 )
r = W 1 r ( k ) ;
fim da sub-rotina;

40
2.8. Consideraes sobre Mtodos Iterativos
Quando comparamos mtodos diretos com iterativos, no se pode

garantir que mtodo o mais eficiente. necessrio o estabelecimento de certos
critrios. Usando critrios bem gerais, pode-se afirmar que os mtodos diretos se
prestam aos sistemas de pequeno porte com matrizes de coeficientes densas; tambm
resolvem satisfatoriamente sistemas lineares com a mesma matriz de coeficientes.
J os mtodos iterativos, quando h convergncia garantida, so bastante

vantajosos na resoluo de sistemas de grande porte, com a matriz de coeficientes do
tipo 'esparso' (grande nmero de zeros entre seus elementos). Os sistemas oriundos da
discretizao de equaes diferenciais parciais so um caso tpico. Neles, os zeros da
matriz original so preservados e as iteraes so conduzidas com a preservao da
matriz original, tornando os clculos autocorrigveis, o que tende a minimizar os erros
de arredondamento e torna-los muito mais rpidos e eficientes.
41
3. APLICAO PRTICA DE MTODOS ITERATIVOS
Os testes prticos dos mtodos iterativos sero divididos em trs partes.
A primeira parte consiste em um simples teste de funcionamento dos

algoritmos implementados, onde foram usadas apenas matrizes muito pequenas, com a
finalidade de verificar se o programa estava executando sem problemas.
Na segunda parte, utilizamos os mtodos iterativos implementados para

resolver equaes diferenciais, pelo mtodo das diferenas finitas de segunda ordem.
Neste caso, a ordem das matrizes utilizadas eram de no mximo 60.
Finalmente, na terceira parte, utilizamos os mtodos iterativos no

estacionrios para resolver grandes sistemas lineares esparsos. A matriz usada neste
teste "uma matriz representativa" de matrizes resultantes da aplicao do mtodo dos
elementos espectrais a equaes diferenciais parciais (EDPs).
3.1. Teste de Funcionamento
Primeiramente, testamos os mtodos iterativos estacionrios: Jacobi,

Jacobi com relaxao, Gauss-Seidel e Gauss-Seidel com relaxao. Para os mtodos de
relaxao, foram testados coeficientes compreendidos entre 0,2 e 1,2. A soluo inicial
x(0) encolhida para os mtodos foi 0.
Estes mtodos foram implementados na linguagem Pascal estruturada,

utilizando o compilador Turbo Pascal 7.0. Para facilitar a execuo dos algoritmos,
estes foram juntos em quatro programas, distintos por sua ordem:
A:\TurboPascal\Estacionrios\Iterativos_Estacionrios_Ordem2.exe
42
Neste mesmo diretrio encontram seu cdigo com a extenso .pas:
A:\TurboPascal\Estacionrios\Iterativos_Estacionrios.pas
Nos testes, foram utilizadas matrizes A e coeficientes b para resoluo do

sistema Ax = b, sendo que estes esto armazenados em forma de um arquivo de texto,
que solicitado pelo programa quando executado.
As matrizes A e vetores b utilizados foram:
A:\TurboPascal\Estacionrios\m2a.txt
A = 2 1 b = 1
-1 3 -4
A:\TurboPascal\Estacionrios\m2b.txt
A = 5 4 b = 23
-3 9 9
A = 4 2 3 b = 8
1 5 2 0
3 2 6 13
A = 9 3 2 b = 19
5 8 1 17
3 5 12 -1
A = 2 -2 1 -1 b = 8
2 3 1 -2 5
1 -2 2 -1 9
-3 -1 1 2 -4
43
A = 4 -1 3 2 b = 11
-2 2 -1 3 -12
1 -3 3 -1 12
2 -2 1 4 5
A = 5 -1 3 2 -2 b = 7
-2 3 1 -3 2 0
1 3 4 -1 2 7
2 -2 1 4 3 14
1 -2 3 -3 5 27
A = 5 1 -2 3 4 b = 5
1 4 -3 3 2 -13
1 -2 5 3 -4 -3
-3 2 1 5 3 -6
1 2 3 4 5 10
O nmero de iteraes que cada mtodo apresentou com os testes, foram

organizados na tabela a seguir:
Metodo Jacobi Gauss_S Jacobi_W Gauss_S_W
Sistema 0,2 0,4 0,6 0,8 1,2 0,2 0,4 0,6 0,8 1,2
m2a.txt 40 22 156 72 46 38 54 160 72 42 24 80
m2b.txt 56 30 162 80 54 48 84 158 70 40 24 144
m3a.txt 399 48 525 252 162 117 109 327 153 96 63 39
m3b.txt 120 36 381 177 111 75 2340 285 132 81 54 48
m4a.txt 1404 316 932 452 292 212 1054 700 332 224 164 207
m4b.txt 652 96 1040 588 468 556 2064 336 152 96 88 304
m5a.txt 1480 320 3635 1805 1195 890 1201 1740 855 555 410 330
m5b.txt 2110 536 5418 1205 1070 1230 4520 1005 720 1020 632 254
44
Agora, testamos os mtodos iterativos no estacionrios: Gradientes
Conjugados, gradientes Conjugados Precondicionados (Diagonal Principal de A, SSOR,
Decomposio LU incompleta, minimizao de Frobenius pelos Resduos mnimos e
pela descida mais inclinada) e Gradientes Biconjugados. Para os mtodo SSOR,
utilizamos o coeficiente de relaxao sendo 1,3. Nos mtodos de Frobenius, a matriz W
inicial escolhida foi a diagonal principal de A modificada (foi utilizado 1 no lugar de
coeficientes nulos). A soluo inicial x(0) encolhida para os mtodos foi 0.
Estes mtodos foram implementados na linguagem Pascal estruturada,

utilizando o compilador Turbo Pascal 7.0. Para facilitar a execuo dos algoritmos,
estes foram juntos em quatro programas, distintos por sua ordem:
A:\TurboPascal\NoEstacionrios\Iterativos_Nao_Estacionrios_Ordem2.exe
A:\TurboPascal\NoEstacionrios\Iterativos_Nao_Estacionrios.pas
Nos testes, foram utilizadas matrizes A e coeficientes b para resoluo do

sistema Ax = b, sendo que estes esto armazenados em forma de um arquivo de texto,
que solicitado pelo programa quando executado.
As matrizes A e vetores b utilizados foram:
A:\TurboPascal\Estacionrios\m2c.txt
A = 2 -3 b = 5
-3 1 -4
A:\TurboPascal\Estacionrios\m2d.txt
A = -5 4 b = -23
4 2 8
45
A = 1 5 -2 b = 5
5 3 -1 8
-2 -1 4 8
A = -2 1 3 b = -11
1 -4 5 -4
3 5 -3 7
A = 1 -1 2 2 b = 2
-1 3 -2 1 -10
2 -2 -1 0 2
2 1 0 2 -3
A = 3 -2 0 -1 b = -16
-2 4 -3 2 17
0 -3 5 1 2
-1 2 1 2 14
A = 2 0 -1 3 -2 b = 15
0 2 1 -1 0 -1
-1 1 4 -2 3 -20
3 -1 -2 -2 -1 -4
-2 0 3 -1 5 -22
A = 3 -1 2 -2 -3 b = -2
-1 2 0 -3 1 12
2 0 5 1 2 -5
-2 -3 1 4 3 -10
-3 1 2 3 2 5
46
organizados na tabela a seguir:
Metodo Gradiente Gradiente Conjugado Precondicionado Gradiente
Sistema Conjug. diag_A SSOR LU_incom FRB_rm FRB_di Biconjug.

p.
m2c.txt 2 2 2 2 2 2 3
m2d.txt 2 2 2 1 2 2 3
m3c.txt 3 3 3 14 overflow 3 4
m3d.txt 3 3 3 2 overflow 3 3
m4c.txt 4 4 3 erro overflow 4 5
m5c.txt 5 5 4 erro overflow 5 6
3.2. Aplicao dos Mtodos Iterativos na Resoluo de

Equaes Diferenciais
O objetivo destes testes aplicar os mtodos iterativos na resoluo de

equaes diferenciais, pelo mtodo das diferenas finitas de segunda ordem. Neste
mtodo, gerado um sistema linear, no qual pode ser resolvido por mtodos iterativos.
Para isto, foram escolhidas duas equaes diferenciais, e variamos o intervalo de pontos
aos quais sero calculados seus coeficientes. Esse nmero de intervalos ser a ordem
da matriz.
As equaes utilizadas foram:
(1) - u - u + 2 u - 2 = 0
-1<x<1
u ( -1) = u (1) = 0
47
(2) - u + 2 cos x - sen x (x+1) = 0
0<x<1
u ( 0) = 0 , u (1) = 2sen1
Primeiramente, comparamos os mtodos estacionrios com os mtodos

de gradientes Conjugado e Biconjugado. Para o isto, utilizamos matrizes de ordem 10
at 60, com passos de 10.
Este programa foi implementado na linguagem Pascal estruturada,

utilizando o compilador Turbo Pascal 7.0.
Os arquivos que contem os algoritmos que resolvem a equao

diferencial (1) esto em:
A:\TurboPascal\EqDiferenciais\Eqdif_1_ordem10.exe
A:\TurboPascal\EqDiferenciais\Eqdif_1.pas

organizados na tabela e grfico a seguir:
MTODO / ORDEM 10 20 30 40 50 60
Jacobi 1810 12540 25786 25144 24258 29516
Gauss Seidel 970 6640 21030 17576 25644 23308
Jacobi com w = 0,6 3050 22960 794 20208 25256 27488
48
Gauss Seidel com w = 0,6 1650 11140 30376 14544 21078 4684
Gradientes Conjugados 23 29 42 55 67 80
Gradientes Biconjugados 24 30 43 56 68 81
Equao (1) Jacobi

100000
10000 Gauss Seidel
1000
Jacobi com w
NIT
100
Gauss Seidel
10 com w
1 Gradientes
Conjugados
1 2 3 4 5 6
Gradientes
ORDEM (x10) Biconjugados

A:\TurboPascal\EqDiferenciais\Eqdif_2.pas
49
MTODO / ORDEM 10 20 30 40 50 60
Jacobi 3010 18580 11506 16392 7942 740
Gauss Seidel 1680 11060 31756 9344 7828 31984
Jacobi com w 5230 31116 26072 29864 28602 9416
Gauss Seidel com w 2840 18500 9136 6192 30494 9456
Gradientes Conjugados 10 20 30 40 50 60
Gradientes Biconjugados 11 21 31 41 51 61
Equao (2) Jacobi

100000
10000 Gauss Seidel
1000
NIT
Jacobi com w
100
10 Gauss Seidel
com w
1 Gradientes
1 2 3 4 5 6 Conjugados
Gradientes
Aps estes testes iniciais, comparamos ento os mtodos no

estacionrios dos gradientes Conjugado com e sem precondicionadores e gradiente
Biconjugado. Para o isto, utilizamos matrizes um pouco maiores, de ordem 100 at 300,
com passos de 100.
Este programa foi implementado na linguagem Pascal estruturada,

utilizando o compilador Delphi 3.0 , devido a limitaes no tamanho da matriz
encontradas no Turbo Pascal.
50
A:\Delphi\Eqdif1\ProgEqdif_1_Ordem100.exe
Neste mesmo diretrio encontram seu cdigo com a extenso .dpr e .pas:
A:\Delphi\Eqdif1\ProgEqdif_1.dpr
A:\Delphi\Eqdif1\UprEqdif_1.pas

MTODO / ORDEM 100 200 300

Gradiente Conjugado 218 265 394
Prec. Diag Princ. De A 263 501 730
Prec.SSOR 83 152 222
Prec LU incompl. 1 1 1
Prec Frobenius RM 231 402 580
Prec Frobenius DI 201 336 425
Gradientes Biconjugados 219 266 395
51
1000
Equao (1) Gradiente
Conjugado
Prec. Diag
100 Princ. De A
Prec.SSOR
NIT
10 Prec LU
incompl.
1 Prec Frobenius
RM
1 2 3
Gradientes

A:\Delphi\Eqdif1\ProgEqdif_2.dpr
A:\Delphi\Eqdif1\UprEqdif_2.pas

52
MTODO / ORDEM 100 200 300
Gradiente Conjugado 83 151 211
Prec. Diag Princ. De A 80 142 195
Prec.SSOR 28 48 66
Prec LU incompl. 1 1 1
Prec Frobenius RM 95 123 204
Prec Frobenius DI 78 103 189
Gradientes Biconjugados 84 152 212
Equao (2) Gradiente

1000
Conjugado
Prec. Diag
100 Princ. De A
Prec.SSOR
NIT
10 Prec LU
incompl.
1 Prec Frobenius
RM
1 2 3
Gradientes
3.3. Aplicao dos Mtodos Iterativos na resoluo de matrizes

geradas por Mtodos Espectrais
Vamos agora, resolver uma matriz grande, gerada pela aplicao de

mtodos espectrais. A matriz grande usada nos testes "uma matriz representativa" de
matrizes resultantes da aplicao do mtodo dos elementos espectrais a equaes
diferenciais parciais (EDPs). Os mtodos dos elementos espectrais uma combinao
53
dos mtodos espectrais com o mtodo dos elementos finitos. Esta combinao via
aproveitar a flexibilidade dos elementos finitos e uni-la a elevada acuracia dos mtodos
espectrais.
Para isto, necessrio fornecer ao programa esta matriz A externa,

juntamente com os seus coeficientes b. Em nosso teste, utilizamos uma matriz de ordem
961x961, armazenada em um arquivo chamado mat_a.log e os vetores em outro arquivo
chamado vet_b.log. No programa, temos uma rotina que abre automaticamente estes 2
arquivos e os l. Por razo de seu tamanho ser muito grande, este arquivo ser
compactado e armazenado em:
A:\Delphi\IterativosNEstac\dados.zip
O programa foi implementado na linguagem Pascal estruturada,

utilizando o compilador Delphi 3.0.
Os arquivos que contem os algoritmos que resolvem a matriz A resultante

da aplicao de mtodos espectrais, esto em:
A:\Delphi\IterativosNEstac\ProgIterativosNEst.exe
A:\Delphi\IterativosNEstac\ProgIterativosNEst.dpr
A:\Delphi\IterativosNEstac\UprIterativosNEst.pas

54
vetor b = vet_b.log vetor b = 1
MTODO / ORDEM 961 961
Gradiente Conjugado 2083 865
Prec. Diag Princ. De A 912 651
Prec.SSOR 256 142
Prec LU incompl. 526 231
Prec Frobenius RM 894 327
Prec Frobenius DI 761 287
Gradientes Biconjugados 2084 866
Gradientes
Biconjugados
3 Prec Frobenius RM
ORDEM Prec LU incompl.
2
961
1 Prec.SSOR
1 10 100 1000 10000 Prec. Diag Princ.

De A
Gradiente
NIT
Conjugado
55
CONCLUSES
Neste trabalho, adquirimos uma grande experincia com o estudo dos

mtodos iterativos. Pudemos colocar em prtica vrios conhecimentos tericos
adquiridos, tanto na parte de anlise e clculo numrico, como tambm programao.
Com base nos testes realizados, vimos com clareza a superioridade dos
mtodos no estacionrios na resoluo de sistemas lineares grandes e esparsos, em
relao aos mtodos estacionrios.
Quanto aos precondicionadores implementados, que eram o objetivo

central de nosso trabalho, podemos fazer algumas consideraes baseados nos testes
realizados:
a) O mtodo da diagonal principal de A apresentou eficincia para

sistemas onde a matriz A apresentava um nmero de condio no muito elevado;
b) O mtodo SSOR apresentou resultados muito bons, para todos os

testes;
c) O mtodo da decomposio LU incompleta comportou-se como um

mtodo direto nas equaes diferenciais, resolvendo os problemas em uma nica
iterao. Teve tambm um bom desempenho na resoluo do sistema de grande porte;
d) O mtodo de minimizao de Frobenuis por resduos mnimos possui

uma desvantagem: mais lento que os outros e as vezes gera overflow, quando a matriz
cheia;
e) O mtodo da minimizao de Frobenius pela descida mais inclinada

no apresenta o problema do overflow, porm, tambm lento.
Pode-se dizer que todos os objetivos formam alcanados, pois pudemos

verificar os pontos positivos e negativos de cada mtodo iterativo.
56
ANEXOS
1) Implementao do Mtodo de Jacobi
procedure metodo_Jacob;
var
k,i,j :integer;
begin
nit:=0;
erro:=5;
while erro>0.0000001 do
begin
for i:= 1 to ordem do
begin
for j:= 1 to ordem do
begin
if i<>j then resp[i]:= (coef_a[i,j] * x[j]) + resp[i];
end;
resp[i]:= (coef_b[i] - resp[i] ) / coef_a[i,i];
end;
calcule_erro;
for i:=1 to ordem do
begin
x[i]:= resp[i];
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
2) Implementao do Mtodo de Gauss-Seidel
procedure metodo_GaussSeidel;
var
k,i,j :integer;
begin
nit:=0;
erro:=5;
begin
begin
begin
if j<i then resp[i]:= (coef_a[i,j] * resp[j]) + resp[i];
if j>i then resp[i]:= (coef_a[i,j] * x[j]) + resp[i];
end;
end;
calcule_erro;
begin
x[i]:= resp[i];
resp[i]:=0;
nit:=nit+1;
57
end;
end;{while}
end;
3) Implementao do Mtodo de Jacobi com Relaxao
procedure metodo_RJacob;
var
k,i,j :integer;
begin
write('Digite o coeficiente de relaxacao w:');
readln(w);
nit:=0;
erro:=5;
begin
begin
begin
end;
end;
calcule_erro;
begin
x[i]:= x[i] + w*(resp[i] - x[i]) ;
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
4) Implementao do Mtodo de Gauss-Seidel com Relaxao
procedure metodo_RGaussSeidel;
var
k,i,j :integer;
begin
readln(w);
nit:=0;
erro:=5;
begin
begin
begin
end;
end;
calcule_erro;
begin
x[i]:= x[i] + w*(resp[i] - x[i]) ;
58
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
5) Implementao dos Mtodos Iterativos Estacionrios
Program Iterativos_Estacionarios;
{Este programa resolve um problema A x = b , onde:

A eh uma matriz, x sao as icognitas e b eh um vetor
de coeficientes, pelo metodos iterativos Estacionarios:
Jacob, Gauss Seidel, com e sem relaxaao}
uses
crt;
const
ordem = 3;
type
vetor_real = array[1..ordem] of real;
vetor_inteiro = array[1..ordem] of integer;
matriz = array[1..ordem,1..ordem] of integer;
var
i,j,k :integer;
coef_a :matriz;
resp :vetor_real;
x :vetor_real;
coef_b :vetor_inteiro;
erro :real;
nit :integer;
w :real;
Arquivo:TEXT;
nome :string;
sair :boolean;
opsair :integer;
contr :boolean;
procedure le_coeficientes_arquivo;
begin
write('Digite o nome do arquivo e extensao:');
readln(nome);
assign(Arquivo, nome);
reset(Arquivo);
while not EOF(Arquivo) do
begin
begin
for j:=1 to ordem do readln(Arquivo, coef_a[i,j]);
readln(Arquivo, coef_b[i]);
end;
end;
close(Arquivo);
end;
procedure le_coeficientes_manual;
59
begin
begin
for j:=1 to ordem do
begin
write('Digite a',i,j ,':');
readln(coef_a[i,j]);
end;
write('Digite o Coeficiente b',i,':');
readln(coef_b[i]);
end;
end;
procedure exibe_matriz;
begin
write('MATRIZ DE COEFICIENTES A');
begin
writeln('');
begin
write(' ',coef_a[i,j]);
end;
end;
writeln('');
end;
procedure exibe_resultado;
begin
write('VETOR DE RESULTADOS');
begin
writeln('');
writeln('Variavel x',i, ': ',x[i]:10:2);
end;
writeln('Numero de Iteracoes necessarias: ',nit);
end;
procedure inicializa;
begin
erro:=0;
begin
resp[i]:=0;
x[i]:=0;
end;
end;
procedure calcule_erro;
var v_erros: array[1..ordem] of real;
cont:integer;
begin
for cont:=1 to ordem do
v_erros[cont]:= abs (x[cont] - resp[cont]);
erro:= v_erros[1];
for cont:=2 to ordem do
begin
if v_erros[cont] > v_erros[cont-1] then
erro:=v_erros[cont];
end;
60
end;
procedure metodo_Jacob;
var
k,i,j :integer;
begin
nit:=0;
erro:=5;
begin
begin
begin
end;
end;
calcule_erro;
begin
x[i]:= resp[i];
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
procedure metodo_GaussSeidel;
var
k,i,j :integer;
begin
nit:=0;
erro:=5;
begin
begin
begin
end;
end;
calcule_erro;
begin
x[i]:= resp[i];
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
procedure metodo_RJacob;
var
k,i,j :integer;
begin
61
readln(w);
nit:=0;
erro:=5;
begin
begin
begin
end;
end;
calcule_erro;
begin
x[i]:= x[i] + w*(resp[i] - x[i]) ;
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
procedure metodo_RGaussSeidel;
var
k,i,j :integer;
begin
readln(w);
nit:=0;
erro:=5;
begin
begin
begin
end;
end;
calcule_erro;
begin
x[i]:= x[i] + w*(resp[i] - x[i]) ;
resp[i]:=0;
nit:=nit+1;
end;
end;{while}
end;
procedure menu_inicial;
var
opcao_a: integer;
contr_a: boolean;
begin
clrscr;
writeln('**********************************************************');
62
writeln('*
*');
writeln('* METODOS ITERATIVOS ESTACIONARIOS
*');
writeln('* PARA RESOLUCAO DE SISTEMAS LINEARES
*');
writeln('*
*');
writeln('* ORDEM DA MATRIZ ',ordem,'
*');
writeln('*
*');
writeln('**********************************************************');
writeln('');
writeln('');
writeln('');
writeln('ENTRADA DE DADOS :');
writeln('');
writeln('1 - DIGITACAO MANUAL');
writeln('2 - ARMAZENADO EM ARQUIVO');
writeln('');
writeln('');
contr_a:=FALSE;
while contr_a=FALSE do
begin
write('ENTRADA DE DADOS -> ');
readln(opcao_a);
case opcao_a of
1: begin
le_coeficientes_manual;
contr_a:=TRUE;
end;
2: begin
le_coeficientes_arquivo;
contr_a:=TRUE;
end;
Else
contr_a:=FALSE;
end;{case}
end;{while}
clrscr;
end;
procedure menu_metodos;
var
opcao_b: integer;
contr_b: boolean;
begin
clrscr;
writeln('**********************************************************');
writeln('*
*');
writeln('* METODOS ITERATIVOS ESTACIONARIOS
*');
*');
writeln('*
*');
63
writeln('**********************************************************');
writeln('');
writeln('METODOS : ');
writeln('');
writeln('1 - METODO DE JACOBI');
writeln('2 - METODO DE JACOBI COM RELAXACAO');
writeln('3 - METODO DE GAUSS SEIDEL');
writeln('4 - METODO DE GAUSS SEIDEL COM RELAXACAO');
writeln('');
writeln('');
writeln('**********************************************************');
writeln('');
contr_b:=FALSE;
while contr_b=FALSE do
begin
write('METODO ESCOLHIDO ->');
readln(opcao_b);
case opcao_b of
1: begin
metodo_Jacob;
contr_b:=TRUE;
end;
2: begin
metodo_RJacob;
contr_b:=TRUE;
end;
3: begin
metodo_GaussSeidel;
contr_b:=TRUE;
end;
4: begin
metodo_RGaussSeidel;
contr_b:=TRUE;
end;
Else
contr_b:=FALSE;
end;{case}
end;{while}
clrscr;
end;
BEGIN
menu_inicial;
sair:=FALSE;
repeat
inicializa;
menu_metodos;
exibe_resultado;
contr:=false;
while contr=FALSE do
begin
writeln('');
writeln('');
writeln('');
writeln('');
writeln('*********************************************************');
writeln('1 - Executar novamente');
writeln('2 - Sair');
64
write('OPCAO ->');
readln(opsair);
case opsair of
1: begin
sair:= TRUE;
contr:=TRUE;
end;
2: begin
sair:= FALSE;
contr:=TRUE;
end;
Else
contr:=FALSE;
end;{case}
end;{while}
until sair=FALSE;
END.
6) Implementao do Mtodo de Gradientes Conjugados
procedure metodo_GradConjPre;
var
i,j :integer;
Ax :vetor_real;
o_aux :vetor_real;
o :real;
rtilTr :real;
begin
nit:=0;
for i:= 1 to ordem do Ax[i]:=0;
begin
for j:= 1 to ordem do Ax[i]:=(coef_a[i,j] * x[j]) + Ax[i];
r[i]:=coef_b[i] - Ax[i];
end;
case prec of
0: calcule_rtil_0(coef_a,r);
end;
for i:=1 to ordem do p[i]:=rtil[i];

pp[0]:=0;
for i:=1 to ordem do pp[0]:= (rtil[i]*r[i]) + pp[0];
while (abs(pp[nit])> tol ) do if (nit<nit_max) then
begin
nit:=nit+1;
o:=0;
for i:=1 to ordem do o_aux[i]:=0;
begin
o_aux[i]:= (p[j] * coef_a[j,i]) + o_aux[i];
65
o:= (o_aux[i] * p[i]) + o;
end;
rtilTr:=0;
rtilTr:= (rtil[i]*r[i]) + rtilTr;
aa:=rtilTr/o;
for i:=1 to ordem do ww[i]:=0;
for j:=1 to ordem do ww[i]:= (coef_a[i,j] * p[j]) + ww[i];
begin
x[i]:=x[i] + (aa * p[i]);
r[i]:=r[i] - (aa * ww[i]);
end;
case prec of
end;
pp[nit]:=0;
for i:=1 to ordem do pp[nit]:= (rtil[i]*r[i]) + pp[nit];
bb:=pp[nit] / pp[nit-1];
for i:=1 to ordem do p[i]:= rtil[i] + (bb * p[i]);
end;{while}
end;
7) Implementao do Mtodo de Gradientes Biconjugados
procedure metodo_GradBiconj;
var
i,j :integer;
Ap :vetor_real;
o_aux :vetor_real;
rrT :real;
begin
nit:=0;
begin
r[i]:= coef_b[i];
p[i]:= coef_b[i];
rtil[i]:= coef_b[i];
ptil[i]:= coef_b[i];
end;
pp[1]:=0;
for i:=1 to ordem do pp[1]:= (r[i]*r[i]) + pp[1];
pp[0]:=pp[1];
while (pp[nit]> tol ) AND (nit<nit_max) do
begin
nit:=nit+1;
o[nit]:=0;
begin
66
o[nit]:= (o_aux[i] * p[i]) + o[nit];
end; {end for}
aa:=pp[nit]/o[nit];
for i:= 1 to ordem do Ap[i]:=0;
begin
Ap[i]:=(coef_a[i,j] * p[j]) + Ap[i];
r[i]:= r[i] - aa * Ap[i];
end;
x[i]:= x[i] + (aa * p[i]);
begin
Ap[i]:=0;
Ap[i]:=(coef_a[j,i] * ptil[j]) + Ap[i];
rtil[i]:= rtil[i] - aa * Ap[i];
end;
for i:=1 to ordem do rrT:=0;
for i:=1 to ordem do rrT:= (r[i] * r[i]) + rrT;
pp[nit+1]:= rrT;
bb:=pp[nit+1] / pp[nit];
begin
p[i]:= r[i] + (bb * p[i]);
ptil[i]:= rtil[i] + (bb * ptil[i]);
end;
end;{while}
end;
8) Implementao dos Precondicionadores
{SEM PRECONDICIONAMENTO}
procedure calcule_rtil_0(coef_a_linha:matriz;
coef_b_linha:vetor_real);
begin
for i:=1 to ordem do rtil[i]:=0;
for i:=1 to ordem do rtil[i]:=r[i];
end;
{PRECONDICIONAMENTO PELA DIAGONAL PRINCIPAL DA MATRIZ A}

begin
rtil[i]:=coef_b_linha[i]/coef_a_linha[i,i];
end;
{PRECONDICIONAMENTO PELO METODO SSOR}

procedure calcule_rtil_2(coef_a_linha:
matriz;coef_b_linha:vetor_real);
var x_aster : vetor_real;
begin
{calcula - w L}
coef_a_linha[i,j]:= -w * coef_a_linha[i,j];
67
{calcula w r_(k+1)}
for k:=1 to ordem do coef_b_linha[k]:= w * coef_b_linha[k];
{Resolve-se (D - w L) x* = w r_(k+1)}
for k:= 1 to ordem-1 do
begin
x_aster[k]:=coef_b_linha[k] / coef_a_linha[k,k];
for i:= k+1 to ordem do
coef_b_linha[i]:= coef_b_linha[i] - x_aster[k] *
coef_a_linha[i,k];
end;
x_aster[ordem]:=coef_b_linha[ordem] / coef_a_linha[ordem,ordem];
{Calcula-se x** = D x*}
for i:=1 to ordem do x_aster[i]:= coef_a[i,i] * x_aster[i];
{Calcula-se w (2 - w) x** }
for k:=1 to ordem do coef_b_linha[k]:= w * (2-w) * x_aster[k];
{Resolve-se (D - w L') rtil = w (2 - w) x** }
for k:= ordem downto 2 do
begin
rtil[k]:=coef_b_linha[k] / coef_a_linha[k,k];
for i:= k-1 downto 1 do
coef_b_linha[i]:= coef_b_linha[i] - rtil[k] * coef_a_linha[i,k];
end;
rtil[1]:=coef_b_linha[1] / coef_a_linha[1,1];
end;
{PRECONDICIONAMENTO PELO METODO DA DECOMPOSICAO LU INCOMPLETA}

var
l: vetor_inteiro;
smax, r , rmax : real;
lk,h : integer;
s : vetor_real;
xmult,soma: real;
begin
begin
j:=1;
l[i]:= i ;
smax:=coef_a_linha[i,j];
if smax<coef_a_linha[i,j] then smax:=coef_a_linha[i,j];
s[i]:= smax;
end;
for k:=1 to ordem-1 do
begin
rmax:= 0;
for i:= k to ordem do
begin
r:= abs(coef_a_linha[l[i], k])/s[l[i]];
if r > rmax then
begin
j:= i;
rmax:= r;
end;
end;
lk:= l[j];
l[j]:= l[k];
l[k]:= lk;
for i:= k + 1 to ordem do
68
begin
xmult:= coef_a_linha[l[i], j]/coef_a_linha[lk,k];
for h:= k+1 to ordem do
if coef_a_linha[l[i],h] <> 0 then {preservar os coeficientes
nulos}
coef_a_linha[l[i], h]:= coef_a_linha[l[i], h] - xmult *
coef_a_linha[lk, h];
coef_a_linha[l[i], k]:= xmult;
end;
end;
coef_b_linha[l[i]]:= coef_b_linha[l[i]] - coef_b_linha[l[k]] *
coef_a_linha[l[i],k];
rtil[ordem]:= coef_b_linha[l[ordem]]/coef_a_linha[l[ordem],ordem];
for i:= ordem-1 downto 1 do
begin
soma:= coef_b_linha[l[i]];
for j:= i+1 to ordem do soma:= soma - rtil[j] *
coef_a_linha[l[i],j];
rtil[i]:= soma/coef_a_linha[l[i],i];
end;
end;
{PRECONDICIONAMENTO PELO MINIMIZACAO DE FROBENIUS USANDO RESIDUOS

MINIMOS}
var
W,C,G,GT,GTA,GTAG : matriz;
stp: integer;
coef_alfa: real;
begin
stp:= 5;
{escolha de W inicial}
if i=j then W[i,j]:=coef_a_linha[i,j]
else W[i,j]:=1;
{repeticao ate convergencia}
for l:=1 to stp do
begin
{C = A W}
for j:=1 to ordem do C[i,j]:=0;
for k:=1 to ordem do
C[i,j]:= (coef_a_linha[i,k] * W[k,j]) + C[i,j];
{G = I - C}
if i=j then G[i,j]:= 1 - C[i,j]
else G[i,j]:= - C[i,j];
{GTAG}
for j:=1 to ordem do GTAG[i,j]:=0;
for j:=1 to ordem do GT[i,j]:=G[j,i];
69
GTA[i,j]:= (GT[i,k] * coef_a_linha[k,j]) + GTA[i,j];
GTAG[i,j]:= (GTA[i,k] * G[k,j]) + GTAG[i,j];
{alfa}
coef_alfa:= calcule_traco_matriz(GTAG) / (calcule_norma_matriz(C) *
calcule_norma_matriz(C));
{W novo}
W[i,j]:= coef_alfa * W[i,j];
end;
rtil[i]:= (W[i,j] * coef_b_linha[j]) + rtil[i];
end;
{PRECONDICIONAMENTO PELO MINIMIZACAO DE FROBENIUS USANDO DESCIDA MAIS

INGREME}
var
W,C,R,G,AT,AG : matriz;
stp: integer;
coef_alfa: real;
begin
stp:= 5;
else W[i,j]:=1;
for l:=1 to stp do
begin
{C = A W}
{R = I - C}
if i=j then R[i,j]:= 1 - C[i,j]
else R[i,j]:= - C[i,j];
{G}
for j:=1 to ordem do G[i,j]:=0;
for j:=1 to ordem do AT[i,j]:=coef_a_linha[j,i];
G[i,j]:= (AT[i,k] * R[k,j]) + G[i,j];
70
{A * G}
AG[i,j]:= (coef_a_linha[i,k] * G[k,j]) + G[i,j];
{alfa}
coef_alfa:= (calcule_norma_matriz(G) * calcule_norma_matriz(G)) /
(calcule_norma_matriz(AG) * calcule_norma_matriz(AG));
{W novo}
end;
end;
9) Implementao dos Mtodos Iterativos Estacionrios
Program Iterativos_NaoEstacionarios;
{Este programa resolve um problema A x = b , onde:

A eh uma matriz, x sao as icognitas e b eh um vetor
de coeficientes, pelo metodos iterativos Nao Estacionarios:
Gradientes Conjugados, Gradientes Conjugados Precondicionados e
Gradientes Biconjugados}
uses
crt;
const
ordem = 3;
nit_max = 1000;
tol = 0.0000001;
w = 1.3;
type
vetor_real = array[1..ordem] of real;
vetor_inteiro = array[1..ordem] of integer;
matriz = array[1..ordem,1..ordem] of real;
var
i,j,k,l :integer;
coef_a :matriz;
resp :vetor_real;
x :vetor_real;
coef_b :vetor_inteiro;
nit :integer;
ww :vetor_real;
r,rtil :vetor_real;
p,ptil :vetor_real;
aa,bb :real;
o :array[0..nit_max] of real;
pp :array[0..nit_max] of real;
Arquivo:TEXT;
nome :string;
sair :boolean;
71
opsair :integer;
contr :boolean;
prec :integer;
procedure le_coeficientes_arquivo;
begin
write('Digite o nome do arquivo e extensao:');
readln(nome);
assign(Arquivo, nome);
reset(Arquivo);
while not EOF(Arquivo) do
begin
begin
for j:=1 to ordem do readln(Arquivo, coef_a[i,j]);
readln(Arquivo, coef_b[i]);
end;
end;
close(Arquivo);
end;
procedure le_coeficientes_manual;
begin
begin
begin
write('Digite a',i,j ,':');
readln(coef_a[i,j]);
end;
write('Digite o Coeficiente b',i,':');
readln(coef_b[i]);
end;
end;
procedure exibe_matriz;
begin
write('MATRIZ DE COEFICIENTES A');
begin
writeln('');
begin
write(' ',coef_a[i,j]);
end;
end;
writeln('');
end;
procedure exibe_resultado;
begin
write('VETOR DE RESULTADOS');
begin
writeln('');
writeln('Variavel x',i, ': ',x[i]:10:2);
end;
writeln('Numero de Iteracoes necessarias: ',nit);
end;
72
procedure inicializa;
begin
begin
resp[i]:=0;
x[i]:=0;
end;
end;
function calcule_norma_vetor(var vetor:array of real): real;

var calc: real;
begin
calc:=0;
for i:=0 to ordem-1 do
begin
calc:= (vetor[i]*vetor[i]) + calc;
end;
calcule_norma_vetor:=sqrt(calc);
end;
function calcule_norma_matriz (var mtz: matriz): real;

var calc:real;
begin
calc:=0;
begin
calc:= (mtz[i,j]* mtz[i,j]) + calc;
end;
calcule_norma_matriz:=sqrt(calc);
end;
function calcule_traco_matriz (var mtz: matriz): real;

var calc:real;
begin
calc:=0;
calc:= mtz[i,i] + calc;
calcule_traco_matriz:=calc;
end;
procedure escolha_precondicionador;
var
opcao_a: integer;
contr_a: boolean;
begin
writeln('');
writeln('');
writeln('PRECONDICIONADORES DISPONIVEIS :');
writeln('');
writeln('1 - DIAGONAL PRINCIPAL DA MATRIZ A');
writeln('2 - METODO SSOR');
writeln('3 - METODO DA DECOMPOSICAO LU INCOMPLETA');
writeln('4 - MINIMIZACAO DE FROBENIUS USANDO RESIDUOS MINIMOS');
writeln('5 - MINIMIZACAO DE FROBENIUS USANDO DESCIDA MAIS INGREME');
writeln('');
writeln('');
contr_a:=FALSE;
begin
73
readln(opcao_a);
case opcao_a of
1: begin
prec:=1;
contr_a:=TRUE;
end;
2: begin
prec:=2;
contr_a:=TRUE;
end;
3: begin
prec:=3;
contr_a:=TRUE;
end;
4: begin
prec:=4;
contr_a:=TRUE;
end;
5: begin
prec:=5;
contr_a:=TRUE;
end;
Else
contr_a:=FALSE;
end;{case}
end;{while}
end;
{SEM PRECONDICIONAMENTO}
begin
for i:=1 to ordem do rtil[i]:=r[i];
end;
{PRECONDICIONAMENTO PELA DIAGONAL PRINCIPAL DA MATRIZ A}

begin
rtil[i]:=coef_b_linha[i]/coef_a_linha[i,i];
end;
{PRECONDICIONAMENTO PELO METODO SSOR}

procedure calcule_rtil_2(coef_a_linha:
matriz;coef_b_linha:vetor_real);
var x_aster : vetor_real;
begin
{calcula - w L}
coef_a_linha[i,j]:= -w * coef_a_linha[i,j];
{calcula w r_(k+1)}
for k:=1 to ordem do coef_b_linha[k]:= w * coef_b_linha[k];
{Resolve-se (D - w L) x* = w r_(k+1)}
begin
74
x_aster[k]:=coef_b_linha[k] / coef_a_linha[k,k];
coef_b_linha[i]:= coef_b_linha[i] - x_aster[k] *
coef_a_linha[i,k];
end;
x_aster[ordem]:=coef_b_linha[ordem] / coef_a_linha[ordem,ordem];
{Calcula-se x** = D x*}
for i:=1 to ordem do x_aster[i]:= coef_a[i,i] * x_aster[i];
{Calcula-se w (2 - w) x** }
for k:=1 to ordem do coef_b_linha[k]:= w * (2-w) * x_aster[k];
{Resolve-se (D - w L') rtil = w (2 - w) x** }
for k:= ordem downto 2 do
begin
rtil[k]:=coef_b_linha[k] / coef_a_linha[k,k];
for i:= k-1 downto 1 do
coef_b_linha[i]:= coef_b_linha[i] - rtil[k] * coef_a_linha[i,k];
end;
rtil[1]:=coef_b_linha[1] / coef_a_linha[1,1];
end;
{PRECONDICIONAMENTO PELO METODO DA DECOMPOSICAO LU INCOMPLETA}

var
l: vetor_inteiro;
smax, r , rmax : real;
lk,h : integer;
s : vetor_real;
xmult,soma: real;
begin
begin
j:=1;
l[i]:= i ;
smax:=coef_a_linha[i,j];
if smax<coef_a_linha[i,j] then smax:=coef_a_linha[i,j];
s[i]:= smax;
end;
for k:=1 to ordem-1 do
begin
rmax:= 0;
for i:= k to ordem do
begin
r:= abs(coef_a_linha[l[i], k])/s[l[i]];
if r > rmax then
begin
j:= i;
rmax:= r;
end;
end;
lk:= l[j];
l[j]:= l[k];
l[k]:= lk;
for i:= k + 1 to ordem do
begin
xmult:= coef_a_linha[l[i], j]/coef_a_linha[lk,k];
for h:= k+1 to ordem do
if coef_a_linha[l[i],h] <> 0 then {preservar os coeficientes
nulos}
75
coef_a_linha[l[i], h]:= coef_a_linha[l[i], h] - xmult *
coef_a_linha[lk, h];
coef_a_linha[l[i], k]:= xmult;
end;
end;
coef_b_linha[l[i]]:= coef_b_linha[l[i]] - coef_b_linha[l[k]] *
coef_a_linha[l[i],k];
rtil[ordem]:= coef_b_linha[l[ordem]]/coef_a_linha[l[ordem],ordem];
for i:= ordem-1 downto 1 do
begin
soma:= coef_b_linha[l[i]];
for j:= i+1 to ordem do soma:= soma - rtil[j] *
coef_a_linha[l[i],j];
rtil[i]:= soma/coef_a_linha[l[i],i];
end;
end;
{PRECONDICIONAMENTO PELO MINIMIZACAO DE FROBENIUS USANDO RESIDUOS

MINIMOS}
var
W,C,G,GT,GTA,GTAG : matriz;
stp: integer;
coef_alfa: real;
begin
stp:= 5;
else W[i,j]:=1;
for l:=1 to stp do
begin
{C = A W}
{G = I - C}
if i=j then G[i,j]:= 1 - C[i,j]
else G[i,j]:= - C[i,j];
{GTAG}
for j:=1 to ordem do GTAG[i,j]:=0;
for j:=1 to ordem do GT[i,j]:=G[j,i];
GTA[i,j]:= (GT[i,k] * coef_a_linha[k,j]) + GTA[i,j];
76
GTAG[i,j]:= (GTA[i,k] * G[k,j]) + GTAG[i,j];
{alfa}
coef_alfa:= calcule_traco_matriz(GTAG) / (calcule_norma_matriz(C) *
calcule_norma_matriz(C));
{W novo}
end;
end;
{PRECONDICIONAMENTO PELO MINIMIZACAO DE FROBENIUS USANDO DESCIDA MAIS

INGREME}
var
W,C,R,G,AT,AG : matriz;
stp: integer;
coef_alfa: real;
begin
stp:= 5;
else W[i,j]:=1;
for l:=1 to stp do
begin
{C = A W}
{R = I - C}
if i=j then R[i,j]:= 1 - C[i,j]
else R[i,j]:= - C[i,j];
{G}
for j:=1 to ordem do G[i,j]:=0;
for j:=1 to ordem do AT[i,j]:=coef_a_linha[j,i];
G[i,j]:= (AT[i,k] * R[k,j]) + G[i,j];
{A * G}
AG[i,j]:= (coef_a_linha[i,k] * G[k,j]) + G[i,j];
77
{alfa}
coef_alfa:= (calcule_norma_matriz(G) * calcule_norma_matriz(G)) /
(calcule_norma_matriz(AG) * calcule_norma_matriz(AG));
{W novo}
end;
end;
procedure metodo_GradConjPre;
var
i,j :integer;
Ax :vetor_real;
o_aux :vetor_real;
o :real;
rtilTr :real;
begin
nit:=0;
for i:= 1 to ordem do Ax[i]:=0;
begin
for j:= 1 to ordem do Ax[i]:=(coef_a[i,j] * x[j]) + Ax[i];
r[i]:=coef_b[i] - Ax[i];
end;
case prec of
end;
for i:=1 to ordem do p[i]:=rtil[i];

pp[0]:=0;
for i:=1 to ordem do pp[0]:= (rtil[i]*r[i]) + pp[0];
while (abs(pp[nit])> tol ) do if (nit<nit_max) then
begin
nit:=nit+1;
o:=0;
begin
o:= (o_aux[i] * p[i]) + o;
end;
rtilTr:=0;
rtilTr:= (rtil[i]*r[i]) + rtilTr;
aa:=rtilTr/o;
for i:=1 to ordem do ww[i]:=0;
78
for j:=1 to ordem do ww[i]:= (coef_a[i,j] * p[j]) + ww[i];
begin
x[i]:=x[i] + (aa * p[i]);
r[i]:=r[i] - (aa * ww[i]);
end;
case prec of
end;
pp[nit]:=0;
for i:=1 to ordem do pp[nit]:= (rtil[i]*r[i]) + pp[nit];
bb:=pp[nit] / pp[nit-1];
for i:=1 to ordem do p[i]:= rtil[i] + (bb * p[i]);
end;{while}
end;
procedure metodo_GradBiconj;
var
i,j :integer;
Ap :vetor_real;
o_aux :vetor_real;
rrT :real;
begin
nit:=0;
begin
r[i]:= coef_b[i];
p[i]:= coef_b[i];
rtil[i]:= coef_b[i];
ptil[i]:= coef_b[i];
end;
pp[1]:=0;
for i:=1 to ordem do pp[1]:= (r[i]*r[i]) + pp[1];
pp[0]:=pp[1];
while (pp[nit]> tol ) AND (nit<nit_max) do
begin
nit:=nit+1;
o[nit]:=0;
begin
o[nit]:= (o_aux[i] * p[i]) + o[nit];
end; {end for}
aa:=pp[nit]/o[nit];
for i:= 1 to ordem do Ap[i]:=0;
begin
Ap[i]:=(coef_a[i,j] * p[j]) + Ap[i];
r[i]:= r[i] - aa * Ap[i];
end;
79
x[i]:= x[i] + (aa * p[i]);
begin
Ap[i]:=0;
Ap[i]:=(coef_a[j,i] * ptil[j]) + Ap[i];
rtil[i]:= rtil[i] - aa * Ap[i];
end;
for i:=1 to ordem do rrT:=0;
for i:=1 to ordem do rrT:= (r[i] * r[i]) + rrT;
pp[nit+1]:= rrT;
bb:=pp[nit+1] / pp[nit];
begin
p[i]:= r[i] + (bb * p[i]);
ptil[i]:= rtil[i] + (bb * ptil[i]);
end;
end;{while}
end;
procedure menu_inicial;
var
opcao_a: integer;
contr_a: boolean;
begin
clrscr;
writeln('**********************************************************');
writeln('*
*');
writeln('* METODOS ITERATIVOS NAO ESTACIONARIOS
*');
*');
writeln('*
*');
writeln('* ORDEM DA MATRIZ ',ordem,'
*');
writeln('*
*');
writeln('**********************************************************');
writeln('');
writeln('');
writeln('');
writeln('ENTRADA DE DADOS :');
writeln('');
writeln('1 - DIGITACAO MANUAL');
writeln('2 - ARMAZENADO EM ARQUIVO');
writeln('');
writeln('');
contr_a:=FALSE;
begin
readln(opcao_a);
case opcao_a of
1: begin
le_coeficientes_manual;
contr_a:=TRUE;
80
end;
2: begin
le_coeficientes_arquivo;
contr_a:=TRUE;
end;
Else
contr_a:=FALSE;
end;{case}
end;{while}
clrscr;
end;
procedure menu_metodos;
var
opcao_b: integer;
contr_b: boolean;
begin
clrscr;
writeln('**********************************************************');
writeln('*
*');
writeln('* METODOS ITERATIVOS NAO ESTACIONARIOS
*');
*');
writeln('*
*');
writeln('**********************************************************');
writeln('');
writeln('METODOS : ');
writeln('');
writeln('1 - METODO DOS GRADIENTES CONJUGADOS');
writeln('2 - METODO DOS GRADIENTES CONJUGADOS PRECONDICIONADO');
writeln('3 - METODO DOS GRADIENTES BICONJUGADOS');
writeln('');
writeln('');
writeln('**********************************************************');
writeln('');
contr_b:=FALSE;
while contr_b=FALSE do
begin
write('METODO ESCOLHIDO ->');
readln(opcao_b);
case opcao_b of
1: begin
prec:=0;
metodo_GradConjPre;
contr_b:=TRUE;
end;
2: begin
escolha_precondicionador;
metodo_GradConjPre;
contr_b:=TRUE;
end;
3: begin
metodo_GradBiconj;
contr_b:=TRUE;
end;
81
Else
contr_b:=FALSE;
end;{case}
end;{while}
clrscr;
end;
BEGIN
menu_inicial;
sair:=FALSE;
repeat
inicializa;
menu_metodos;
exibe_resultado;
contr:=false;
while contr=FALSE do
begin
writeln('');
writeln('');
writeln('');
writeln('');
writeln('*********************************************************');
writeln('1 - Executar novamente');
writeln('2 - Sair');
write('OPCAO ->');
readln(opsair);
case opsair of
1: begin
sair:= TRUE;
contr:=TRUE;
end;
2: begin
sair:= FALSE;
contr:=TRUE;
end;
Else
contr:=FALSE;
end;{case}
end;{while}
until sair=FALSE;
END.
82
REFERNCIAS BIBLIOGRFICAS
Oliveira, J.C.(2001). Comunicao pessoal.
Santos, Votoriano R. de Barros.(1976).Curso de Clculo Numrico . Livros Tcnicos e

Cientficos, 3ed, Rio de Janeiro.
Canuto, C., M. Y. Hussaini, et al. (1988). Spectral Methods in Fluid Dynamics,

Springer-Verlag Berlin Heidelberg.
Gottlieb, D. and S. A. Orszag (1977). Numerical Analysis of Spectral Methods: Theory

and Applications, SIAM (Society of Industrial and Applied Mathematics).
R. Barret, M. Berry, T. Chan, J. Demmel, J. Donato, J. Dongarra, V. Eijkhout, R. Pozo,

C. Romine, H. van der Vorst (1994).Templates for the Solution of Linear Systems:
Building Blocks for Iterative Methods. SIAM. Philadelphia, PA.
Y. Saad (1996), Iterative Methods for Sparse Linear Systems, PWS Publishing Co.,
Boston.
L. Hageman, D. Young (1981). Applied Iterative Methods. Academic Press, NY.
D. M. Young (1971). Iterative Solution of Large Linear Systems. Academic Press, NY.
G. H. Golub, C. F. van Loan (1996) . Matrix Computations. The John Hopkins

University Press, Baltimore, Maryland.
83

TCC LuizFernando

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

TCC LuizFernando

Hochgeladen von

Copyright:

Verfügbare Formate

UNIVERSIDADE FEDERAL DE SANTA CATARINA

ESTUDO DE MTODOS ITERATIVOS

AUTOR: LUIZ FERNANDO SPILLERE DE SOUZA

TTULO: ESTUDO DE MTODOS ITERATIVOS NO-ESTACIONRIOS DE

RESOLUO DE GRANDES SISTEMAS LINEARES ESPARSOS

AUTOR: LUIZ FERNANDO SPILLERE DE SOUZA

ORIENTADOR: PROF. JABER C. DE OLIVEIRA

BANCA EXAMINADORA: PROF. DANIEL SANTANA DE FREITAS

PROF. JLIO FELIPE SZEREMETA

Florianpolis, 02 de maio de 2002

Este trabalho tem por objetivo comparar vrios precondicionadores para

We present comparisons among several preconditioning techniques for

O objetivo deste trabalho estudar os mtodos numricos que

Para isso, aps uma breve apresentao dos mtodos diretos,

Aps este estudo inicial, pretendemos estudar os denominados mtodos

Nesse contexto, devemos tambm nos preocupar com as formas de

Nos mtodos diretos, a soluo obtida por uma seqncia finita de

Vamos ento, apresentar rapidamente os mais usuais mtodos diretos

1.1. Mtodo de Eliminao de Gauss

Dado um sistema linear qualquer da forma:

a11 x1 + a12 x 2 + L + a1n x n = b1

o mtodo de Gauss consiste em fazer operaes entre linhas deste sistema at

a'11 x1 + a'12 x 2 + L + a'1n x n = b' 1

determinado na penltima, substituindo-se o valor de x n ; o valor de x n 2 ser obtido na

penltima linha com os valores j determinados de x n e x n 1 , e assim por diante at

1.2. Mtodo de Eliminao de Gauss-Jordan

Este mtodo uma complementao ao mtodo de Gauss. Ele transforma

Sabemos que o um sistema linear pode ser escrito na forma de uma

a11 a12 L a1n M b1

Ento procuraremos chegar a outra matriz, com os passos do mtodo de

que ser associada a um sistema na forma:

1.3. Mtodo de Gauss-Jordan na Inverso de Matrizes

Uma anlise rpida do mtodo de eliminao de Gauss nos mostra que,

De um modo mais formal, podemos dizer que samos de um sistema

e chegamos a outro sistema:

Naturalmente a passagem de uma forma outra no pode ser arbitrria.

1.4. Mtodo de Crout

Observamos que no caso do mtodo de Gauss, podemos transformar uma

calculados no processo. Essa fatorao recebe o nome de mtodo de Crout .

1.5. Consideraes sobre Mtodos Diretos

Apresentamos os mtodos diretos, e estes, aps um certo nmero de

Um mtodo iterativo quando fornece uma seqncia de aproximantes

No caso de mtodos iterativos precisamos sempre saber se a seqncia

Os mtodos iterativos devem ser aplicados quando a matriz dos

2.1. Introduo aos Mtodos Iterativos

Vamos estudar mtodos iterativos para a soluo de sistemas de equaes

onde A uma matriz quadrada sendo que A n x n e b so vetores sendo que b n :

a11 x1 + a12 x 2 + L + a1n x n = b1

Como na realidade no possvel efetuar um nmero infinito de

As principal vantagem dos mtodos iterativos esta no fatos destes

De forma geral, os mtodos iterativos podem ser escritos como:

x ( k +1 ) = Gk x ( k ) + c k , k = 0,1, ..., (3)

onde G k uma matriz conhecida (matriz de iterao) e c k um vetor.

A equao (3) tambm pode ser vista como:

Definio: Um mtodo iterativo dito linear se x ( k +1 ) depende de x ( j ) ,

Definio: Um mtodo iterativo dito estacionrio se Gk e c k dependem

de k. J um mtodo iterativo dito no estacionrio se Gk e c k independem de k.

A expresso geral dos mtodos estacionrios dada por:

x ( k +1 ) = Gx ( k ) + c , k = 0,1, ..., (5)

considerando assim que G e c dependem do contador de iteraes k.

J a expresso gral dos mtodos no-estacionrios dada por:

x ( k +1 ) = Gk x ( k ) + c k k = 0,1, ..., (6)

considerando assim que Gk e c k independem do contador de iteraes k.