Considere a equação
. Faça um programa que encontra a raiz da equação (em w) pelo método da bisseção, com
, se
, e
, se
.
Passo 1
O que o problema pede e quais informações temos.
- Pedem um programa que encontre a raiz em
da equação
para um dado
, usando o método da bisseção.
- A escolha do intervalo inicial depende de
: - se
, usar ; - se
, usar .
- se
- O programa deve iterar aplicando a bisseção até obter uma aproximação da raiz com precisão numérica (critério de parada).
- Não há outros detalhes obrigatórios no enunciado (por exemplo, tolerância ou número máximo de iterações), então o programa deve incluir uma tolerância razoável e proteção por máximo de iterações.
Passo 2
Por que existe uma única raiz em
para cada
(intuição usada para a bisseção).
- Defina
. Queremos resolver . - Observe a derivada:
- Para
tem-se e , portanto em . Ou seja, é estritamente crescente em . - Conclusão: para cada
existe no máximo uma raiz . Como e , existe exatamente uma raiz em para todo . Isso garante que o método da bisseção funcione desde que escolhamos um intervalo que contenha a raiz.
Passo 3
Justificando os intervalos iniciais pedidos no enunciado.
- Para
: -
e . - Se
então , logo a raiz está no intervalo .
-
- Para
: -
. - Tome
. Então
- Como
implica , tem-se , logo . - Portanto
e a raiz está no intervalo .
-
Passo 4
Explicação didática do método da bisseção (como aplicá-lo passo a passo).
- Seja
. Queremos . - Bisseção funciona quando se tem um intervalo
com (sinal oposto ou zero). - Iteração (um passo da bisseção):
- Calcule o ponto médio
. - Calcule
. - Se
, então a raiz está em ; ponha .
Caso contrário (então), a raiz está em ; ponha .
- Calcule o ponto médio
- Critérios de parada típicos:
- Quando o comprimento do intervalo
fica menor que uma tolerância : . - Ou quando
. - Sempre colocar um número máximo de iterações
para segurança.
- Quando o comprimento do intervalo
- Complexidade e convergência:
- O método da bisseção reduz o comprimento do intervalo pela metade a cada iteração. Após
iterações o comprimento é . Para atingir precisão de intervalo é preciso
- O método da bisseção reduz o comprimento do intervalo pela metade a cada iteração. Após
Passo 5
Pseudocódigo detalhado (para transformar facilmente em programa).
- Entrada:
, tolerância (por ex. ), (por ex. ). - Se
retornar (porque ). - Escolher
conforme: - se
: , ; - se
: , .
- se
- Verificar que
e (deverá ocorrer pelas justificativas anteriores). - Repetir até parada ou até
: -
. -
. - Se
ou então retornar . - Se
então senão .
-
- Se atingir
retornar com um aviso (no programa, por exemplo, pode lançar exceção ou retornar a melhor aproximação).
Passo 6
Cuidados numéricos e dicas para a prova (como justificar e o que checar rapidamente).
- Checar o caso
explicitamente (resposta exata ). - Não usar a transformação para a função inversa direta (Lambert W) na prova se o enunciado exige usar bisseção; porém é bom saber que a solução é
(função W de Lambert) — apenas referência, não usada aqui. - Escolher
compatível com precisão desejada; é um bom valor para dupla precisão. - Sempre verificar que os sinais em
e são opostos antes de iniciar (sanity check). - Em prova oral/escrita: explique monotonicidade de
(derivada positiva) e justifique os extremos do intervalo como feito nos passos anteriores.
Passo 7
Exemplo numérico rápido (passo a passo) para
(ilustrativo).
- Como
, escolhemos . -
(negativo), (positivo), ok. - Iteração 1:
. Calcule . Sabendo temos (negativo) → nova direita . - Iteração 2:
. (negativo) → nova direita . - Observação: aqui
ficou mais negativo porque a função cresce inicialmente devagar; continuaríamos a bissetar até convergir. (No programa, todos esses cálculos são feitos com precisão da máquina.)
Passo 8
Resumo final do que entregar: o programa deve
- receber
; - montar o intervalo inicial conforme o enunciado;
- aplicar bisseção com critério de parada e máximo de iterações;
- devolver a aproximação de
tal que .
Resposta
# Programa em Python: encontra w tal que w*exp(w) = x usando bisseção
# Usa os intervalos [0,1] se x <= e, e [1, ln x] se x > e.
# Retorna uma aproximação da raiz w.
import math
def bissecao_weq_x(x, tol=1e-12, max_iter=1000):
"""
Resolve w*exp(w) = x por bisseção para x >= 0.
Retorna (w, n_iter) onde w é a aproximação da raiz e n_iter é o número de iterações usadas.
"""
if x < 0:
raise ValueError("x deve ser >= 0")
# caso exato
if x == 0:
return 0.0, 0
# função f(w) = w*exp(w) - x
def f(w):
return w * math.exp(w) - x
# escolha do intervalo inicial
e = math.e
if x <= e:
a, b = 0.0, 1.0
else:
a, b = 1.0, math.log(x)
fa = f(a)
fb = f(b)
# sanity check: garantir que há raiz no intervalo
if fa > 0 or fb < 0:
raise RuntimeError("Intervalo inicial não contém mudança de sinal: f(a)={}, f(b)={}".format(fa, fb))
m = None
for n in range(1, max_iter+1):
m = 0.5 * (a + b)
fm = f(m)
# critério de parada: valor da função muito pequeno ou intervalo pequeno
if abs(fm) <= tol or (b - a) / 2.0 < tol:
return m, n
# decidir o subintervalo que contém a raiz
if fa * fm <= 0:
b = m
fb = fm
else:
a = m
fa = fm
# se chegou aqui, máximo de iterações atingido
return m, max_iter
# Exemplo de uso:
if __name__ == "__main__":
# testar alguns valores de x
testes = [0.0, 1.0, math.e, 10.0, 100.0]
for x in testes:
w, it = bissecao_weq_x(x)
print("x = {:g} -> w ≈ {:.15g} ({} iterações); w*exp(w) = {:.15g}".format(
x, w, it, w * math.exp(w)))