O Método de Gauss-Seidel é um método iterativo para resolver sistemas de equações lineares. Ele foi desenvolvido como uma modificação do método de Jacobi-Richardson com o objetivo de acelerar a convergência, ou seja, chegar à solução final com menos iterações.

Enquanto no método de Jacobi cada iteração usa apenas os valores da solução da iteração anterior, o método de Gauss-Seidel utiliza os valores mais recentes assim que eles são calculados dentro da própria iteração. Isso pode acelerar a convergência do método em muitos casos.

Tal como o método de Jacobi, para garantir a convergência do método de Gauss-Seidel de forma eficaz, 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.


Fórmula Matricial Clássica:
$$\large x^{(k+1)}=(D+L)^{-1} (b-Ux^{(k)})$$
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$.
  • $L:$ Matriz triangular inferior contendo os elementos abaixo da diagonal principal de $A$.
  • $(D+L)^{-1}:$ Inversa da soma das matrizes $D$ e $L$.
  • $b:$ Vetor dos termos constantes do sistema de equações.
  • $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 e definindo a aproximação inicial.

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(list(map(lambda x: list(map(lambda y: A[x,y] if x == y else 0, range(A.shape[1]))), range(A.shape[0]))))

"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.matrix(list(map(lambda x: list(map(lambda y: A[x,y] if x > y else 0, range(A.shape[1]))), range(A.shape[0]))))

"Julia"
L = hcat(map(x -> map(y -> if x > y 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.matrix(list(map(lambda x: list(map(lambda y: A[x,y] if x < y else 0, range(A.shape[1]))), range(A.shape[0]))))

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

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


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

$$\begin{matrix} \large x^{(k+1)}=(D+L)^{-1} (b-Ux^{(k)})\\ \small \downarrow \end{matrix}$$

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

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

$$\begin{matrix} x^{(1)} = \scriptsize \begin{pmatrix}0.33333&0.0&0.0\\-0.083333&0.25&0.0\\-0.083333&0.05&0.2 \end{pmatrix} \cdot \begin{pmatrix} 7\\21\\-4 \end{pmatrix}\\ \small \downarrow \end{matrix}$$

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


'Python'
xK = np.array(np.linalg.inv(D+L) @ (b - np.array(A @ x)[0]))[0]

"Julia"
xK = inv(D+L) * (b - 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.


4º 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\\4.6666\\-0.3333 \end{pmatrix} – \begin{pmatrix} 0\\0\\0 \end{pmatrix} |}{| \begin{pmatrix} 2.3333\\4.6666\\-0.3333 \end{pmatrix} |}\\ \downarrow\\ \dfrac{\sqrt{\sum \begin{pmatrix} 2.3333\\4.6666\\-0.3333 \end{pmatrix}^{2}}}{\sqrt{\sum \begin{pmatrix} 2.3333\\4.6666\\-0.3333 \end{pmatrix}^{2}}}\\ \downarrow\\ \dfrac{6.6666}{6.6666}\\ \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.


5º 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.0\\4.1666\\-0.7666 \end{pmatrix}\ \qquad\qquad E_{r}^2 = 0.3077$$

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


$$x^{(3)} = \begin{pmatrix} 3.9777\\4.0638\\-0.7827 \end{pmatrix}\ \qquad\qquad E_{r}^3 = 0.0185$$
$$0.0185 < \epsilon\ \to\ 0.0185 < 0.010\ \to\ \color{tomato} Falso$$


$$x^{(4)} = \begin{pmatrix} 3.9488\\4.0670\\-0.7763 \end{pmatrix}\ \qquad\qquad E_{r}^4 = 0.0052$$
$$0.0052 < \epsilon\ \to\ 0.0052 < 0.010\ \to\ \color{green} Verdadeiro$$


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

$$x^{(4)} = \begin{pmatrix} 3.9488\\4.0670\\-0.7763 \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}\\ \small \downarrow\\ \large \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 = np.array([7, 21, -4])

# 2º passo: Decomposição a matriz A e definindo a aproximação inicial.
D = np.matrix(list(map(lambda x: list(map(lambda y: A[x,y] if x == y else 0, range(A.shape[1]))), range(A.shape[0]))))

L = np.matrix(list(map(lambda x: list(map(lambda y: A[x,y] if x > y else 0, range(A.shape[1]))), range(A.shape[0]))))

U = np.matrix(list(map(lambda x: list(map(lambda y: A[x,y] if x < y else 0, range(A.shape[1]))), range(A.shape[0]))))

x = np.zeros(A.shape[0])

# 3º, 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 # contagem de iterações
     # Fórmula Matricial Clássica
    xK = np.array(np.linalg.inv(D+L) @ (b - np.array(U @ x)[0]))[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): # critério de tolerância (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 e definindo a aproximação inicial.
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])...)'

x = zeros(size(A)[1])

# 3º, 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 # contagem de iterações
    # Fórmula Matricial Clássica
    xK = inv(D+L) * (b-U*x)
    # 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: 4
# Incógnitas: [3.95, 4.07, -0.78]

Variação da Fórmula Iterativa Padrão:

$$\large x^{(k+1)} = \sum_{j \neq i}{B_{i}x^{(k)}}+g_{i}$$

Sendo:

  • $x^{(k+1)}:$ Vetor de aproximações na $k+1$-ésima iteração.
  • $B_{i}:$ Elemento da matriz derivada da matriz $A$ na linha $i$.
  • $x^{(k)}:$ Vetor de aproximações na $k$-ésima iteração.
  • $\sum_{j \neq i}{B_{i}x^{(k)}}:$ Soma dos elementos provenientes da multiplicação de $B_{i}$ por $x^{(k)}$.
  • $g_{i}:$ Elemento do vetor derivado do vetor $b$ na linha $i$.

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.transpose(np.matrix(list(map(lambda x: list(map(lambda y: A[x,y] * (-1) if x != y else 0, range(A.shape[1]))), range(A.shape[0]))))) / list(map(lambda x: A[x,x], range(A.shape[1]))))

"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:

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

$$\downarrow$$

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


'Python'
g = b / list(map(lambda x: A[x,x], range(A.shape[1])))

"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

A fórmula de iteração do método atualiza linha por linha da matriz, cada uma representando uma incógnita do sistema $(x, y, z)$. Com o resultado encontrado em cada incógnita, o mesmo será aplicado na operação seguinte, fazendo uma iteração linha por linha.

$$\scriptsize \begin{matrix} B = \begin{pmatrix} 0&0.3333&-0.3333\\-0.25&0&0.25\\-0.2&0.2&0 \end{pmatrix} \quad x = \begin{pmatrix}0\\0\\0 \end{pmatrix} \quad g = \begin{pmatrix}2.3333\\5.25\\-0.8 \end{pmatrix}\\ \downarrow\\ \small x^{(k+1)} = \sum_{j \neq i}{B_{i}x^{(k)}}+g_{i}\\ \scriptsize \downarrow\\ {\color{lime}x_{1}} = (0\qquad 0.3333\quad -0.3333) \cdot (0, 0, 0) + 2.3333 = {\color{lime}2.3333}\\ \dots\\ {\color{gold}y_{1}} = (-0.25\quad 0\quad 0.25) \cdot ({\color{lime}x_{1}},\ 0,\ 0) + 5.25\\ \downarrow\\ {\color{gold}y_{1}} = (-0.25\quad 0\quad 0.25) \cdot ({\color{lime}2.3333},\ 0,\ 0) + 5.25 = {\color{gold}4.6666}\\ \dots\\ {\color{deepskyblue}z_{1}} = (-0.2\quad 0.2\quad 0) \cdot ({\color{lime}x_{1}},\ {\color{gold}y_{1}},\ 0) + (-0.8)\\ \downarrow\\ {\color{deepskyblue}z_{1}} = (-0.2\quad 0.2\quad 0) \cdot ({\color{lime}2.3333},\ {\color{gold}4.6666},\ 0) + (-0.8) = {\color{deepskyblue}-0.3333}\\ \downarrow\\ x^{(1)} = \begin{pmatrix} {\color{lime}2.3333}\\{\color{gold}4.6666}\\{\color{deepskyblue}-0.3333} \end{pmatrix} \end{matrix}$$


'Python'

x1 = x

for i in range(A.shape[0]):
  xK = np.sum(np.array(B[i]) * x1) + g[i]
  x1[i] = xK

"Julia"

x1 = copy(x)

for i in 1:size(A)[1]
  xK = sum(B[i,:] .* x1) + g[i]
  x1[i] = xK
end

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 = np.array([7, 21, -4])

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

g = b / list(map(lambda x: A[x,x], range(A.shape[1])))

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

# 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 # contagem de iterações
    # Fórmula Iterativa Padrão
    for i in range(A.shape[0]):
        xK = np.sum(np.array(B[i]) * x1) + g[i]
        x1[i] = xK
    # Fórmula do critério de tolerância
    Er = np.sqrt(sum(list(map(lambda x: x**2, np.array(xK).T[0] - x)))) / np.sqrt(sum(list(map(lambda x: x**2, np.array(xK).T[0]))))
    r = list(map(lambda x: round(x,2), x1))
    if Er < 10**(-2): # critério de tolerância (10^(-2))
        print(f"Nº de Iterações: {count} \nIncógnitas: {list(map(lambda x: float(x), r))}")
        break
    x = x1.copy()

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])
x1 = copy(x)

# 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 # contagem de iterações
    # Fórmula Iterativa Padrão
    for i in 1:size(A)[1]
        xK = sum(B[i,:] .* x1) + g[i]
        x1[i] = xK
    end
    # Fórmula do critério de tolerância
    Er = sqrt(sum((xK - x).^2)) / sqrt(sum(xK.^2))
    r = round.(x1, 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 = copy(x1)
end

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

 Fórmula Equacional Iterativa:

$$x_{i}^{(k+1)} = \dfrac{1}{a_{ii}} \left( b_{i} – \sum_{j=1}^{i-1} a_{ij} x_{j}^{(k+1)} – \sum_{j=i+1}^{n} a_{ij}x_{j}^{(k)} \right)$$

$$ou$$

$$x_{i}^{(k+1)} = \dfrac{\left(b_{i} – \sum_{j=1}^{i-1} a_{ij} x_{j}^{(k+1)}- \sum_{j=i+1}^{n} a_{ij}x_{j}^{(k)} \right)}{a_{ii}}$$

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 $j$ do vetor solução na $k$-ésima iteração mais um.
  • $x_{j}^{(k+1)}:$ valor atualizado na iteração $k + 1$.
  • $b_{i}:$ Componente $large 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 $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 $\large x_{j}^{(0)},\ y_{j}^{(0)},\ z_{j}^{(0)}$ será ${\color{gold}0}.$


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

$$ \scriptsize \begin{matrix} x_{i}^{(k+1)} = \dfrac{\left(b_{i} – \sum_{j=1}^{i-1} a_{ij} x_{j}^{(k+1)}- \sum_{j=i+1}^{n} a_{ij}x_{j}^{(k)} \right)}{a_{ii}}\\ \downarrow\\ {\color{deepskyblue}x_{j}^{(1)}} = \dfrac{7 – (-1)(0) + 1(0)}3\ \to\ \dfrac{7}{3}\ \to\ {\color{deepskyblue}2.3333} \\ \\ {\color{lime}y_{j}^{(1)}} = \dfrac{21 – 1({\color{deepskyblue}2.3333}) + (-1)(0)}{4}\ \to\ \dfrac{21}{{4}}\ \to\ {\color{lime}4.6666}\\ \\ {\color{gold}z_{j}^{(1)}} = \dfrac{-4 – 1({\color{deepskyblue}2.3333}) + (-1)({\color{lime}4.6666})}{5}\ \to\ \dfrac{4}{5}\ \to\ {\color{gold}-0.3333} \end{matrix}$$

$$\small x^{(1)} = [x^{(1)},\ y^{(1)},\ z^{(1)}] = [{\color{deepskyblue}2.3333},\ {\color{lime}4.6666}, {\color{gold}-0.3333}]$$


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 = np.array([7, 21, -4])
x = np.zeros(A.shape[0])

count = 0

while True:
    count += 1
    x_ant = x.copy()

    for n in range(A.shape[0]):
        sum_ax = 0.0

        for j in range(A.shape[1]):
            if n != j:
                sum_ax += A[n,j] * x[j]

        x[n] = (b[n] - sum_ax) / A[n,n]

    r = list(map(lambda x: round(x,2), x))
    Er = float(np.sqrt(sum((x - x_ant)**2)) / np.sqrt(sum(x**2)))

    if Er < 10**(-2):
        print(f"Nº de Iterações: {count} \nIncógnitas: {list(map(lambda x: float(x), r))}")
        break

Julia

A = [3 -1 1; 1 4 -1; 1 -1 5]
b = [7, 21, -4]
x = zeros(size(A)[1])

count = 0

while true
    count += 1
    x_ant = copy(x)  # Mantenha uma cópia dos valores antigos para cálculo do erro

    for n in 1:size(A)[1]
        sum_ax = 0.0

        for j in 1:size(A)[2]
            if n != j
                sum_ax += A[n,j] * x[j]
            end
        end

        x[n] = (b[n] - sum_ax) / A[n,n]
    end

    r = round.(x, digits=2)
    Er = sqrt(sum((x - x_ant).^2)) / sqrt(sum(x.^2))

    if Er < 10^(-2)
        println("Nº de Iterações: $count \nIncógnitas: $r")
        break
    end
end

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

Código alternativo (mais curto)

A = [3 -1 1; 1 4 -1; 1 -1 5]
b = [7, 21, -4]
x = zeros(size(A)[1])

count = 0

while true
    count += 1
    x_ant = copy(x)  # Guardar a solução anterior para cálculo do erro

    for n in 1:size(A)[1]
        sum1 = sum(A[n, 1:n-1] .* x[1:n-1])  # Utiliza valores já atualizados
        sum2 = sum(A[n, n+1:end] .* x_ant[n+1:end])  # Utiliza valores da iteração anterior
        x[n] = (b[n] - sum1 - sum2) / A[n, n]  # Atualiza x[n]
    end

    r = round.(x, digits=2)
    Er = sqrt(sum((x - x_ant).^2)) / sqrt(sum(x.^2))

    if Er < 10^(-2)
        println("Nº de Iterações: $count \nIncógnitas: $r")
        break
    end
end

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