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:
2x + 3y = 8 5x + 4y = 13

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.
def decomposicao_LU(A):
    n = A.shape[0]
    L = np.zeros_like(A)
    U = np.zeros_like(A)

    for i in range(n):
        # Calculando os elementos de U
        for k in range(i, n):
            U[i, k] = A[i, k] - sum(L[i, j] * U[j, k] for j in range(i))
        
        # Calculando os elementos de L
        for k in range(i, n):
            if i == k:
                L[i, i] = 1
            else:
                L[k, i] = (A[k, i] - sum(L[k, j] * U[j, i] for j in range(i))) / U[i, i]
    return L, U

Passo 7

Agora, vamos criar uma função para resolver Ly = b usando substituição direta:
def substituicao_direta(L, b):
    n = L.shape[0]
    y = np.zeros_like(b, dtype=np.double)
    for i in range(n):
        y[i] = b[i] - sum(L[i, j] * y[j] for j in range(i))
    return y

Passo 8

E outra função para resolver Ux = y usando substituição retroativa:
def substituicao_retrospectiva(U, y):
    n = U.shape[0]
    x = np.zeros_like(y, dtype=np.double)
    for i in reversed(range(n)):
        x[i] = (y[i] - sum(U[i, j] * x[j] for j in range(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:
def resolver_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:
def matriz_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 in range(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:
def main():
    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 _ in range(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.

Exercícios relacionados