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.
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:
Ler entrada A (garantir 0\le A\le 1000).
Definir x\leftarrow 1 (chute inicial).
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}.
Iterar: em cada iteração calcular x_{\text{novo}}=\varphi(x). Atualizar x\leftarrow x_{\text{novo}}.
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-6import math
defcbrt_real(z):
"""Raiz cúbica real de z (preserva sinal)."""return math.copysign(abs(z) ** (1.0 / 3.0), z)
defphi1(x, A):
return (A - x**3) / 3.0defphi2(x, A):
return A / (x**2 + 3.0)
defphi3(x, A):
return cbrt_real(A - 3.0 * x)
deffixed_point_root(A, tol=1e-6, max_iter=10000):
# Verifica domínio de Aifnot (0.0 <= A <= 1000.0):
raise ValueError("A deve satisfazer 0 <= A <= 1000")
# Escolhe phi conforme enunciadoif 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# x0for k inrange(1, max_iter + 1):
x_new = phi(x)
# segurança contra estouro numéricoifnot math.isfinite(x_new):
returnNone, 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 enunciadoif resid < tol:
return x_new, k, resid
# detectar divergência (valor absoluto muito grande)ifabs(x_new) > 1e12:
returnNone, k, float('inf')
x = x_new
# não convergiu dentro do máximo de iteraçõesreturnNone, max_iter, abs(x**3 + 3.0 * x - A)
if __name__ == "__main__":
# exemplo de uso interativo simplestry:
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 isNone:
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-6import math
defcbrt_real(z):
"""Raiz cúbica real de z (preserva sinal)."""return math.copysign(abs(z) ** (1.0 / 3.0), z)
defphi1(x, A):
return (A - x**3) / 3.0defphi2(x, A):
return A / (x**2 + 3.0)
defphi3(x, A):
return cbrt_real(A - 3.0 * x)
deffixed_point_root(A, tol=1e-6, max_iter=10000):
# Verifica domínio de Aifnot (0.0 <= A <= 1000.0):
raise ValueError("A deve satisfazer 0 <= A <= 1000")
# Escolhe phi conforme enunciadoif 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# x0for k inrange(1, max_iter + 1):
x_new = phi(x)
# segurança contra estouro numéricoifnot math.isfinite(x_new):
returnNone, 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 enunciadoif resid < tol:
return x_new, k, resid
# detectar divergência (valor absoluto muito grande)ifabs(x_new) > 1e12:
returnNone, k, float('inf')
x = x_new
# não convergiu dentro do máximo de iteraçõesreturnNone, max_iter, abs(x**3 + 3.0 * x - A)
if __name__ == "__main__":
# exemplo de uso interativo simplestry:
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 isNone:
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}")