Usando o Python, implemente os métodos de Newton e Bissecção para determinar zeros de funções:
OBSERVAÇÕES :
I) Para cada método a função pode ser definida no próprio código;
II) No método de Newton, a derivada deverá ser obtida pelo próprio código usando a função diff da biblioteca Simpy
III) Entradas:
Bissecção: a e b (extremos do intervalo e precisão
Newton: valor inicial e precisão
Saídas : valor aproximado da raiz ou mensagem dizendo que não existe;
Gráfico da função e o ponto de coordenadas (raiz, 0)

Passo 1

Beleza, o exercício pede pra gente criar em Python duas funções que acham raízes de uma função qualquer: o método da Bissecção e o de Newton. A gente vai usar a biblioteca Sympy pra derivada automática no Newton, matplotlib pra fazer o gráfico e numpy ou definições em Python puro pra avaliar a função. O que precisamos:
  • Entender o critério da Bissecção (quando f(a),f(b)<0 tem raiz no intervalo).
  • Saber a fórmula do Newton: xn+1=xn-f(xn)f'(xn)
    - Montar loops que param quando a precisão for alcançada (por exemplo, |b-a| ou |f(xn)|).

Passo 2

Método da Bissecção – teoria e código
  1. Teoria: Se f(a),f(b)<0, existe ao menos uma raiz em [a,b]. A cada iteração a gente pega
c=a+b2
e vê o sinal de f(c). Se f(a),f(c)<0, então a raiz está em [a,c], senão em [c,b]. Para parar, basta ter (b-a)/2.
2) Trechinho de código informal em Python:
```python
import numpy as np
import matplotlib.pyplot as plt
def bisseccao(f, a, b, tol):
if f(a)*f(b) > 0:
return “Não há garantia de raiz no intervalo”
while (b - a)/2 > tol:
c = (a + b)/2
if f© == 0:
return c
if f(a)*f© < 0:
b = c
else:
a = c
return (a + b)/2

Passo 3

Método de Newton – teoria e código
  1. Teoria: Newton usa a derivada pra “puxar” o chute xn até a raiz. A fórmula é
xn+1 = xn - f(xn)f'(xn)
A gente precisa da função diff do Sympy para gerar f'. Para parar, verifica se |f(xn)| ou se a mudança |xn+1-xn|.
2) Código:
```python
import sympy as sp
def newton(f_expr, x0, tol, max_iter=50):
x = sp.symbols(‘x’)
f = sp.lambdify(x, f_expr, ‘numpy’)
fprime = sp.lambdify(x, sp.diff(f_expr, x), ‘numpy’)
xn = x0
for i in range(max_iter):
fx = f(xn)
fpx = fprime(xn)
if abs(fpx) < 1e-12:
return “Derivada muito pequena – pode não convergir”
xn1 = xn - fx/fpx
if abs(xn1 - xn) < tol:
return xn1
xn = xn1
return “Não convergiu em {} iterações”.format(max_iter)

Passo 4

Gerando o gráfico
Depois de achar a raiz r, a gente faz um gráfico simples:
xs = np.linspace(a, b, 400)
ys = f(xs)
plt.plot(xs, ys, label='f(x)')
plt.axhline(0, color='black')
plt.scatter([r], [0], color='red', label=f'raiz ≈ {r:.5f}')
plt.legend()
plt.show()

Resposta

Aqui está um template completo em Python que implementa o método da Bissecção e o de Newton, verifica condições iniciais, pára na precisão desejada e plota a função com o ponto da raiz. É só definir a sua função f(x) (no Newton como f_expr do Sympy) e chamar bisseccao(f, a, b, tol) ou newton(f_expr, x0, tol). Pronto, agora é só testar com qualquer função!

Exercícios relacionados