Desenvolva um programa amigável ao usuário para solução de sistemas algébricos lineares que utilizem:
Decomposição LU, incluindo o recurso de calcular a matriz inversa
Passo 1
Beleza, vamos lá! A gente tem que desenvolver um programa amigável para resolver sistemas de equações lineares usando a Decomposição LU e que também consiga calcular a matriz inversa. Então, vamos precisar entender um pouquinho sobre sistemas lineares, a decomposição LU e como isso ajuda a resolver o sistema e encontrar a matriz inversa.
Passo 2
Primeiro, vamos entender o que é um sistema de equações lineares. É um conjunto de equações onde cada uma é uma linha reta, e a gente quer encontrar os valores das variáveis que satisfazem todas elas ao mesmo tempo. Por exemplo:
Passo 3
Agora, vamos falar sobre a Decomposição LU. Basicamente, qualquer matriz quadrada pode ser decomposta em duas matrizes: L (inferior) e U (superior), de forma que A = LU . Isso facilita muito a resolução de sistemas, porque primeiro resolvemos Ly = b e depois Ux = y .
Passo 4
Para calcular a matriz inversa usando a decomposição LU, a gente resolve AX = I , onde I é a matriz identidade. Como A = LU , ficamos LUx = I . Primeiro, resolvemos Ly = I e depois Ux = y para cada coluna de I .
Passo 5
Vamos começar a programar! Vamos usar Python, que é fácil de entender. Primeiro, precisamos importar as bibliotecas necessárias:
import numpy as np
Passo 6
Em seguida, vamos criar uma função para fazer a decomposição LU. Vamos seguir o método de Doolittle, onde a diagonal da matriz L é composta por 1’s.
defdecomposicao_LU(A):
n = A.shape[0]
L = np.zeros_like(A)
U = np.zeros_like(A)
for i inrange(n):
# Calculando os elementos de Ufor k inrange(i, n):
U[i, k] = A[i, k] - sum(L[i, j] * U[j, k] for j inrange(i))
# Calculando os elementos de Lfor k inrange(i, n):
if i == k:
L[i, i] = 1else:
L[k, i] = (A[k, i] - sum(L[k, j] * U[j, i] for j inrange(i))) / U[i, i]
return L, U
Passo 7
Agora, vamos criar uma função para resolver Ly = b usando substituição direta:
defsubstituicao_direta(L, b):
n = L.shape[0]
y = np.zeros_like(b, dtype=np.double)
for i inrange(n):
y[i] = b[i] - sum(L[i, j] * y[j] for j inrange(i))
return y
Passo 8
E outra função para resolver Ux = y usando substituição retroativa:
defsubstituicao_retrospectiva(U, y):
n = U.shape[0]
x = np.zeros_like(y, dtype=np.double)
for i inreversed(range(n)):
x[i] = (y[i] - sum(U[i, j] * x[j] for j inrange(i+1, n))) / U[i, i]
return x
Passo 9
Vamos criar a função principal que resolve o sistema Ax = b usando as funções anteriores:
defresolver_sistema(A, b):
L, U = decomposicao_LU(A)
y = substituicao_direta(L, b)
x = substituicao_retrospectiva(U, y)
return x
Passo 10
Agora, para calcular a matriz inversa, vamos resolver A X = I . Vamos criar uma função para isso:
defmatriz_inversa(A):
n = A.shape[0]
I = np.identity(n)
inv = np.zeros_like(A, dtype=np.double)
L, U = decomposicao_LU(A)
for i inrange(n):
e = I[:, i]
y = substituicao_direta(L, e)
inv[:, i] = substituicao_retrospectiva(U, y)
return inv
Passo 11
Por fim, vamos criar uma interface simples para o usuário inserir a matriz e o vetor, e escolher entre resolver o sistema ou calcular a inversa:
defmain():
n = int(input("Digite o tamanho da matriz quadrada: "))
print("Digite os elementos da matriz A, linha por linha:")
A = np.array([list(map(float, input().split())) for _ inrange(n)])
print("Digite os elementos do vetor b:")
b = np.array(list(map(float, input().split())))
print("\nEscolha uma opção:")
print("1. Resolver o sistema Ax = b")
print("2. Calcular a matriz inversa de A")
escolha = input("Digite 1 ou 2: ")
if escolha == '1':
x = resolver_sistema(A, b)
print("A solução do sistema é:", x)
elif escolha == '2':
inv = matriz_inversa(A)
print("A matriz inversa de A é:")
print(inv)
else:
print("Opção inválida!")
if __name__ == "__main__":
main()
Resposta
Pronto! Com esse programa, você pode inserir uma matriz quadrada e um vetor, e escolher entre resolver o sistema de equações ou calcular a matriz inversa usando a decomposição LU. Basta rodar o código e seguir as instruções na tela.