Considere a equação w e^{w}=x .(x \geqslant 0). Faça um programa que encontra a raiz da equação (em w) pelo método da bisseção, com \left[a_{0}, b_{0}\right]=[0,1], se x \leq e, e [1, \ln x], se x>e.

Passo 1

O que o problema pede e quais informações temos.
  • Pedem um programa que encontre a raiz em w da equação
w e^{w} = x,
para um dado x\geqslant 0, usando o método da bisseção.
  • A escolha do intervalo inicial depende de x:
    • se x \leqslant e, usar [a_0,b_0]=[0,1];
    • se x > e, usar [a_0,b_0]=[1,\ln x].
  • 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 w para cada x\geqslant0 (intuição usada para a bisseção).
  • Defina g(w)=w e^{w}. Queremos resolver g(w)-x=0.
  • Observe a derivada:
g'(w)=\frac{d}{dw}\big(w e^{w}\big)=e^{w}(w+1).
  • Para w\geqslant 0 tem-se w+1>0 e e^{w}>0, portanto g'(w)>0 em [0,\infty). Ou seja, g é estritamente crescente em [0,\infty).
  • Conclusão: para cada x\geqslant 0 existe no máximo uma raiz w\geqslant0. Como g(0)=0 e \lim_{w\to\infty}g(w)=\infty, existe exatamente uma raiz em [0,\infty) para todo x\geqslant0. 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 x\leqslant e:
    • g(0)=0 e g(1)=1\cdot e^{1}=e.
    • Se 0\leqslant x\leqslant e então g(0)\leqslant x\leqslant g(1), logo a raiz está no intervalo [0,1].
  • Para x>e:
    • g(1)=e<x.
    • Tome b_0=\ln x. Então
    g(\ln x) = (\ln x)\,e^{\ln x} = (\ln x)\,x.
    • Como x>e implica \ln x>1, tem-se (\ln x)\,x > 1\cdot x = x, logo g(\ln x)>x.
    • Portanto g(1)<x<g(\ln x) e a raiz está no intervalo [1,\ln x].

Passo 4

Explicação didática do método da bisseção (como aplicá-lo passo a passo).
  • Seja f(w)=g(w)-x = w e^{w} - x. Queremos f(w)=0.
  • Bisseção funciona quando se tem um intervalo [a,b] com f(a)\cdot f(b)\leqslant 0 (sinal oposto ou zero).
  • Iteração (um passo da bisseção):
    1. Calcule o ponto médio m=\dfrac{a+b}{2}.
    2. Calcule f(m).
    3. Se f(a)\cdot f(m)\leqslant 0, então a raiz está em [a,m]; ponha b\leftarrow m.
      Caso contrário (então f(m)\cdot f(b)\leqslant 0), a raiz está em [m,b]; ponha a\leftarrow m.
  • Critérios de parada típicos:
    • Quando o comprimento do intervalo [a,b] fica menor que uma tolerância \text{tol}: \,b-a<\text{tol}.
    • Ou quando |f(m)|<\text{tol\_f}.
    • Sempre colocar um número máximo de iterações \text{max\_iter} para segurança.
  • Complexidade e convergência:
    • O método da bisseção reduz o comprimento do intervalo pela metade a cada iteração. Após n iterações o comprimento é (b_0-a_0)/2^{n}. Para atingir precisão de intervalo \text{tol} é preciso
    n \ge \log_{2}\!\left(\frac{b_0-a_0}{\text{tol}}\right).

Passo 5

Pseudocódigo detalhado (para transformar facilmente em programa).
  • Entrada: x\geqslant 0, tolerância \text{tol} (por ex. 10^{-12}), \text{max\_iter} (por ex. 1000).
  • Se x=0 retornar w=0 (porque 0\cdot e^{0}=0).
  • Escolher [a,b] conforme:
    • se x\leqslant e: a\leftarrow 0, b\leftarrow 1;
    • se x>e: a\leftarrow 1, b\leftarrow \ln x.
  • Verificar que f(a)\leqslant 0 e f(b)\geqslant 0 (deverá ocorrer pelas justificativas anteriores).
  • Repetir até parada ou até \text{max\_iter}:
    • m \leftarrow (a+b)/2.
    • fm \leftarrow m\cdot e^{m} - x.
    • Se |fm|<\text{tol} ou (b-a)/2 < \text{tol} então retornar m.
    • Se f(a)\cdot fm \leqslant 0 então b\leftarrow m senão a\leftarrow m.
  • Se atingir \text{max\_iter} retornar m 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 x=0 explicitamente (resposta exata w=0).
  • 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 é w=W(x) (função W de Lambert) — apenas referência, não usada aqui.
  • Escolher \text{tol} compatível com precisão desejada; \text{tol}=10^{-12} é um bom valor para dupla precisão.
  • Sempre verificar que os sinais em a e b são opostos antes de iniciar (sanity check).
  • Em prova oral/escrita: explique monotonicidade de g (derivada positiva) e justifique os extremos do intervalo como feito nos passos anteriores.

Passo 7

Exemplo numérico rápido (passo a passo) para x=1 (ilustrativo).
  • Como 1\leqslant e, escolhemos [a,b]=[0,1].
  • f(0)=0\cdot e^{0}-1=-1 (negativo), f(1)=e-1 (positivo), ok.
  • Iteração 1: m=0{,}5. Calcule f(0{,}5)=0{,}5 e^{0{,}5}-1. Sabendo e^{0{,}5}\approx1{,}6487 temos f(0{,}5)\approx0{,}82435-1=-0{,}17565 (negativo) → nova direita b=0{,}5.
  • Iteração 2: m=0{,}25. f(0{,}25)=0{,}25 e^{0{,}25}-1\approx0{,}25\cdot1{,}2840-1\approx0{,}3210-1=-0{,}6790 (negativo) → nova direita b=0{,}25.
  • Observação: aqui f(0{,}25) ficou mais negativo porque a função g(w) 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 x\geqslant 0;
  • 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 w tal que w e^{w}\approx x.

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)))

Exercícios relacionados