Faça um código para resolver uma equação pelo método da Bisseção.
Passo 1
Beleza, o que queremos aqui é criar um programa (vamos usar Python) que encontre uma raiz de qualquer função
usando o método da bisseção. Isso faz parte dos Métodos Numéricos, mais precisamente de Técnicas de Busca de Raízes.
O que precisamos:
O que precisamos:
- Definir a função
cuja raiz a gente quer achar. - Ter um intervalo inicial
tal que e tenham sinais opostos (isso garante que exista pelo menos uma raiz no intervalo, pois ). - Uma tolerância
para parar o processo quando o intervalo ficar pequeno o suficiente. - (Opcional) Um número máximo de iterações para não ficar preso num loop infinito.
Passo 2
Vamos entender a teoria do método da bisseção:
- A cada iteração, calculamos o ponto médio
do intervalo via - Então avaliamos
. - Se
, a raiz está em ; então jogamos fora o lado direito, definindo .
Caso contrário, a raiz fica em, e aí fazemos . - Repetimos até que o tamanho do intervalo
seja menor que a tolerância (ou cheguemos ao limite de iterações).
Passo 3
Vamos montar o passo a passo em forma de pseudocódigo (para fixar antes de codar):
- Recebe
, , , tol, max_iter. - Verifica se
. Se não, dá erro (intervalo inválido). - Para
até max_iter:
3.1. Calcula.
3.2. Se, para e devolve .
3.3. Se , define ; senão, define . - Se estourar as iterações, devolve o melhor
encontrado.
Passo 4
Agora vamos ao código Python, bem simples e comentado. Em qualquer parte que tenha fórmula, usei LaTeX nos comentários:
Resposta
def bissecao(f, a, b, tol=1e-6, max_iter=100):
"""
Método da Bisseção para encontrar raiz de f em [a, b].
Requer que f(a)*f(b) < 0.
Parâmetros:
f : função cujo zero queremos achar
a, b : limites iniciais do intervalo
tol : tolerância para |b - a|
max_iter : número máximo de iterações
Retorna:
(c, k) onde c é a aproximação da raiz e k é a iteração final
"""
fa = f(a)
fb = f(b)
if fa * fb > 0:
raise ValueError("f(a) e f(b) devem ter sinais opostos.")
for k in range(1, max_iter+1):
# calcula o ponto médio: c = (a + b)/2 ou c = \\frac{a+b}{2}
c = (a + b) / 2.0
fc = f(c)
# critério de parada: |b - a| < tol
if abs(b - a) < tol:
return c, k
# decide em qual subintervalo está a raiz
if fa * fc < 0:
b, fb = c, fc
else:
a, fa = c, fc
# se bater no máximo de iterações, devolve melhor c
return c, k
# Exemplo de uso:
if __name__ == "__main__":
# Exemplo: f(x) = x^2 - 2, raiz em sqrt(2) ~ 1.4142
import math
def f(x):
return x**2 - 2
raiz, iters = bissecao(f, 0, 2, tol=1e-8, max_iter=100)
print(f"Raiz aproximada: {raiz:.8f} em {iters} iterações.")