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:
  1. Definir a função cuja raiz a gente quer achar.
  2. Ter um intervalo inicial tal que e tenham sinais opostos (isso garante que exista pelo menos uma raiz no intervalo, pois ).
  3. Uma tolerância para parar o processo quando o intervalo ficar pequeno o suficiente.
  4. (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 c = a + b2 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):
  1. Recebe , , , tol, max_iter.
  2. Verifica se . Se não, dá erro (intervalo inválido).
  3. Para até max_iter:
    3.1. Calcula .
    3.2. Se , para e devolve .
    3.3. Se , define ; senão, define .
  4. 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.")

Exercícios relacionados