Questão sobre eliminação de gauss python

Python NumPy

Afim de estudar o comportamento de sistemas mal-condicionados, iremos resolver sistemas a partir da eliminação de Gauss. Para isso, a sua tarefa é ler uma matriz de ordem n e então encontrar a solução do sistema associado à essa matriz utilizando o método da eliminação para o mesmo.
Porém, como estamos trabalhando com sistemas que podem ser mal-condicionados, temos que verificar o seu condicionamento para aplicar o método, e termos indício da nossa resposta para o vetor solução. Para encontrarmos o número de condicionamento da matriz, multiplicamos o valor das normas matriciais (utilize a norma infinito) da própria matriz e da sua inversa, considere que as matrizes passadas serão não-singulares.
Aplique o método de Gauss-Jordan muito utilizado em álgebra linear para encontrar a inversa da matriz, relembramos que a primeira parte desse método é o escalonamento da matriz, ou seja, a eliminação de Gauss (não será necessário aplicar o pivoteamento, considere que a matriz tem pivôs diferentes de zero e suficientemente grandes).
Encontre a solução do sistema por esse caminho e imprima a matriz inversa com a mensagem inicial: “A matriz inversa de A é:”.
Calcule as normas infinito de ambas as matrizes para encontrar o número de condicionamento de A e o imprima com a mensagem: “O número de condição é:”.
Caso esse número seja maior que 1000, imprima a seguinte mensagem: “Há indícios de mal-condicionamento.”, caso contrário imprima o seguinte: “Não há indícios de mal-condicionamento.”.
Utilize a seguinte linha de código em repetição para tabelar os valores encontrados que satisfazem o sistema de equações: print("x", i, " ", f’{solucao[i]:.2f}’, sep="") E para imprimir a matriz da forma desejada, utilize a seguinte linha de código em repetição para cada elemento matricial: print(f’{matriz[i][j]:.2f}’, end=” ”)
Os valores de entrada estão na seguinte ordem: Ordem n da matriz; Valores dos coeficientes matriciais de A; Valores do vetor de termos independentes b. ​
ATENÇÃO: para essa questão, é proibido o uso de funções que aplicam métodos diretamente. Utilize a biblioteca Numpy (opcional) apenas para declaração e manipulação de matrizes.
Obs.: imprima todos os valores numéricos com 2 casas decimais de precisão.

Exemplo de entrada 1: 2
1.001
1
1
1.0001
2
2.1
Exemplo de saída 1:
A matriz inversa de A é:

909.10 -909.01
-909.01 909.92

O número de condição é 3639.67
Há indícios de mal-condicionamento

x0 -90.72
x1 92.81

Exemplo de entrada 2:
3
4.16
-1.83
2.96
3.62
8.03
-2.66
1.86
1.52
3.74
12.05
-20.73
10.46

Exemplo de saída 2:
A matriz inversa de A é:

0.23 0.08 -0.13
-0.13 0.07 0.15
-0.06 -0.07 0.27

O número de condição é 6.23
Não há indícios de mal-condicionamento

x0 -0.15
x1 -1.38
x2 3.43


Eu fiz o código mas está dando erro, pode me ajudar a consertar?

def gauss_elimination(matriz, n):
    for i in range(n):
        
        pivot = matriz[i][i]
        for j in range(i + 1, n):
            if abs(matriz[j][i]) > abs(pivot):
                matriz[i], matriz[j] = matriz[j], matriz[i]
                pivot = matriz[i][i]

        
        for j in range(i + 1, n):
            ratio = matriz[j][i] / matriz[i][i]
            for k in range(n + 1):
                matriz[j][k] -= ratio * matriz[i][k]

   
    for i in range(n):
        divisor = matriz[i][i]
        for j in range(n + 1):
            matriz[i][j] /= divisor

def calc_norm_inf(matriz, n):
    norm_inf = 0
    for i in range(n):
        row_sum = sum(abs(matriz[i][j]) for j in range(n))
        if row_sum > norm_inf:
            norm_inf = row_sum
    return norm_inf

def main():
    n = int(input())  
    matriz = []
    for _ in range(n):
        linha = list(map(float, input().split()))
        matriz.append(linha + [0.0])  

    
    b = list(map(float, input().split()))

    for i in range(n):
        matriz[i][-1] = b[i]

    
    gauss_elimination(matriz, n)

    
    matriz_inversa = [linha[n:] for linha in matriz]

    norm_a = calc_norm_inf(matriz, n)
    norm_inv_a = calc_norm_inf(matriz_inversa, n)
    condicao = norm_a * norm_inv_a

    print("A matriz inversa de A é:")
    for i in range(n):
        for j in range(n):
            print(f"{matriz_inversa[i][j]:.2f}", end=" ")
        print()

    print(f"O número de condição é: {condicao:.2f}")

    if condicao > 1000:
        print("Há indícios de mal-condicionamento.")
    else:
        print("Não há indícios de mal-condicionamento.")

   
    solucao = [linha[-1] for linha in matriz]
    for i in range(n):
        print(f"x{i} {solucao[i]:.2f}")

if __name__ == "__main__":
    main()

Foto de Eduarda A.
Eduarda perguntou há 9 meses

Sabe a resposta?

Ganhe 10 pts por resposta de qualidade
Responder dúvida
3 respostas
1
votos
1 usuário votou nessa resposta como útil.
Professor Gustavo S.
Identidade verificada
  • CPF verificado
  • E-mail verificado
Respondeu há 9 meses
Melhor resposta
Essa foi a melhor resposta, escolhida pelo autor da dúvida

Boa tarde, tudo bem?? Em matrizes não singulares, o pivot (matriz[i][i]) será igual a 0 em algum momento. Ou seja, a seguinte linha: 

ratio = matriz[j][i] / matriz[i][i]

Resultará em uma divisão por 0. 

 

Envie uma dúvida gratuitamente

Envie sua primeira dúvida gratuitamente aqui no Tira-dúvidas Profes. Nossos professores particulares estão aqui para te ajudar.

0
votos
Nenhum usuário votou nessa resposta como útil.
Professor Jhonni S.
Identidade verificada
  • CPF verificado
  • E-mail verificado
Respondeu há 3 meses

Entendi a descrição da tarefa. Vamos criar um código em Python para resolver esse problema utilizando o método da eliminação de Gauss-Jordan e calcular o número de condicionamento. Para simplificar, vou assumir que os valores de entrada estão na ordem mencionada. A biblioteca NumPy será utilizada apenas para manipulação de matrizes. Certifique-se de tê-la instalada com o comando pip install numpy.

Aqui está o código:

import numpy as np

def gauss_jordan_elimination(A, b):
    n = len(b)
    augmented_matrix = np.hstack((A, b.reshape(-1, 1)))

    for i in range(n):
        # Normalização para ter 1 na diagonal principal
        pivot = augmented_matrix[i, i]
        augmented_matrix[i, :] /= pivot

        # Eliminação para ter zeros abaixo e acima do pivô
        for j in range(n):
            if i != j:
                ratio = augmented_matrix[j, i]
                augmented_matrix[j, :] -= ratio * augmented_matrix[i, :]

    # Extrai a matriz inversa da parte à direita da barra vertical
    inverse_matrix = augmented_matrix[:, n:]

    return inverse_matrix

def calculate_condition_number(A, A_inv):
    norm_A = np.linalg.norm(A, np.inf)
    norm_A_inv = np.linalg.norm(A_inv, np.inf)
    condition_number = norm_A * norm_A_inv

    return condition_number

# Leitura dos valores de entrada
n = int(input())
A_values = list(map(float, input().split()))
b_values = list(map(float, input().split()))

# Criação da matriz A e vetor b
A = np.array(A_values).reshape(n, n)
b = np.array(b_values)

# Aplica o método de eliminação de Gauss-Jordan para encontrar a matriz inversa
A_inv = gauss_jordan_elimination(A, b)

# Imprime a matriz inversa
print("A matriz inversa de A é:")
for i in range(n):
    for j in range(n):
        print(f'{A_inv[i, j]:.2f}', end=" ")
    print()

# Calcula o número de condição e imprime
condition_number = calculate_condition_number(A, A_inv)
print("O número de condição é:", condition_number)

# Verifica mal-condicionamento
if condition_number > 1000:
    print("Há indícios de mal-condicionamento.")
else:
    print("Não há indícios de mal-condicionamento.")

0
votos
Nenhum usuário votou nessa resposta como útil.
Professor Amador R.
Identidade verificada
  • CPF verificado
  • E-mail verificado
Respondeu há 2 semanas

Parece que o principal problema com o seu código é que ele não calcula corretamente a matriz inversa utilizando o método de Gauss-Jordan. O código realiza apenas uma parte da eliminação de Gauss, escalonando a matriz para resolver o sistema linear, mas não aplica as operações necessárias para encontrar a inversa da matriz.

Para corrigir e completar seu código, é necessário implementar a parte que aplica o método de Gauss-Jordan para calcular a matriz inversa. Além disso, há um problema na forma como você está tratando a matriz de entrada e os termos independentes (vetor ): você os está combinando de uma maneira que não permite a aplicação correta do método de Gauss-Jordan para encontrar a inversa.

Aqui está uma versão revisada do seu código que inclui a correção e implementa a lógica para calcular a matriz inversa e a solução do sistema:

import numpy as np

def gauss_jordan(matriz, n):
    inversa = np.identity(n)  # Criar a matriz identidade para a inversa
    for i in range(n):
        # Normalizar a linha atual
        divisor = matriz[i][i]
        matriz[i] /= divisor
        inversa[i] /= divisor

        # Zero as outras linhas na coluna atual
        for j in range(n):
            if i != j:
                factor = matriz[j][i]
                matriz[j] -= factor * matriz[i]
                inversa[j] -= factor * inversa[i]

    return inversa

def calc_norm_inf(matriz):
    return max(sum(abs(x) for x in row) for row in matriz)

def main():
    n = int(input("Ordem n da matriz: "))  
    valores = [float(input(f"Valor {i+1}: ")) for i in range(n**2)]
    matriz = np.array(valores).reshape(n, n)

    b = np.array([float(input(f"Termo independente {i+1}: ")) for i in range(n)])

    matriz_inversa = gauss_jordan(matriz.copy(), n)  # Cópia da matriz para preservar a original

    norm_a = calc_norm_inf(matriz)
    norm_inv_a = calc_norm_inf(matriz_inversa)
    condicao = norm_a * norm_inv_a

    print("A matriz inversa de A é:")
    for i in range(n):
        for j in range(n):
            print(f"{matriz_inversa[i][j]:.2f}", end=" ")
        print()

    print(f"O número de condição é: {condicao:.2f}")
    if condicao > 1000:
        print("Há indícios de mal-condicionamento.")
    else:
        print("Não há indícios de mal-condicionamento.")

    solucao = np.dot(matriz_inversa, b)  # Solução do sistema
    for i in range(n):
        print(f"x{i} {solucao[i]:.2f}")

if __name__ == "__main__":
    main()

Este código assume a entrada como você especificou, lê uma matriz de ordem , e utiliza o método de Gauss-Jordan para calcular a matriz inversa. Além disso, ele calcula o número de condição utilizando a norma infinito e verifica o condicionamento do sistema.

 

Professores particulares de Python

+ Ver todos
Encontre professor particular para te ajudar nos estudos
R$ 100 / h
Gustavo S.
São Paulo / SP
Gustavo S.
4,4 (29 avaliações)
Horas de aulas particulares ministradas 2 horas de aula
Tarefas resolvidas 56 tarefas resolvidas
Identidade verificada
  • CPF verificado
  • E-mail verificado
Python - Geral
Mestrado: Ciências Econômicas (Fundação Getúlio Vargas (FGV))
Professor de Matemática, Cálculo, Informática Geral
R$ 60 / h
César D.
Mogi Guaçu / SP
César D.
4,9 (811 avaliações)
Horas de aulas particulares ministradas 87 horas de aula
Tarefas resolvidas 995 tarefas resolvidas
Identidade verificada
  • CPF verificado
  • E-mail verificado
1ª hora grátis
Programação em Python NumPy Python - Geral Programação em Python Básico
Graduação: Matemática Aplicada e Computacional (Universidade Estadual de Campinas (UNICAMP))
Faça aulas de matemática, computação e programação em c, c++, java e python.
R$ 120 / h
Johny L.
Fortaleza / CE
Johny L.
4,3 (36 avaliações)
Horas de aulas particulares ministradas 94 horas de aula
Tarefas resolvidas 29 tarefas resolvidas
Identidade verificada
  • CPF verificado
  • E-mail verificado
Programação em Python NumPy Python - OO Python - Geral
Graduação: Engenharia Civil (IFCE - Campus Fortaleza)
Professor da UFC - Aulas de estatística práticas e aplicadas ao mercado de trabalho além de acadêmico