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
com coeficientes:
e o vetor de termos independentes
O algoritmo faz:
. Eliminação para frente (i de
até
):
para
:
Passo 3
Vamos planejar uma interface simples em Python:
- Ler inteiro
(tamanho do sistema). - Ler as listas
(tamanho ), (tamanho ), (tamanho ) e (tamanho ), todas com números reais. - Validar que
durante a eliminação. - Aplicar Thomas e exibir o vetor solução
.
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 é
.