Faça um programa que calcula uma aproximação para a raiz de x^{3}+3 x=A(0 \leq A \leq 1000 ) pelo método do ponto fixo com:
\begin{gathered} \phi_{1}(x)=\frac{A-x^{3}}{3}, \text { se } A \leq 3 \\\ \phi_{2}(x)=\frac{A}{x^{2}+3}, \text { se } 3<A<5 \\\ \phi_{3}(x)=\sqrt[3]{A-3 x}, \text { se } A \geq 5 \end{gathered}
em todos os casos x_{0}=1, e parada \left|x^{3}+3 x-A\right|<10^{-6}.

Passo 1

O enunciado pede: fazer um programa que calcula uma aproximação para a raiz da equação
x^{3}+3x = A,\qquad 0 \leq A \leq 1000,
usando o método do ponto fixo com as iterações definidas por
\phi_{1}(x)=\frac{A-x^{3}}{3},\quad\text{se }A\leq 3,
\phi_{2}(x)=\frac{A}{x^{2}+3},\quad\text{se }3<A<5,
\phi_{3}(x)=\sqrt[3]{A-3x},\quad\text{se }A\geq 5,
sempre com x_{0}=1 e critério de parada
\left|x^{3}+3x-A\right|<10^{-6}.
Informações relevantes dadas:
  • A entrada do programa é o valor de A (no intervalo dado).
  • O método é iteração de ponto fixo com três funções \phi_i condicionadas por A.
  • A condição de parada é o valor absoluto do resíduo da equação original menor que 10^{-6}.
  • O chute inicial é x_{0}=1.
    O que o programa deve fornecer (saída desejada): uma aproximação da raiz (valor de x), o número de iterações usado e o resíduo final (opcionalmente).

Passo 2

Breve aula sobre o método do ponto fixo (bem mastigada).
  • Objetivo: resolver f(x)=0. Uma maneira é reescrever como x=\varphi(x). Se uma função \varphi tem ponto fixo x^{*} (ou seja \varphi(x^{*})=x^{*}), então x^{*} é solução de f(x)=0 se construirmos \varphi adequadamente.
  • Iteração: a sequência
x_{n+1}=\varphi(x_{n})
pode convergir para x^{*} se algumas condições forem satisfeitas.
  • Condição suficiente simples (contratividade local): se existir um intervalo I contendo x^{*} e uma constante k com 0\le k<1 tais que
\left|\varphi'(x)\right|\le k\quad\text{para todo }x\in I,
então \varphi é contração em I e a iteração converge a x^{*} para qualquer x_{0}\in I.
  • Na prática, não precisamos provar a condição rigorosamente no programa; usamos a iteração e um critério de parada. Mas é bom saber que verificar \varphi' ajuda a diagnosticar convergência ou divergência.

Passo 3

Derivadas das \varphi (úteis para entender comportamento e possíveis problemas):
  • Para \phi_{1}(x)=\dfrac{A-x^{3}}{3}:
\phi_{1}'(x) = -x^{2}.
Observação: |\phi_{1}'(x)|=x^{2}. Perto de x^{*} pequeno (por exemplo x em torno de 0 ou 1) isso pode ser menor que 1, o que ajuda a convergir; para x grande isso cresce.
  • Para \phi_{2}(x)=\dfrac{A}{x^{2}+3}:
\phi_{2}'(x) = A\cdot\frac{d}{dx}\left( (x^{2}+3)^{-1} \right) = A\cdot\left(-2x\right)(x^{2}+3)^{-2} = -\frac{2Ax}{(x^{2}+3)^{2}}.
Observação: \phi_{2}'(x) geralmente tem magnitude pequena se x não for muito grande e A moderado.
  • Para \phi_{3}(x)=\sqrt[3]{A-3x}=(A-3x)^{1/3}:
\phi_{3}'(x) = \frac{1}{3}(A-3x)^{-2/3}\cdot(-3) = -(A-3x)^{-2/3}.
Observação: se A-3x fica perto de zero, |\phi_{3}'(x)| pode ficar muito grande (problema). A função cúbica permite radiciação de números negativos (raiz cúbica real existe), mas a derivada pode explodir em pontos onde A-3x=0.
Essas observações servem para termos cuidado no programa (por exemplo, se a iteração não estiver convergindo, pode ser por |\varphi'| grande).

Passo 4

Escolha prática do algoritmo (fluxo do programa) — explicação passo a passo do que implementar:
  1. Ler entrada A (garantir 0\le A\le 1000).
  2. Definir x\leftarrow 1 (chute inicial).
  3. Selecionar a função \varphi correspondente:
    • se A\le 3 usar \phi_{1},
    • se 3< A <5 usar \phi_{2},
    • se A\ge 5 usar \phi_{3}.
  4. Iterar: em cada iteração calcular x_{\text{novo}}=\varphi(x). Atualizar x\leftarrow x_{\text{novo}}.
  5. Após cada iteração calcular o resíduo
r = \left|x^{3}+3x-A\right|.
Se r<10^{-6} parar e retornar x, número de iterações e r.
6. Colocar um limite máximo de iterações (por exemplo N_{\max}=10000) para evitar loop infinito; se atingir N_{\max} informar falha de convergência.
7. Para a raiz cúbica real (no caso de \phi_{3}) em linguagem de programação, usar uma função que retorne a raiz cúbica real também para argumentos negativos (por exemplo em Python usar uma função que preserve o sinal).

Passo 5

Detalhes numéricos e cuidados de implementação (truques práticos para prova/implementação):
  • Raiz cúbica real em computadores: usar uma função que calcule \operatorname{cbrt}(z) real. Em Python uma forma portátil é
    • \text{cbrt}(z)=\operatorname{copysign}(|z|^{1/3},z).
      Isso garante a raiz cúbica real para z<0.
  • Ordem das verificações: a condição de parada do enunciado usa o resíduo da equação original; portanto verificar r após calcular x_{\text{novo}} é correto.
  • Convergência lenta: ponto fixo pode convergir linearmente; pode demorar várias iterações para atingir 10^{-6}. Por isso um N_{\max} suficientemente grande (por ex. 10000) é adequado.
  • Detectar divergência: se |x| crescer muito (por ex. ultrapassar 10^{8}) abortar e informar que divergiu.
  • Formatação final: mostrar x com precisão razoável (por ex. 10 casas decimais) e o resíduo.
  • Testes rápidos: testar o programa com alguns A conhecidos. Por exemplo:
    • A=0 tem raiz x=0 (porque 0^{3}+3\cdot0=0).
    • valores pequenos A devem convergir com \phi_{1} ou \phi_{2}.

Passo 6

Código Python completo (implementação prática). O programa abaixo segue exatamente o enunciado: escolhe \varphi conforme A, usa x_{0}=1 e pára quando \left|x^{3}+3x-A\right|<10^{-6}. O código inclui cuidados com raiz cúbica real, limite de iterações e mensagens claras.
# Programa: ponto_fixo_raiz.py
# Resolve x^3 + 3x = A por iteração de ponto fixo com x0 = 1
# Critério de parada: |x^3 + 3x - A| < 1e-6

import math

def cbrt_real(z):
    """Raiz cúbica real de z (preserva sinal)."""
    return math.copysign(abs(z) ** (1.0 / 3.0), z)

def phi1(x, A):
    return (A - x**3) / 3.0

def phi2(x, A):
    return A / (x**2 + 3.0)

def phi3(x, A):
    return cbrt_real(A - 3.0 * x)

def fixed_point_root(A, tol=1e-6, max_iter=10000):
    # Verifica domínio de A
    if not (0.0 <= A <= 1000.0):
        raise ValueError("A deve satisfazer 0 <= A <= 1000")
    # Escolhe phi conforme enunciado
    if A <= 3.0:
        phi = lambda x: phi1(x, A)
    elif A < 5.0:
        phi = lambda x: phi2(x, A)
    else:
        phi = lambda x: phi3(x, A)
    x = 1.0  # x0
    for k in range(1, max_iter + 1):
        x_new = phi(x)
        # segurança contra estouro numérico
        if not math.isfinite(x_new):
            return None, k, float('inf')  # divergiu numericamente
        # calcular resíduo da equação original no novo ponto
        resid = abs(x_new**3 + 3.0 * x_new - A)
        # parada conforme enunciado
        if resid < tol:
            return x_new, k, resid
        # detectar divergência (valor absoluto muito grande)
        if abs(x_new) > 1e12:
            return None, k, float('inf')
        x = x_new
    # não convergiu dentro do máximo de iterações
    return None, max_iter, abs(x**3 + 3.0 * x - A)

if __name__ == "__main__":
    # exemplo de uso interativo simples
    try:
        A_str = input("Digite A (0 <= A <= 1000): ").strip()
        A = float(A_str)
    except Exception:
        print("Entrada inválida.")
        exit(1)
    root, iters, resid = fixed_point_root(A)
    if root is None:
        print(f"Não convergiu em {iters} iterações (resíduo aproximado {resid}).")
    else:
        print(f"Convergiu em {iters} iterações.")
        print(f"Raiz aproximada x = {root:.10f}")
        print(f"Resíduo |x^3 + 3x - A| = {resid:.3e}")

Passo 7

Como usar e interpretar resultados (dicas rápidas para a prova e para testar):
  • Executar o programa e fornecer um A. O programa retorna a aproximação da raiz, número de iterações e o resíduo.
  • Se o programa informar “Não convergiu”, tente:
    • aumentar o número máximo de iterações (parâmetro max_iter),
    • verificar qual \varphi foi escolhido (verificar a condição de seleção),
    • inspecionar se |\varphi'(x)| é grande perto do iterando (isso indica possível divergência).
  • Exemplos simples para testar mentalmente:
    • A=0 deveria convergir rapidamente para x\approx 0.
    • A=1 com \phi_{1} (pois A\le3) normalmente converge com chute x_{0}=1.

Resposta

# Programa: ponto_fixo_raiz.py
# Resolve x^3 + 3x = A por iteração de ponto fixo com x0 = 1
# Critério de parada: |x^3 + 3x - A| < 1e-6

import math

def cbrt_real(z):
    """Raiz cúbica real de z (preserva sinal)."""
    return math.copysign(abs(z) ** (1.0 / 3.0), z)

def phi1(x, A):
    return (A - x**3) / 3.0

def phi2(x, A):
    return A / (x**2 + 3.0)

def phi3(x, A):
    return cbrt_real(A - 3.0 * x)

def fixed_point_root(A, tol=1e-6, max_iter=10000):
    # Verifica domínio de A
    if not (0.0 <= A <= 1000.0):
        raise ValueError("A deve satisfazer 0 <= A <= 1000")
    # Escolhe phi conforme enunciado
    if A <= 3.0:
        phi = lambda x: phi1(x, A)
    elif A < 5.0:
        phi = lambda x: phi2(x, A)
    else:
        phi = lambda x: phi3(x, A)
    x = 1.0  # x0
    for k in range(1, max_iter + 1):
        x_new = phi(x)
        # segurança contra estouro numérico
        if not math.isfinite(x_new):
            return None, k, float('inf')  # divergiu numericamente
        # calcular resíduo da equação original no novo ponto
        resid = abs(x_new**3 + 3.0 * x_new - A)
        # parada conforme enunciado
        if resid < tol:
            return x_new, k, resid
        # detectar divergência (valor absoluto muito grande)
        if abs(x_new) > 1e12:
            return None, k, float('inf')
        x = x_new
    # não convergiu dentro do máximo de iterações
    return None, max_iter, abs(x**3 + 3.0 * x - A)

if __name__ == "__main__":
    # exemplo de uso interativo simples
    try:
        A_str = input("Digite A (0 <= A <= 1000): ").strip()
        A = float(A_str)
    except Exception:
        print("Entrada inválida.")
        exit(1)
    root, iters, resid = fixed_point_root(A)
    if root is None:
        print(f"Não convergiu em {iters} iterações (resíduo aproximado {resid}).")
    else:
        print(f"Convergiu em {iters} iterações.")
        print(f"Raiz aproximada x = {root:.10f}")
        print(f"Resíduo |x^3 + 3x - A| = {resid:.3e}")