O Método de Jacobi é um método iterativo para resolver sistemas de equações lineares. Ele é especialmente útil para sistemas grandes e esparsos, nos quais a maioria dos elementos da matriz de coeficientes é zero, onde métodos diretos, como eliminação gaussiana, podem ser computacionalmente impraticáveis.

O Método de Jacobi funciona iterativamente, ajustando os valores das variáveis desconhecidas de forma sucessiva até que convirjam para a solução do sistema de equações lineares. Em cada iteração, o valor de uma variável é atualizado com base nos valores atuais das demais variáveis.


Condições necessárias para o funcionamento do método
Dominância Diagonal (Preferencial): A matriz deve ser diagonalmente dominante. Isso significa que para cada linha :


Em outras palavras, o valor absoluto do elemento diagonal de cada linha deve ser maior ou igual à soma dos valores absolutos de todos os outros elementos dessa linha.
Critério de Sassenfeld (Alternativa): O critério de Sassenfeld é uma condição mais geral e menos restritiva que a dominância diagonal. Ele estabelece uma série de testes para garantir a convergência do método de Jacobi. O critério é aplicado iterativamente:


Se para todos os , então o método de Jacobi converge.
Esparsidade da Matriz Embora não seja uma condição estrita para a convergência, o método de Jacobi é mais eficiente quando aplicado a matrizes esparsas, onde a maioria dos elementos são zero.

Para utilizar o método de Jacobi de forma eficaz e garantir a convergência, a matriz $A$ deve ser preferencialmente Diagonalmente dominante. Alternativamente, pode-se usar o Critério de Sassenfeld para verificar a convergência em casos onde a dominância diagonal não é evidente.

A dominância diagonal é uma condição suficiente, mas não necessária, e ajuda a assegurar a estabilidade e a eficiência do método.


Fórmula Matricial Clássica:


$$\large x^{(k+1)}=D^{-1} \Big(b – (L+U)x^{(k)} \Big)$$

Sendo:

  • $x^{(k+1)}:$ Vetor de aproximações na $k+1$-ésima iteração.
  • $D:$ Matriz contendo os elementos da diagonal principal da matriz $A$.
  • $D^{-1}:$ Inversa da matriz diagonal $D$.
  • $b:$ Vetor dos termos constantes do sistema de equações.
  • $L:$ Matriz triangular inferior contendo os elementos abaixo da diagonal principal de $A$.
  • $U:$ Matriz triangular inferior contendo os elementos acima da diagonal principal de $A$.
  • $x^{(k)}:$ Vetor de aproximações na $k$-ésima iteração.

 

Exemplo

Considere o sistema linear:

$$\large \begin{cases} 3x – y + z = 7 \\ x + 4y – z = 21 \\ x – y + 5z = -4 \end{cases}$$


1º Passo: Reescrever o sistema em notação matricial, criando uma matriz dos coeficientes e um vetor dos resultados.

$$A = \begin{pmatrix} 3&-1&1\\1&4&-1\\1&-1&5 \end{pmatrix},\ b = \begin{pmatrix} 7\\21\\-4 \end{pmatrix}$$


2º Passo: Decomposição a matriz A

D: Matriz contendo os elementos da diagonal principal da matriz A

$$D = \begin{pmatrix}3&0&0\\0&4&0\\0&0&5 \end{pmatrix}$$

'Python'
D = np.matrix([[int(A[x, y]) if y == x else 0 for x in range(A.shape[0])] for y in range(A.shape[1])])

"Julia"
D = hcat(map(x -> map(y -> if y == x A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)

L: Matriz triangular contendo os elementos abaixo da diagonal principal de A

$$L = \begin{pmatrix}0&0&0\\1&0&0\\1&-1&0 \end{pmatrix}$$

'Python'
L = np.transpose(np.matrix([[int(A[x, y]) if y < x else 0 for x in range(A.shape[0])] for y in range(A.shape[1])]))

"Julia"
L = hcat(map(x -> map(y -> if y < x A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)'

U: Matriz triangular contendo os elementos acima da diagonal principal de A

$$U = \begin{pmatrix}0&-1&1\\0&0&-1\\0&0&0 \end{pmatrix}$$

'Python'
U = np.transpose(np.matrix([[int(A[x, y]) if y > x else 0 for x in range(A.shape[0])] for y in range(A.shape[1])]))

"Julia"
U = hcat(map(x -> map(y -> if y > x A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)'

3º Passo: Calculando a inversa da matriz D e definindo a aproximação inicial

$$\begin{matrix} D = \begin{pmatrix}3&0&0\\0&4&0\\0&0&5 \end{pmatrix}\\ \downarrow\\ D^{-1} = \begin{pmatrix}0.333333&0&0\\0&0.25&0\\0&0&0.2 \end{pmatrix} \end{matrix}$$

A aproximação inicial será 0 $\to\ x^{(0)} = \begin{pmatrix}0\\0\\0 \end{pmatrix}$


4º Passo: Fórmula de Iteração

$$\begin{matrix} x^{(0+1)}=D^{-1} \Big(b – (L+U)x^{(0)} \Big)\\ \downarrow \end{matrix}$$

$$\tiny \begin{matrix} x^{(1)} = \begin{pmatrix}0.333333&0&0\\0&0.25&0\\0&0&0.2 \end{pmatrix} \cdot \left( \begin{pmatrix} 7\\21\\-4 \end{pmatrix} – \left( \begin{pmatrix}0&0&0\\1&0&0\\1&-1&0 \end{pmatrix} + \begin{pmatrix}0&-1&1\\0&0&-1\\0&0&0 \end{pmatrix} \right) \cdot \begin{pmatrix}0\\0\\0 \end{pmatrix} \right)\\ \downarrow \end{matrix}$$

$$\tiny \begin{matrix} x^{(1)} = \begin{pmatrix}0.333333&0&0\\0&0.25&0\\0&0&0.2 \end{pmatrix} \cdot \left( \begin{pmatrix} 7\\21\\-4 \end{pmatrix} – \begin{pmatrix}0&-1&1\\1&0&-1\\1&-1&0 \end{pmatrix} \cdot \begin{pmatrix}0\\0\\0 \end{pmatrix} \right)\\ \downarrow \end{matrix}$$

$$\begin{matrix} x^{(1)} = \small \begin{pmatrix}0.333333&0&0\\0&0.25&0\\0&0&0.2 \end{pmatrix} \cdot \left( \begin{pmatrix} 7\\21\\-4 \end{pmatrix} – \begin{pmatrix}0\\0\\0 \end{pmatrix} \right)\\ \downarrow \end{matrix}$$

$$\begin{matrix} x^{(1)} = \small \begin{pmatrix}0.333333&0&0\\0&0.25&0\\0&0&0.2 \end{pmatrix} \cdot \begin{pmatrix} 7\\21\\-4 \end{pmatrix}\\ \downarrow \end{matrix}$$

$$x^{(1)} = \normalsize \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix}$$

"Python"
xK = np.array(np.dot(np.linalg.inv(D), (b - np.dot((L+U), x)).T)).T[0]

"Julia"
xK = inv(D) * (b-(L+U)*x)

 O processo será repetido iterativamente usando as novas estimativas. Para a segunda iteração, substituímos $x^{(1)}$ em lugar de $x^{(0)}$ e repetimos os cálculos.


5º Passo: Critério de Tolerância

O processo é repetido até que a diferença entre $x^{(k+1)}$ e $x^{(k)}$ seja menor que um determinado Critério de Tolerância. Para descobrir se essa diferença foi alcançada será utilizado a Norma do Erro Relativo, e a tolerância $(\epsilon)$ será de 10-2 (0.010):

$$\begin{matrix} E_{r}^{1} = \dfrac{|| \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix} – \begin{pmatrix} 0\\0\\0 \end{pmatrix} ||}{|| \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix} ||}\\ \downarrow\\ \dfrac{\sqrt{\sum \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix}^{2}}}{\sqrt{\sum \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix}^{2}}}\\ \downarrow\\ \dfrac{6.7833}{6.7833}\\ \downarrow\\ 1.0 \end{matrix}$$


$$1.0 < \epsilon \to 1.0 < 0.010 \to \color{tomato} Falso$$

Como o valor do erro relativo encontrado não é menor que a tolerância, o processo iterativo será repetido, substituindo o valor encontrado $x^{1}$ por $x^{2}$, e assim, sucessivamente.

6º Passo: Processo de Iteração

Durante o processo iterativo, quando a fórmula para calcular o critério de tolerância $(E_{r},\ E_{a},\ Res,\ E_{m})$ retorna um valor abaixo da tolerância $(\epsilon)$, o processo iterativo é interrompido e o resultado obtido da fórmula iterativa $(x^{(k+1)})$ deve corresponder às incógnitas do sistema.

$$x^{(2)} = \begin{pmatrix} 4.35\\4.46666\\-0.2166 \end{pmatrix}\ \qquad\qquad E_{r}^2 = 0.3592$$

$$0.3592 < \epsilon\ \to\ 0.3592 < 0.010\ \to\ \color{tomato} Falso$$

$$x^{(3)} = \begin{pmatrix} 3.8944\\4.1083\\-0.7766 \end{pmatrix}\ \qquad\qquad E_{r}^3 = 0.1410$$

$$0.1410 < \epsilon\ \to\ 0.1410 < 0.010\ \to\ \color{tomato} Falso$$

$$x^{(4)} = \begin{pmatrix} 3.9617\\4.0822\\-0.7572 \end{pmatrix}\ \qquad\qquad E_{r}^4 = 0.0130$$

$$0.0130 < \epsilon\ \to\ 0.0130 < 0.010\ \to\ \color{tomato} Falso$$

$$x^{(5)} = \begin{pmatrix} 3.9465\\4.0703\\-0.7759 \end{pmatrix}\ \qquad\qquad E_{r}^5 = 0.0047$$

$$0.0047 < \epsilon\ \to\ 0.0047 < 0.010\ \to\ \color{green} Verdadeiro$$


Após a 5ª iteração, o critério de tolerância foi atingido e o resultado das incógnitas encontrado.

$$x^{(5)} = \begin{pmatrix} 3.9465\\4.0703\\-0.7759 \end{pmatrix}\ \to\ \begin{matrix} x \to\\ y \to\\ z \to \end{matrix} \begin{pmatrix} 3.95\\4.07\\-0.78 \end{pmatrix}$$


Com os resultados encontrados, pode-se verificar sua assertividade no próprio sistema:

$$\large \begin{matrix} \begin{cases} 3x-y+z=7\ \ \\x+4y-z=21\ \\x-y+5z=-4 \end{cases} \\ \downarrow\\ \begin{cases} 3 \cdot 3.95 – 4.07 + (-0.78)=7\ \ \\ 3.95 + 4 \cdot 4.07 – (-0.78)=21\ \\ 3.95 – 4.07 + 5 \cdot (-0.78)=-4 \end{cases} \end{matrix}$$

Exemplos

Python

import numpy as np

# 1º passo: Reescrever o sistema em notação matricial
A = np.matrix([[3, -1, 1], [1, 4, -1], [1, -1, 5]])
b = [7, 21, -4]

# 2º passo: Decomposição a matriz A
D = np.matrix([[int(A[x, y]) if x == y else 0 for x in range(A.shape[0])] for y in range(A.shape[1])])

L = np.transpose(np.matrix([[int(A[x, y]) if y < x else 0 for x in range(A.shape[0])] for y in range(A.shape[1])]))

U = np.transpose(np.matrix([[int(A[x, y]) if y > x else 0 for x in range(A.shape[0])] for y in range(A.shape[1])]))

# 3º passo: Calculando a inversa da matriz D e definindo a aproximação inicial
invD = np.linalg.inv(D)
x = np.zeros(A.shape[0])

# 4º, 5º e 6º passos: Processo de iteração e critério de tolerância (A fórmula do critério de tolerância utilizada será a Norma do Erro Relativo)
count = 0

while True:
    count += 1
    # Fórmula Matricial Clássica
    xK = np.array(np.dot(invD, (b - np.dot((L+U), x)).T)).T[0]
    # Fórmula do critério de tolerância
    Er = float(np.sqrt(sum((xK - x)**2)) / np.sqrt(sum(xK**2)))
    r = list(map(lambda x: round(x,2), xK))
    if Er < 10**(-2):
        print(f'Nº de Iterações: {count} \nIncógnitas: {list(map(lambda x: float(x), r))}')
        break
    x = xK

Julia

# 1º passo: Reescrever o sistema em notação matricial
A = [3 -1 1; 1 4 -1; 1 -1 5] 
b = [7, 21, -4]

# 2º passo: Decomposição a matriz A
D = hcat(map(x -> map(y -> if y == x A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)

L = hcat(map(x -> map(y -> if y < x A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)'

U = hcat(map(x -> map(y -> if y > x A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)'

# 3º passo: Calculando a inversa da matriz D e definindo a aproximação inicial
invD = inv(D)
x = zeros(size(A)[1])

# 4º, 5º e 6º passos: Processo de iteração e critério de tolerância (A fórmula do critério de tolerância utilizada será a Norma do Erro Relativo)
count = 0

while true
    count += 1
    # Fórmula Matricial Clássica
    xK = invD * (b-(L+U)*x)
    # Fórmula do critério de tolerância
    Er = sqrt(sum(map(x-> x^2, xK-x))) / sqrt(sum(map(x-> x^2, xK)))
    r = round.(xK, digits=2)
    if Er < 10^(-2) # critério de tolerância (10^(-2))
        println("Nº de Iterações: $countnIncógnitas: $r")
        break
    end
    x = xK
end

# RESPOSTA:
# Nº de Iterações: 5
# Incógnitas: [3.95, 4.07, -0.78]

Fórmula Iterativa Padrão:


$$\Large x^{(k+1)}=Bx^{(k)}+g$$

Sendo:

  • $x^{(k+1)}:$ Vetor de aproximações na $k+1$-ésima iteração.
  • $B:$ Matriz derivada da matriz $A$, obtida com a divisão, por linha, dos elementos pelos coeficientes da diagonal principal, transformação dos elementos da diagonal principal em 0 e inversão dos sinais dos demais elementos.
  • $x^{(k)}:$ Vetor de aproximações na $k$-ésima iteração.
  • $g:$ Vetor derivado do vetor $b$, obtido com a divisão dos elementos de $b$ pelos coeficientes da diagonal principal de $A$.

Exemplo

 Utilizando o mesmo sistema linear do exemplo anterior:

$$\large \begin{cases} 3x – y + z = 7 \\ x + 4y – z = 21 \\ x – y + 5z = -4 \end{cases}$$


1º Passo: Reescrever o sistema em notação matricial, criando uma matriz dos coeficientes e um vetor dos resultados.

$$A = \begin{pmatrix} 3&-1&1\\1&4&-1\\1&-1&5 \end{pmatrix},\ b = \begin{pmatrix} 7\\21\\-4 \end{pmatrix}$$


2º Passo: Encontrando a matriz $\color{white} B$ e o vetor $\color{white} g.$

Encontrando a matriz B:

$$\begin{matrix} A = \begin{pmatrix} \color{orangered}3&-1&1\\1&\color{orangered}4&-1\\1&-1&\color{orangered}5 \end{pmatrix}\\ \downarrow\\ \left( \begin{pmatrix} 0&-1&1\\1&0&-1\\1&-1&0 \end{pmatrix} \div \begin{pmatrix} \color{orangered}3\\ \color{orangered}4\\ \color{orangered}5 \end{pmatrix} \right) \cdot (-1) \end{matrix}$$

$$\downarrow$$

$$B = \begin{pmatrix} 0&0.3333&-0.3333\\-0.25&0&0.25\\-0.2&0.2&0 \end{pmatrix}$$

"Python"
B = np.transpose(np.matrix([[float(A[x, y]) * (-1) if x != y else 0 for x in range(A.shape[0])] for y in range(A.shape[1])])) / np.matrix(list(map(lambda x: int(A[x,x]), range(A.shape[0])))).T

"Julia"
B = hcat(map(x -> map(y -> if x != y A[x,y] * (-1) else 0 end, 1:size(A)[1]), 1:size(A)[2])...)' ./ map(x -> A[x,x], 1:size(A)[1])
Encontrando o vetor g:

$$\begin{matrix} b = \begin{pmatrix} 7\\21\\-4 \end{pmatrix}\\ \downarrow\\ \left( \begin{pmatrix} 7\\21\\-4 \end{pmatrix} \div \begin{pmatrix} \color{orangered}3\\ \color{orangered}4\\ \color{orangered}5 \end{pmatrix} \right) \end{matrix}$$

$$\downarrow$$

$$g = \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix}$$

"Python"
g = (np.matrix(b) / np.matrix(list(map(lambda x: int(A[x,x]), range(A.shape[0]))))).T

"Julia"
g = b ./ map(x -> A[x,x], 1:size(A)[1])

3º Passo: Definindo a aproximação inicial

A aproximação inicial será 0 $\to\ x^{(0)} = \begin{pmatrix}0\\0\\0 \end{pmatrix}$


4º Passo: Fórmula de Iteração

$$\begin{matrix} x^{(k+1)}=Bx^{(k)}+g\\ \downarrow\\ \scriptsize x^{(1)} = \begin{pmatrix} 0&0.3333&-0.3333\\-0.25&0&0.25\\-0.2&0.2&0 \end{pmatrix} \cdot \begin{pmatrix}0\\0\\0 \end{pmatrix} + \begin{pmatrix}2.3333\\5.25\\-0.8 \end{pmatrix}\\ \normalsize \downarrow\\ x^{(1)} = \begin{pmatrix}0\\0\\0 \end{pmatrix} + \begin{pmatrix}2.3333\\5.25\\-0.8 \end{pmatrix}\\ \downarrow\\ x^{(1)} = \begin{pmatrix} 2.3333\\5.25\\-0.8 \end{pmatrix} \end{matrix}$$

"Python"
xK = np.array(B * np.matrix(x).T + g).T[0]

"Julia"
xK = B * x + g

 O processo será repetido iterativamente usando as novas estimativas. Para a segunda iteração, substituímos $x^{(1)}$ em lugar de $x^{(0)}$ e repetimos os cálculos.

O resultado será submetido à fórmula do Critério de Tolerância, e será aplicado no processo de iteração até que a tolerância seja atingida.

A sequência de passos não será demonstrada porque já foi demonstrada no exemplo anterior.

Exemplos

Python

import numpy as np

# 1º passo: Reescrever o sistema em notação matricial
A = np.matrix([[3, -1, 1], [1, 4, -1], [1, -1, 5]])
b = [7, 21, -4]

# 2º passo: Encontrando a matriz "B" e o vetor "g"
B = np.transpose(np.matrix([[float(A[x, y]) * (-1) if x != y else 0 for x in range(A.shape[0])] for y in range(A.shape[1])])) / np.matrix(list(map(lambda x: int(A[x,x]), range(A.shape[0])))).T

g = (np.matrix(b) / np.matrix(list(map(lambda x: int(A[x,x]), range(A.shape[0]))))).T

# 3º passo: Definindo a aproximação inicial
x = np.zeros(A.shape[0])

# 4º e 5º passos: Processo de iteração e critério de tolerância (A fórmula do critério de tolerância utilizada será a Norma do Erro Relativo)
count = 0

while True:
    count += 1
    # Fórmula Iterativa Padrão
    xK = np.array(B * np.matrix(x).T + g).T[0]
    # Fórmula do critério de tolerância
    Er = float(np.sqrt(sum((xK - x)**2)) / np.sqrt(sum(xK**2)))
    r = list(map(lambda x: round(x,2), xK))
    if Er < 10**(-2):
        print(f'Nº de Iterações: {count} \nIncógnitas: {list(map(lambda x: float(x), r))}')
        break
    x = xK

Julia

# 1º passo: Reescrever o sistema em notação matricial
A = [3 -1 1; 1 4 -1; 1 -1 5] 
b = [7, 21, -4]

# 2º passo: Encontrando a matriz "B" e o vetor "g"
B = hcat(map(x -> map(y -> if x != y A[x,y] * (-1) else 0 end, 1:size(A)[1]), 1:size(A)[2])...)' ./ map(x -> A[x,x], 1:size(A)[1])

g = b ./ map(x -> A[x,x], 1:size(A)[1])

# 3º passo: Definindo a aproximação inicial
x = zeros(size(A)[1])

# 4º e 5º passos: Processo de iteração e critério de tolerância (A fórmula do critério de tolerância utilizada será a Norma do Erro Relativo)
count = 0

while true
    count += 1
    # Fórmula Iterativa Padrão
    xK = B*x+g
    # Fórmula do critério de tolerância
    Er = sqrt(sum(map(x-> x^2, xK-x))) / sqrt(sum(map(x-> x^2, xK)))
    r = round.(xK, digits=2)
    if Er < 10^(-2) # critério de tolerância (10^(-2))
        println("Nº de Iterações: $count \nIncógnitas: $r")
        break
    end
    x = xK
end

# RESPOSTA:
# Nº de Iterações: 5
# Incógnitas: [3.95, 4.07, -0.78]

Fórmula Equacional Iterativa:


$$\begin{matrix} x_{i}^{(k+1)} = \dfrac{\left(b_{i} – \sum_{j \neq i} a_{ij} x_{j}^{(k)} \right)}{a_{ii}}\\ \ ou\\ \ x_{i}^{(k+1)} = \dfrac{1}{a_{ii}} \left( b_{i} – \sum_{j \neq i} a_{ij} x_{j}^{(k)} \right) \end{matrix}$$

Sendo:

  • $k:$ Iteração atual (começa em 0).
  • $x_{i}^{(k+1)}:$ Vetor de aproximações na $k+1$-ésima iteração.
  • $x_{j}^{(k)}:$ Componente $large j$ do vetor solução na $k$-ésima iteração.
  • $b_{i}:$ Componente $i$ do vetor de constantes $b$.
  • $a_{ij}:$ Elemento da matriz $A$ na linha $i$ e coluna $j$.
  • $a_{ii}:$ Elemento da diagonal principal da matriz $A$ na linha $i$ e coluna $large i$.

Exemplo

Utilizando o mesmo sistema linear do exemplo anterior:

$$\large \begin{cases} {\color{lime}3}x – y + z = {\color{deepskyblue}7} \\ x + {\color{lime}4}y – z = {\color{deepskyblue}21} \\ x – y + {\color{lime}5}z = {\color{deepskyblue}-4} \end{cases}$$

Como essa fórmula é equacional, não é necessário colocar a fórmula na forma matricial.


1º Passo: Definindo a aproximação inicial

A aproximação inicial para $x_{j}^{(0)},\ y_{j}^{(0)},\ z_{j}^{(0)}$ será ${\color{gold}0}.$


2º Passo: Fórmula de Iteração

$$\begin{matrix} x_{i}^{(k+1)} = \dfrac{\left(b_{i} – \sum_{j \neq i} a_{ij} x_{j}^{(k)} \right)}{a_{ii}}\\ \downarrow\\ \ x_{j}^{(1)} = \dfrac{{\color{deepskyblue}7} – (-1)({\color{gold}0}) + 1({\color{gold}0})}{\color{lime}3}\ \to\ \dfrac{{\color{deepskyblue}7}}{{\color{lime}3}}\ \to\ 2.3333 \\ y_{j}^{(1)} = \dfrac{{\color{deepskyblue}21} – 1({\color{gold}0}) + (-1)({\color{gold}0})}{\color{lime}4}\ \to\ \dfrac{{\color{deepskyblue}21}}{{\color{lime}4}}\ \to\ 5.25\\ \ z_{j}^{(1)} = \dfrac{{\color{deepskyblue}-4} – 1({\color{gold}0}) + (-1)({\color{gold}0})}{\color{lime}5}\ \to\ \dfrac{{\color{deepskyblue}-4}}{{\color{lime}5}}\ \to\ -0.8 \end{matrix}$$
$$x^{(1)} = [x^{(1)},\ y^{(1)},\ z^{(1)}] = [2.3333,\ 5.25, -0.8]$$

 O processo será repetido iterativamente usando as novas estimativas para $x,y$ e $z$.

O resultado será submetido à fórmula do Critério de Tolerância, e será aplicado no processo de iteração até que a tolerância seja atingida.

A sequência de passos não será demonstrada porque já foi demonstrada no exemplo anterior.

Exemplos

Python

import numpy as np

# 1º passo: Reescrever o sistema em notação matricial
A = np.matrix([[3, -1, 1], [1, 4, -1], [1, -1, 5]])
b = [7, 21, -4]

# 2º passo: Encontrando o aij e o aii
aij = np.transpose(np.matrix([[float(A[x, y]) if x != y else 0 for x in range(A.shape[0])] for y in range(A.shape[1])]))

aii = np.matrix(list(map(lambda x: int(A[x,x]), range(A.shape[0])))).T

# 3º passo: Definindo a aproximação inicial
x = np.zeros(A.shape[0])

# 4º e 5º passos: Processo de iteração e critério de tolerância (A fórmula do critério de tolerância utilizada será a Norma do Erro Relativo)
count = 0

while True:
    count += 1
    # Fórmula Iterativa Padrão
    xK = np.array((np.matrix(b).T - aij * np.matrix(x).T) / aii).T[0]
    # Fórmula do critério de tolerância
    Er = float(np.sqrt(sum((xK - x)**2)) / np.sqrt(sum(xK**2)))
    r = list(map(lambda x: round(x,2), xK))
    if Er < 10**(-2):
        print(f'Nº de Iterações: {count} \nIncógnitas: {list(map(lambda x: float(x), r))}')
        break
    x = xK

Julia

# 1º passo: Reescrever o sistema em notação matricial
A = [3 -1 1; 1 4 -1; 1 -1 5] 
b = [7, 21, -4]

# 2º passo: Encontrando o aij e o aii
aij = hcat(map(x -> map(y -> if x != y A[x,y] else 0 end, 1:size(A)[2]), 1:size(A)[1])...)'

aii = map(x -> A[x,x], 1:size(A)[1])

# 3º passo: Definindo a aproximação inicial
x = zeros(size(A)[1])

# 4º e 5º passos: Processo de iteração e critério de tolerância (A fórmula do critério de tolerância utilizada será a Norma do Erro Relativo)
count = 0

while true
    count += 1
    # Fórmula Iterativa Padrão
    xK = (b - aij * x) ./ aii
    # Fórmula do critério de tolerância
    Er = sqrt(sum((xK - x).^2)) / sqrt(sum(xK.^2))
    r = round.(xK, digits=2)
    if Er < 10^(-2) # critério de tolerância (10^(-2))
        println("Nº de Iterações: $count \nIncógnitas: $r")
        break
    end
    x = xK
end

# RESPOSTA:
# Nº de Iterações: 5
# Incógnitas: [3.95, 4.07, -0.78]