Método de Eliminação de Gauss

O Método de Eliminação de Gauss é uma técnica fundamental utilizada para resolver sistemas lineares de equações. Este método consiste em transformar um sistema linear em uma forma triangular superior, facilitando a resolução do mesmo através da substituição retroativa.

Passos Básicos Do Método

Forma Triangular Superior:
- O objetivo é transformar o sistema linear original em uma matriz triangular superior.
- Isso é feito através de operações elementares nas linhas do sistema, sem alterar a solução do mesmo.
Operações Elementares:
- Adição múltipla de uma linha à outra.
- Troca de duas linhas entre si.
- Multiplicação de uma linha por um escalar não nulo.
Etapa de Eliminação:
- Para cada coluna, a ideia é eliminar os elementos abaixo da diagonal principal.
- Isso é feito multiplicando a primeira equação pelo fator adequado e subtraindo-a das demais equações correspondentes.
Etapa de Substituição Retroativa:
- Após obter a forma triangular superior, o sistema pode ser resolvido facilmente através da substituição retroativa.
- Começa pela última equação e resolve para a última variável, depois usa esse valor na penúltima equação, e assim por diante.

Exemplo de Aplicação Do Método de Eliminação de Gauss

Considere o seguinte sistema linear de equações:

{\begin{cases} 2 x + 3 y - z = 1 \\ 4 x - y + 2 z = 7 \\ - 2 x + 2 y + 5 z = 0 \end{cases}

Passos Básicos Do Método

Forma Triangular Superior:

Primeiro, transformamos o sistema em uma matriz aumentada:

[\begin{array}{cccc} 2 & 3 & - 1 & 1 \\ 4 & - 1 & 2 & 7 \\ - 2 & 2 & 5 & 0 \end{array}]

Etapa de Eliminação:

Eliminando $x$ na segunda linha:
Multiplicamos a primeira linha por 2 e subtraímos da segunda linha:

R_{2} = R_{2} - 2 R_{1}

Resultado:

[\begin{array}{cccc} 2 & 3 & - 1 & 1 \\ 0 & - 7 & 4 & 5 \\ - 2 & 2 & 5 & 0 \end{array}]

Eliminando $x$ na terceira linha:
Multiplicamos a primeira linha por 1 e somamos à terceira linha:

R_{3} = R_{3} + R_{1}

Resultado:

[\begin{array}{cccc} 2 & 3 & - 1 & 1 \\ 0 & - 7 & 4 & 5 \\ 0 & 5 & 4 & 1 \end{array}]

Eliminando $y$ na terceira linha:
Multiplicamos a segunda linha por $\frac{5}{7}$ e subtraímos da terceira linha:

R_{3} = R_{3} - \frac{5}{7} R_{2}

Resultado:

[\begin{array}{cccc} 2 & 3 & - 1 & 1 \\ 0 & - 7 & 4 & 5 \\ 0 & 0 & \frac{8}{7} & - \frac{18}{7} \end{array}]

Agora, temos a matriz triangular superior:

[\begin{array}{cccc} 2 & 3 & - 1 & 1 \\ 0 & - 7 & 4 & 5 \\ 0 & 0 & \frac{8}{7} & - \frac{18}{7} \end{array}]

Etapa de Substituição Retroativa:
- Resolvendo a última equação:

\frac{8}{7} z = - \frac{18}{7} ⟹ z = - \frac{18}{7} \cdot \frac{7}{8} = - \frac{9}{4}

Resolvendo a segunda equação:
Substituindo $z$ na segunda equação:

- 7 y + 4 (- \frac{9}{4}) = 5 ⟹ - 7 y - 9 = 5 ⟹ - 7 y = 14 ⟹ y = - 2

Resolvendo a primeira equação:
Substituindo $y$ e $z$ na primeira equação:

2 x + 3 (- 2) - (- \frac{9}{4}) = 1 ⟹ 2 x - 6 + \frac{9}{4} = 1 ⟹ 2 x - \frac{24}{4} + \frac{9}{4} = 1 ⟹ 2 x - \frac{15}{4} = 1

2 x = 1 + \frac{15}{4} ⟹ 2 x = \frac{4}{4} + \frac{15}{4} ⟹ 2 x = \frac{19}{4} ⟹ x = \frac{19}{8}

Portanto, a solução do sistema é:

x = \frac{19}{8}, y = - 2, z = - \frac{9}{4}

Código em Python

def print_matrix(a, b):
    """
    Print the augmented matrix [A|b] in a readable format.
    """
    n = len(b)
    for i in range(n):
        row = "  ".join(f"{a[i][j]:8.4f}" for j in range(n))
        print(f"[ {row} ] | {b[i]:8.4f}")
    print()

def gauss_elimination_verbose(a, b):
    """
    Solve the linear system Ax = b using Gaussian elimination with partial pivoting.
    Prints each step of the elimination and back substitution process.

    Parameters:
    a -- Coefficient matrix (list of lists, will be modified in-place)
    b -- Right-hand side vector (list, will be modified in-place)

    Returns:
    x -- Solution vector (list)
    """
    n = len(b)

    print("Initial augmented matrix:")
    print_matrix(a, b)

	# Forward Elimination
    for i in range(n):
		# Partial Pivoting: Find The Row With The Largest Value In Column I
        max_row = i + max(range(n - i), key=lambda k: abs(a[i + k][i]))
        if abs(a[max_row][i]) < 1e-12:
            raise ValueError("Matrix is singular or nearly singular")

		# Swap Rows If Needed
        if max_row != i:
            a[i], a[max_row] = a[max_row], a[i]
            b[i], b[max_row] = b[max_row], b[i]
            print(f"Swapped row {i} with row {max_row}")
            print_matrix(a, b)

		# Eliminate Entries Below The Pivot
        for j in range(i + 1, n):
            factor = a[j][i] / a[i][i]
            for k in range(i, n):
                a[j][k] -= factor * a[i][k]
            b[j] -= factor * b[i]
            print(f"Eliminated row {j} using row {i} with factor {factor:.4f}")
            print_matrix(a, b)

	# Back Substitution
    x = [0 for _ in range(n)]
    print("Back substitution:")
    for i in reversed(range(n)):
        s = sum(a[i][j] * x[j] for j in range(i + 1, n))
        x[i] = (b[i] - s) / a[i][i]
        print(f"x[{i}] = {x[i]:.4f}")

    print("\nFinal solution:", x)
    return x

if __name__ == "__main__":
    A = [
        [1, 2, 1, 1, 2],
        [0, 1, 2, 2, 3],
        [1, 0, 2, 3, 2],
        [1, 1, 1, 2, 1],
        [2, 1, 0, 1, 1]
    ]
    B = [31, 31, 27, 23, 22]

    solution = gauss_elimination_verbose([row[:] for row in A], B[:])

Extra

![[Escalonamento.pdf]]