Sistemas Lineares - Eliminação de Gauss em Python
Autor: Julio Cesar Eiras Melanda | Publicado: 2014-05-04T19:37:00-03:00

Boa noite pessoal!

Vamos então começar efetivamente com a série de postagens sobre implementação de algoritmos com Python?

Como prometido no último artigo, hoje trataremos de resolução de sistemas lineares com o método de triangulação.




Conforme prometido, temos aqui a base teórica para o método de resolução de sistemas lineares conhecido como método de eliminação de Gauss:





Neste vídeo é possível ver como resolver um sistema linear através do método de Eliminação de Gauss.

Agora, vejamos um programa simples, feito de modo didático e sem otimizações que pudessem deixar o algoritmo menos legível para iniciantes para resolver em Python um sistema linear via método de Eliminação de Gauss.

Para início de conversa, vamos criar um arquivo de texto ou usar o gerador de matrizes que criamos em Gerador de Matrizes.

Os dados para a matriz para testarmos aqui são:

2.0 2.0 1.0 1.0 7.0
1.0 -1.0 2.0 -1.0 1.0
3.0 2.0 -3.0 -2.0 4.0
4.0 3.0 2.0 1.0 12.0

Esta matriz representa um sistema com as seguintes equações:

2x +&nbsp;2y +&nbsp;z +&nbsp;w &nbsp;= 7.0
x - y +&nbsp;2z - w = 1.0
3x +&nbsp;2y - 3z - 2w = 4.0
4x +&nbsp;3y +&nbsp;2z +&nbsp;w = 12.0

Então, ao algoritmo.

Primeiro, criamos uma função que apresente um menu


def menu():
    os.system('clear')
    print '====================MENU==================='
    print '1...Ler arquivo e resolver o sistema'
    print '0...Sair do programa'
    op = input()
    os.system('clear')
    return op


Agora, vamos criar uma função que mostre na tela uma matriz, assim, podemos ver o que está acontecendo.


def mostraMat(mat):
    for i in range(len(mat)):
        for j in range(len(mat[i])):
            if mat[i][j] &gt;= 0:
                print '  %3.5f' % (mat[i][j]),
            else:
                print ' %3.5f' % (mat[i][j]),
        print '\n'



Bom já é um bom começo.


Precisamos então de uma função para efetivamente ler a matriz que fornecemos ao programa



def le_matriz(arq):
    return [[float(x) for x in line.split()] for line in arq]



Agora, vamos à parte divertida.

Precisamos avaliar se a matriz pode ser resolvida pois já é uma matriz triangular, se podemos aplicar o método de eliminação ou se o sistema não é determinado.

Heis a função que avalia isto.


#========================================================================
#Funcao que avalia se a matriz pode ser resolvida pelo metodo gaussiano&nbsp;
def avaliaMat(mat):
    j = 0
    av = 1
    for i in range(len(mat)):

        while j &lt; i:
            if mat[i][j] != 0.0:
                av = 0
            j = j + 1
        if av == 1:
            if mat[i][j] == 0.0:
                av = -1
    return av



Agora que já conseguimos avaliar se o sistema pode ser resolvido, vamos escrever a função que resolve quando a matriz é triangular.



#========================================================================
#Funcao que resolve quando a matriz e triangular
def resolveTri(mat):
    n = len(mat) - 1
    res = []

    for i in range(len(mat)):
        j = len(mat) - 1
        x = []
        r = 0.0
        while (mat[n][j] != 0):
            x.append(mat[n][j])
            j = j - 1
            if j &lt; 0:
                break
        if len(x) == 1:
            res.append(mat[n][-1] / x[0])
        else:
            i = 0
            for i in range(len(res)):
                r = x[i] * res[i] + r
            res.append((mat[-n][-1] - r) / x[-1])
        n = n - 1
    return res



Esta é uma das partes principais de nosso algoritmo, pois ela que determinará o resultado do sistema.

Agora, escrevemos uma função para achar o maior valor de uma coluna, pois esta etapa é necessária para a pivotação.



#========================================================================
#Funcao que acha o maior numero entre os valores da coluna passada
def achaMaior(mat, i, j):
    maior = 0
    maiorIndice = i
    while i &lt; len(mat):
        if abs(mat[i][j]) &gt; maior:
            maior = mat[i][j]
            maiorIndice = i
        i += 1
    return maiorIndice



Então, chegamos à estrela do nosso algoritmo: a função que efetivamente faz o método de eliminação



#========================================================================
#Funcao que resolve q matriz pelo metodo de gauss
def resolveGauss(mat):
    for j in range(len(mat[0]) - 1):
        i = j
        maior = achaMaior(mat, i, j)
        aux = mat[i]
        mat[i] = mat[maior]
        mat[maior] = aux
        j1 = j
        div = mat[i][j]
        while j1 &lt; len(mat[i]):
            mat[i][j1] = mat[i][j1] / div
            j1 += 1
        i += 1
        while i &lt; len(mat):
            mul = mat[i][j]
            for j1 in range(len(mat[0])):
                mat[i][j1] -= mat[j][j1] * mul
            i += 1
    print '\nMatriz apos pivotacao\n'
    mostraMat(mat)
    r = resolveTri(mat)
    return r



Então, finalmente, uma função para controlar o funcionamento do nosso programa



#========================================================================
def main():
    """Este programa le arquivos contendo matrizes de sistemas lineares&nbsp;
           e os resolve"""

    while True:
        if menu():
            nome_arq = raw_input(
                'Entre com o nome do arquivo de dados\n=&gt;')
            arq = open(nome_arq, "r")
            mat = le_matriz(arq.readlines())

            print 'Matriz extendida do sistema \n'
            mostraMat(mat)

            aval = avaliaMat(mat)
            if aval == 1:
                r = resolveTri(mat)
            elif aval == -1:
                print 'Sistema indeterminado'
                raw_input()
                continue
            else:
                r = resolveGauss(mat)
            for i in range(len(r)):
                print 'x%d=%5.5f' % (i + 1, r[-(i + 1)])
        else:
            exit()
        raw_input()



No final do arquivo, simplesmente adicione uma chamada ao método main
Agora já temos um programa totalmente funcional para resolvermos sistemas lineares usando o método de Gauss em Python!

Vamos testar?

Execute o script num terminal, e quando for solicitado, informe o caminho para o arquivo que contém a matriz que representa o sistema!

Espero que tenham gostado do artigo!

Fiquem à vontade para tirar dúvidas ou dar sua opinião nos comentários!

Para a versão completa do programa, acessem aqui&nbsp;sistlin.py

Até a próxima! Abraços!