Isso é para levar o Método de Jacobi um passo adiante. Onde a melhor solução é x = (x1, x2, ..., xn), se x1 (k + 1) é uma aproximação melhor para o valor de x1 do que x1 (k), então seria melhor encontrarmos o novo valor x1 (k + 1) para usá-lo (em vez do valor antigo que isx1 (k)) para encontrar x2 (k + 1),…, xn (k + 1). Portanto, x1 (k + 1) é encontrado como no Método de Jacobi, mas ao encontrar x2 (k + 1), em vez de usar o valor antigo de x1 (k) e os valores antigos de x3 (k),…, xn (k) , então usamos o novo valor x1 (k + 1) e os antigos valores x3 (k),…, xn (k), e da mesma forma para encontrar x3 (k + 1),…, xn (k + 1). Este processo para encontrar a solução da equação linear dada é chamado de Método de Gauss-Seidel

O método de Gauss-Seidel é uma técnica iterativa para resolver um sistema quadrado de n (n = 3) equações lineares com x desconhecido.
Dado

Ax=B

, para encontrar o sistema de equação x que satisfaça esta condição.
Em mais detalhes, A, x e b em seus componentes são:

Então, a decomposição de A Matrix em seu componente triangular inferior e seu componente triangular superior é dada por:

O sistema de equações lineares é reescrito como:

O método de Gauss-Seidel agora resolve o lado esquerdo desta expressão para x, usando o valor anterior para x no lado direito. Mais formalmente, isso pode ser escrito como:

No entanto, pela forma triangular de L *, os elementos de x (k + 1) podem ser calculados sequencialmente usando substituição direta:

Este processo é repetido continuamente até encontrarmos a melhor solução aproximada com menos erro.
Exemplos:

Input :
3
4x+ y+ 2z= 4
3x+ 5y+ 1z= 7
x+ y+ 3z= 3

Output :
[0, 0, 0]
[1.0, 0.8, 0.39999999999999997]
[0.6000000000000001, 0.9599999999999997, 0.48000000000000004]
[0.52, 0.9919999999999998, 0.49600000000000005]
[0.504, 0.9983999999999998, 0.4992000000000001]
[0.5008, 0.99968, 0.49984]
[0.5001599999999999, 0.9999360000000002, 0.4999679999999999]
[0.500032, 0.9999872, 0.4999936]
[0.5000064, 0.9999974400000001, 0.49999871999999995]
[0.50000128, 0.999999488, 0.4999997439999999]
[0.500000256, 0.9999998976000001, 0.49999994880000004]
[0.5000000512, 0.9999999795199999, 0.4999999897600001]
[0.50000001024, 0.999999995904, 0.499999997952]
[0.500000002048, 0.9999999991808, 0.49999999959040003]
[0.5000000004095999, 0.9999999998361601, 0.49999999991808003]
[0.50000000008192, 0.9999999999672321, 0.49999999998361594]
[0.500000000016384, 0.9999999999934465, 0.49999999999672307]
[0.5000000000032768, 0.9999999999986894, 0.4999999999993445]
[0.5000000000006554, 0.9999999999997378, 0.49999999999986894]
[0.500000000000131, 0.9999999999999478, 0.49999999999997374]
[0.5000000000000262, 0.9999999999999897, 0.49999999999999467]
[0.5000000000000052, 0.9999999999999979, 0.49999999999999895]
[0.5000000000000011, 0.9999999999999994, 0.49999999999999983]
[0.5000000000000002, 0.9999999999999998, 0.5000000000000001]
[0.49999999999999994, 1.0, 0.5]
[0.5, 1.0, 0.5]

Dada a três equação:

4x + y + 2z = 4
3x + 5y + z = 7
x + y + 3z = 3

Primeiro, assumimos que a solução da equação dada é

(0,0,0)

Então, primeiro colocamos o valor de y e z na equação 1 e obtemos o valor de x e atualizamos o valor de x como

(x1,0,0)

Agora, colocando o valor atualizado de x que é x1 e z = 0 na equação 2 para obter y1 e, em seguida, atualizando nossa solução como

(x1,y1,0)

Então, finalmente colocando x1 e y1 na equação 3 para obter z1 e atualizando nossa solução como

(x1,y1,z1)

Agora repita o mesmo processo mais 24 vezes para obter a solução aproximada com erro mínimo.

# Defining our function as seidel which takes 3 arguments
# as A matrix, Solution and B matrix
   
def seidel(a, x ,b):
    #Finding length of a(3)       
    n = len(a)                   
    # for loop for 3 times as to calculate x, y , z
    for j in range(0, n):        
        # temp variable d to store b[j]
        d = b[j]                  
          
        # to calculate respective xi, yi, zi
        for i in range(0, n):     
            if(j != i):
                d-=a[j][i] * x[i]
        # updating the value of our solution        
        x[j] = d / a[j][j]
    # returning our updated solution           
    return x    
   
# int(input())input as number of variable to be solved                
n = 3                              
a = []                            
b = []        
# initial solution depending on n(here n=3)                     
x = [0, 0, 0]                        
a = [[4, 1, 2],[3, 5, 1],[1, 1, 3]]
b = [4,7,3]
print(x)
  
#loop run for m times depending on m the error value
for i in range(0, 25):            
    x = seidel(a, x, b)
    #print each time the updated solution
    print(x)                     

Um exemplo para a versão da array
Um sistema linear mostrado como Ax = b é dado por:

Queremos usar a equação

Onde:

Devemos decompor A na soma de um componente triangular inferior L * e um componente triangular superior estrito U:

O inverso de L * é:

Agora podemos encontrar as coisas restantes:

Agora temos T e C e podemos usá-los para obter os vetores x iterativamente.

Em primeiro lugar, temos que escolher x {0}, podemos apenas adivinhar. Quanto melhor for a suposição, mais rápido será o desempenho do algoritmo.

Supomos:

Então podemos calcular iterativamente outros x {i's}:

Agora sabemos a solução exata que corresponde à resposta calculada acima.

Na verdade, a array A é estritamente dominante na diagonal (mas não definida positiva).