Desenvolva um programa amigável ao usuário para solução de sistemas algébricos lineares que utilizem: Algoritmo de Thomas. Teste o programa em um dos exemplos de aplicação.

Passo 1

O enunciado pede que a gente crie um programa interativo (amigável ao usuário) para resolver sistemas lineares tridiagonais usando o Algoritmo de Thomas. O conteúdo envolve representar as três diagonais (subdiagonal, diagonal principal e superdiagonal) e o vetor de termos independentes, aplicar a eliminação para obter um sistema triangular superior ``especial'' e depois fazer a retro‐substituição.

Passo 2

Vamos revisar o Algoritmo de Thomas. Seja um sistema de dimensão n com coeficientes:
a1,dots,an-1(subdiagonal),
b0,dots,bn-1(diagonal principal),
c0,dots,cn-2(superdiagonal),
e o vetor de termos independentes
d0,dots,dn-1
O algoritmo faz:
1. Eliminação para frente (i de 1 até n-1):
mi = aibi-1,
bi >=ts bi - mi,ci-1,
di >=ts di - mi,di-1
2. Retro‐substituição:
xn-1 = dn-1bn-1,
para i=n-2,n-3,dots,0:
xi = di - ci,xi+1bi

Passo 3

Vamos planejar uma interface simples em Python:
  • Ler inteiro n (tamanho do sistema).
  • Ler as listas a (tamanho n-1), b (tamanho n), c (tamanho n-1) e d (tamanho n), todas com números reais.
  • Validar que bineq0 durante a eliminação.
  • Aplicar Thomas e exibir o vetor solução x.

Passo 4

Pseudocódigo em alto nível:
leia n
leia lista a[\(1\)..n-\(1\)]
leia lista b[\(0\)..n-\(1\)]
leia lista c[\(0\)..n-\(2\)]
leia lista d[\(0\)..n-\(1\)]

# eliminação para frente
para i de \(1\) até n-\(1\) faça
    m \(=\) a[i] / b[i-\(1\)]
    b[i] \(=\) b[i] - m*c[i-\(1\)]
    d[i] \(=\) d[i] - m*d[i-\(1\)]
fim para

# retro\text{‐}substituição
x[n-\(1\)] \(=\) d[n-\(1\)] / b[n-\(1\)]
para i de n-\(2\) até \(0\) passo -\(1\) faça
    x[i] \(=\) (d[i] - c[i]*x[i\(+1\)]) / b[i]
fim para

imprima x

Passo 5

Implementação em Python:
def thomas(a, b, c, d):
    n \(=\) len(b)
    # eliminação para frente
    for i in range(\(1\), n):
        if b[i-\(1\)] \(==0\):
            raise ZeroDivisionError("Pivot zero em b[{}]".format(i-\(1\)))
        m \(=\) a[i-\(1\)] / b[i-\(1\)]
        b[i] -\(=\) m * c[i-\(1\)]
        d[i] -\(=\) m * d[i-\(1\)]
    # retro\text{‐}substituição
    x \(=\) [\(0.0\)]*n
    x[-\(1\)] \(=\) d[-\(1\)] / b[-\(1\)]
    for i in range(n-\(2\), -\(1\), -\(1\)):
        x[i] \(=\) (d[i] - c[i]*x[i\(+1\)]) / b[i]
    return x

def main():
    print("Solver tridiagonal (Thomas)")
    n \(=\) int(input("Número de equações (n): "))
    print("Entre os coeficientes a (subdiagonal), b (diagonal) e c (superdiagonal):")
    a \(=\) [float(input(f"a[{i}]: ")) for i in range(\(1\), n)]
    b \(=\) [float(input(f"b[{i}]: ")) for i in range(n)]
    c \(=\) [float(input(f"c[{i}]: ")) for i in range(n-\(1\))]
    print("Entre os termos independentes d:")
    d \(=\) [float(input(f"d[{i}]: ")) for i in range(n)]
    try:
        x \(=\) thomas(a, b, c, d)
        print("Solução x:")
        for i, xi in enumerate(x):
            print(f"x[{i}] \(=\) {xi:.\(6\)f}")
    except ZeroDivisionError as e:
        print("Erro:", e)

if __name__ \(==\) "__main__":
    main()

Passo 6

Teste do programa num exemplo clássico:
Sistema de
Aqui:
Executando:
Número de equações (n): \(4\]
a[\(1\)]: -\(1\)
a[\(2\)]: -\(1\)
a[\(3\)]: -\(1\)
b[\(0\)]: \(2\)
b[\(1\)]: \(2\)
b[\(2\)]: \(2\)
b[\(3\)]: \(2\)
c[\(0\)]: -\(1\)
c[\(1\)]: -\(1\)
c[\(2\)]: -\(1\)
d[\(0\)]: \(1\)
d[\(1\)]: \(0\)
d[\(2\)]: \(0\)
d[\(3\)]: \(1\)
Saída:
Solução x:
x[\(0\)] \(=1.000000\)
x[\(1\)] \(=1.000000\)
x[\(2\)] \(=1.000000\)
x[\(3\)] \(=1.000000\)

Resposta

O programa acima implementa o Algoritmo de Thomas de forma interativa. No exemplo testado, a solução do sistema é [1,1,1,1].

Exercícios relacionados