Disciplina: Métodos Numéricos

Temática: Métodos Iterativos na

Álgebra das Matrizes

Professor: Vinícius da Rocha Motta

vinicius.motta@uvv.br
Introdução
● A apresentação aborda a utilização de algoritmos
iterativos para solução de sistemas lineares.
● Esses algoritmos são eficientes para sistemas de grande
porte e/ou esparsos, comuns em análise de circuitos e
solução numérica de problemas de contorno e equações
diferenciais.
 Introdução

Um algoritmo numérico é composto

principalmente por algoritmos
iterativos, que consistem em uma
tentativa inicial, uma equação de
recorrência e um teste de parada.
Introdução

● SELAs são amplamente utilizados na engenharia para

resolver problemas como a determinação do potencial em
redes elétricas e cálculo da tensão na estrutura metálica da
construção civil.
● A resolução de um conjunto de equações lineares também é
necessária para estudar métodos numéricos de resolução
de equações diferenciais parciais.
Métodos Iterativos Estacionários

● são um conjunto de algoritmos

usados para resolver sistemas de
equações lineares.
● eles são usados principalmente
para resolver sistemas de grande
porte e esparsos, onde as técnicas
diretas, como a eliminação
gaussiana, podem ser ineficientes.
Métodos Iterativos Estacionários
A solução x de um sistema Ax=b pode ser obtida utilizando-se um método
iterativo, que consiste em calcular uma sequência

de aproximação para a solução x, sendo dada uma aproximação inicial

Para tanto, transformamos o sistema dado em um equivalente da forma:

x = Fx + d
Métodos Iterativos Estacionários

em que F é uma matriz de ordem n e x e d são matrizes n × 1.

Partindo de uma aproximação inicial

obtemos:
Métodos Iterativos Estacionários
Seja é uma forma comum de verificar a convergência de
métodos iterativos de solução de sistemas de
equações lineares, como os métodos iterativos
estacionários. Essa expressão indica que a norma
do vetor de diferenças entre a solução atual x(k+1)
e a solução anterior x é igual ao valor máximo da
diferença entre as coordenadas dos vetores.
Se

significa que a norma do vetor resultante da subtração

entre x(k+1) e x converge para zero à medida que o
então, a sequência número de iterações k tende ao infinito, ou seja, a
solução converge para um valor estável e não muda
mais nas próximas iterações.

converge para a solução do sistema Ax = b.

Existem várias maneiras de obtermos o sistema reescrito na forma x = Fx + d. E daí surgem os diversos métodos.
Os métodos iterativos estacionários são usados para resolver sistemas lineares, ou seja, encontrar a solução de um
conjunto de equações lineares. Esses métodos envolvem a iteração de uma fórmula matemática até que se atinja
uma solução satisfatória.

Em Python, é possível implementar esses métodos por meio de código. Alguns exemplos de métodos iterativos
estacionários são o método de Gauss-Seidel e o método de Jacobi.

Abaixo segue um exemplo de implementação do método de Gauss-Seidel em Python:

def gauss_seidel(A, b, x0, tol=1e-6, max_iter=1000):
n = len(b)
x = x0.copy()
Nesse código, A é uma matriz de
for k in range(max_iter):
coeficientes do sistema linear, b é
um vetor de termos independentes, for i in range(n):
x0 é um vetor inicial para as s = 0
soluções, tol é a tolerância, ou seja, for j in range(n):
a precisão da solução, e max_iter é if j != i:
o número máximo de iterações.
s += A[i][j] * x[j]

Para utilizar o método, basta x[i] = (b[i] - s) / A[i][i]

chamar a função gauss_seidel(A, b, if abs(max(abs(x - x0))) < tol:
x0) com os valores adequados para return x
A, b e x0. x0 = x.copy()
raise ValueError('O método de Gauss-Seidel não converge após {}
iterações.'.format(max_iter))
Para chamar a função, você pode usar o seguinte código:

A = [[10, 2, 1], [1, 5, 1], [2, 3, 10]]

b = [7, -8, 6]
x0 = [0, 0, 0]

solucao = gauss_seidel(np.array(A), np.array(b),

np.array(x0))

print("Solução final:", solucao)

Neste exemplo, a função gauss_seidel recebe como entrada uma matriz A, um vetor b, um vetor inicial x0, uma
tolerância tol e um número máximo de iterações max_iter.

A matriz A é a matriz dos coeficientes do sistema linear, b é o vetor das constantes do sistema linear e x0 é o
vetor inicial da solução.

A função retorna o vetor x, que é a solução aproximada do sistema linear.

No exemplo, a matriz A, o vetor b e o vetor inicial x0 são definidos e a função gauss_seidel é chamada para
calcular a solução do sistema linear. Em seguida, a solução é impressa na tela.
Método iterativo estacionário de Jacobi

O método iterativo estacionário de Jacobi é um método utilizado para

resolver sistemas lineares de equações.

Ele é um dos métodos iterativos mais simples e consiste em utilizar

uma fórmula iterativa para atualizar as aproximações da solução do
sistema até que a solução seja suficientemente precisa.
Método iterativo estacionário de Jacobi

O método de Jacobi é baseado na decomposição da matriz dos

coeficientes em três matrizes: uma diagonal, uma triangular inferior e
uma triangular superior.

A partir dessa decomposição, é possível escrever um sistema de

equações equivalentes em que a matriz dos coeficientes é diagonal e
os termos independentes são atualizados em cada iteração com base
nas soluções obtidas nas iterações anteriores.
Método iterativo estacionário de Jacobi 3x + y + z = 9
x + 4y + z = 8
A matriz F é chamada matriz de iteração 2x + y + 5z = 13
Iniciaremos decompondo a matriz dos coeficientes do sistema como na forma seguinte:

A=D+L+U
D = [[3, 0, 0],
A = [[3, 1, 1],
[0, 4, 0],
[1, 4, 1], Decomposição [0, 0, 5]]
[2, 1, 5]]
Sendo que:
L = [[0, 0, 0],
D = matriz diagonal [1, 0, 0],
[2, 1, 0]]
L = matriz estritamente triangular inferior
U = [[0, 1, 1],
[0, 0, 1],
U = matriz estritamente triangular superior [0, 0, 0]]

Das diversas formas de escolher as combinações com essas três matrizes surgem as matrizes de
iteração e os diferentes métodos iterativos.
Método iterativo estacionário de Jacobi

● Exemplo 1

O método iterativo é dito estacionário quando a matriz F for fixa.

Com essa decomposição, podemos escrever o sistema de equações equivalente como:

x_{k+1} = D^{-1} (b - Lx_k - Ux_k)

 Método iterativo estacionário de Jacobi

onde x_k é a aproximação da solução na k-ésima iteração e x_{k+1} é a aproximação na k+1-ésima iteração. O
termo D^{-1} (b - Lx_k - Ux_k) é o valor atualizado dos termos independentes do sistema.

Para aplicar o método de Jacobi, escolhemos uma aproximação inicial x_0 e atualizamos essa aproximação
usando a fórmula iterativa até que a solução seja suficientemente precisa. Por exemplo, podemos escolher x_0 =
[0, 0, 0] e aplicar a fórmula iterativa para obter as novas aproximações:

x_{1} = D^{-1} (b - Lx_0 - Ux_0) = [3, 2, 2]

x_{2} = D^{-1} (b - Lx_1 - Ux_1) = [2.8333, 1.4167, 2.3667]
x_{3} = D^{-1} (b - Lx_2 - Ux_2) = [2.8389, 1.3529, 2.3063]
Métodos Iterativos Estacionários

Quando os processos variam e um vetor aproximante é

obtido a partir do anterior, porém, com um processo
diferente, ou seja, a matriz iteração F varia após alguns
passos, dizemos que o processo é m-cíclico.
Condição de Convergência

TEOREMA
Para calcular o valor de ro, precisamos encontrar o valor máximo absoluto de todos os elementos da matriz F. Isso pode
ser feito com o seguinte código em Python:

import numpy as np

# Definir a matriz A
A = np.array([[10, 2, 1],
No exemplo ao lado, a matriz A é
[1, 5, 1],
[2, 3, 10]])
definida manualmente, mas pode ser
# Separar em matrizes D, L e U substituída por outra matriz de
D = np.diag(np.diag(A))
L = np.tril(A, k=-1) coeficientes. O valor de ro é calculado
U = np.triu(A, k=1)
usando a função np.linalg.eigvals, que
# Calcular a matriz de iteração F
F = -np.linalg.inv(D).dot(L + U) retorna os autovalores da matriz F. O
# Calcular o valor de ro valor máximo absoluto dos autovalores é
ro = np.max(np.abs(np.linalg.eigvals(F)))
print('Valor de ro: ', ro) encontrado usando a função
np.max(np.abs()).
Condição de Convergência
Conforme Campos (2013), o cálculo do raio espectral da matriz iteração F, de forma
geral, é difícil de verificar e pode ocorrer de o esforço computacional empregado nesse
cálculo ser maior do que o esforço para calcular a resolução do sistema linear.
TEOREMA
O raio espectral da matriz iteração F pode ser calculado utilizando a biblioteca NumPy do Python da
seguinte maneira:

import numpy as np

# matriz de iteração F Neste exemplo, a matriz de iteração F tem dimensão 3x3 e é

F = np.array([[0.1, 0.2, 0.3], [0.2, 0.3, definida como:
0.1], [0.3, 0.1, 0.2]])
| 0.1 0.2 0.3 |
| 0.2 0.3 0.1 |
# cálculo do raio espectral
| 0.3 0.1 0.2 |
ro = np.max(np.abs(np.linalg.eigvals(F)))
O resultado do cálculo do raio espectral é impresso na tela.
print(ro)
Critério de parada

O critério absoluto e o relativo são utilizados para avaliar a

convergência de uma sequência numérica.

O critério absoluto considera uma tolerância fixa em relação ao valor

absoluto do erro cometido em cada iteração. Assim, o método iterativo
é considerado convergente quando o valor absoluto do erro cometido
for menor que a tolerância definida.
Critério de parada
Já o critério relativo considera uma tolerância em relação ao valor da solução. Assim, o
método iterativo é considerado convergente quando o erro relativo for menor que a
tolerância definida. O erro relativo é dado pela razão entre o valor absoluto do erro
cometido na iteração atual e o valor absoluto da solução atual.

Em geral, o critério relativo é mais adequado para avaliar a convergência de métodos

iterativos, pois leva em consideração a magnitude da solução. Porém, em algumas
situações pode ser mais conveniente utilizar o critério absoluto, principalmente quando
a solução esperada é próxima de zero.
Critério de Parada
É preciso fornecer uma precisão ou tolerância para podermos parar quando atingirmos a
precisão e estipular um número máximo de iterações que chamaremos de ITMAX.

Vamos comparar dois vetores e usar o critério absoluto ou o relativo. Optamos por usar o
teste relativo.
O critério relativo é utilizado para verificar se a solução obtida por um método iterativo está
próxima o suficiente da solução exata. Em geral, é utilizado o critério de parada de que a variação
relativa entre as iterações consecutivas deve ser menor do que uma tolerância pré-definida.

Em Python, podemos implementar esse critério da seguinte forma:

def criterio_relativo(x_antigo, x_novo, tol):

if max(abs(x_novo - x_antigo) / max(abs(x_novo), 1e-8)) < tol:
return True
else:
return False

Nessa implementação, x_antigo e x_novo são os vetores de soluções nas iterações k e k+1,
respectivamente, e tol é a tolerância relativa. A função retorna True se o critério de parada foi satisfeito e
False caso contrário. O valor 1e-8 é utilizado como limite inferior para evitar divisão por zero caso x_novo
seja próximo de zero.
 Critério de Parada
Ou, ainda, podemos usar como teste de parada o número máximo de iterações (ITMAX).

Se a precisão estabelecida não for atingida, mas ITMAX for parar o processo e emitir a mensagem, não foi possível
obter a solução aproximada com esse número de iterações.

Na realidade, o processo deve ser interrompido quando algum critério de parada for satisfeito
A norma do infinito é uma medida de distância vetorial
que representa o maior valor absoluto entre as
entradas do vetor. Matematicamente, a norma do Neste texto, adotamos a norma do
infinito de um vetor x = [x1, x2, ..., xn] é dada por: infinito para o cálculo do erro em cada
||x||∞ = max(|x1|, |x2|, ..., |xn|) iteração.

Em outras palavras, a norma do infinito é igual ao valor A tolerância ∈ define com qual exatidão a
absoluto da maior entrada do vetor.
solução é calculada.
Código abaixo calcula a norma do infinito de um vetor v em Python:
import numpy as np Nesse exemplo, o vetor v possui 5

v = np.array([2, -3, 1, 4, 0])

elementos e sua norma do infinito é 4.

norm_inf = np.linalg.norm(v, np.inf)

print(norm_inf)
Critérios de Convergência

Os critérios de convergência são condições que devem ser

satisfeitas para garantir que um método numérico iterativo
produza soluções precisas e confiáveis.
Existem vários critérios de convergência, mas alguns dos
mais comuns são:
Critérios de Convergência
● Critério das diferenças: consiste em comparar as diferenças entre as
iterações sucessivas do método iterativo. O método é considerado
convergente se a diferença entre duas iterações consecutivas for menor do
que uma tolerância pré-determinada.
● Critério do erro absoluto: consiste em comparar o erro absoluto entre a
solução atual e a solução exata do problema. O método é considerado
convergente se o erro absoluto for menor do que uma tolerância
pré-determinada.
● Critério do erro relativo: consiste em comparar o erro relativo entre a
solução atual e a solução exata do problema. O método é considerado
convergente se o erro relativo for menor do que uma tolerância
pré-determinada.
Critérios de Convergência

● Critério do raio espectral: é baseado na propriedade de que o método

iterativo converge se e somente se o raio espectral da matriz de
iteração for menor do que 1. O raio espectral é a magnitude do maior
autovalor da matriz de iteração.
● Critério da norma infinita: é baseado na norma infinita da matriz de
iteração. O método é considerado convergente se a norma infinita for
menor do que uma tolerância pré-determinada.
Métodos Iterativos de Jacobi-Richardson

O método de Jacobi-Richardson é adequado

para matrizes esparsas, ou seja, matrizes
com muitos elementos iguais a zero. É um
método simples e fácil de implementar, mas
pode ser lento para convergir em algumas
situações, principalmente quando a matriz do
sistema é mal condicionada.
Critérios de Convergência
 Critérios de Convergência
"Diagonal estritamente dominante" é uma propriedade matemática importante em
sistemas lineares, especialmente na análise de métodos iterativos para resolvê-los.
Basicamente, uma matriz é considerada diagonal estritamente dominante se o valor
absoluto do elemento diagonal é maior que a soma dos valores absolutos dos demais
elementos daquela linha. Essa propriedade é importante porque garante que certos
métodos iterativos, como o método de Jacobi e o método de Gauss-Seidel, irão convergir
para a solução do sistema linear.
 Critérios de Convergência
Esse critério é importante para garantir a convergência de métodos iterativos como o método de
Gauss-Seidel e o método de Jacobi. Se a matriz A não satisfaz o critério das colunas, esses
métodos podem não convergir para uma solução ou apresentar convergência lenta. Nesses
casos, é necessário utilizar outros métodos iterativos ou técnicas de pré-condicionamento para
melhorar a convergência.

Observe que se a matriz for diagonal estritamente dominante, o critério das linhas é satisfeito.

b) O critério das colunas, isto é, se:

Critérios de Convergência
Resolva o sistema por Jacobi usando como aproximação inicial. Use tolerância de 0.005 e
Itmax = 7. Avalie a convergência do sistema para o método de Jacobi.
Critérios de Convergência
Solução:

a) Avaliar a convergência

A matriz dos coeficientes é diagonal estritamente dominante. Logo, satisfaz ao critério das
linhas. Então, o sistema converge para a solução independentemente do vetor inicial
fornecido.

b) Vamos escrever a fórmula de recorrência

Critérios de Convergência
 Método Iterativo de Gauss-Seidel
O método de Gauss-Sedeil pode ser considerado uma “aceleração” do método de Jacobi, pois em
geral, nas mesmas condições, ele fornece a solução mais rapidamente.

Ele consiste em reescrever uma determinada iteração na seguinte forma:

Considere o sistema linear Ax = b de ordem n, determinado (det(A) ≠ 0).

A matriz A do sistema linear pode ser decomposta desta forma:

A=D+L+U
Método Iterativo de Gauss-Seidel
Supondo det(D) ≠ 0, podemos transformar o sistema linear original em:

A técnica iterativa de Seidel toma a forma seguinte:

Método Iterativo de Gauss-Seidel
 Critérios de Convergência
É condição suficiente para convergência do método iterativo de Jacobi-Richardson e
Gauss-Seidel que a matriz A seja diagonal estritamente dominante.

No caso do método de Gauss-Seidel, ainda temos o Critério de Sassenfeld.

Seja:

Se

então, podemos garantir a convergência para a solução do SELA, usando o método

de Gauss-Seidel, independentemente do vetor inicial fornecido.
 Critérios de Convergência
Exemplo 3

Resolva o sistema linear a seguir utilizando o método de Gauss-Seidel, observando:

a) O sistema deve satisfazer a um critério de convergência.

b) Escreva a fórmula de recorrência do método.

c) Use como aproximação inicial o vetor nulo.

d) Trabalhe com tolerância < 0.0001, e com o número máximo de cinco iterações.

e) Use seis casas decimais fixadas na calculadora.

 Critérios de Convergência
Solução

a) Avaliação da convergência

A matriz A dos coeficientes não está diagonal estritamente dominante e, da forma como se encontra,
não podemos usar um método numérico para resolvê-la, porque existem zeros na diagonal principal
e não é possível efetuar divisão por zero.

Desta forma, vamos permutar as linhas, de forma a colocar os maiores elementos na diagonal
principal.
 Critérios de Convergência
Assim, a matriz dos coeficientes se tornou diagonal estritamente dominante e conseguimos garantir
a convergência para a solução, usando o método de Gauss-Seidel, independentemente do vetor de
aproximação inicial fornecido.
 Critérios de Convergência

Não foi possível obter a

solução aproximada com
esse número de iterações
import numpy as np

# Definir a matriz de coeficientes A e o vetor do lado direito b

A = np.array([[ 4, 1, 1],
[ 3, 5, 1],
[ 1, 1, 3]])
b = np.array([4, 7, 3])

# Definir a tolerância e o número máximo de iterações

tol = 1e-10
max_iter = 1000

# Definir a aproximação inicial x0

x0 = np.zeros_like( b)

# Definir a matriz diagonal D e as matrizes M e N

D = np.diag(np.diag(A))
M = D
N = D - A
# Inicializar a aproximação x e o número de iterações
x = x0
iter_num = 0

# Loop até que a tolerância seja atingida ou o número máximo de iterações

seja alcançado
while np.linalg.norm(np.dot(A, x) - b) > tol and iter_num < max_iter:
x = np.dot(np.linalg.inv(M), np.dot(N, x) + b)
iter_num += 1

# Verificar se a solução converge

if iter_num == max_iter:
print("O método não converge após {} iterações".format(max_iter))
else:
print("A solução converge após {} iterações:\n{}".format(iter_num, x))
Dúvidas?
vinicius.motta@uvv.br