Considere a equação
, com
, e
-
. Faça um programa que calcula x pelo método do ponto fixo com
, parada
, no máximo 100 iterações.
Passo 1
O que o problema pede e quais informações foram dadas.
- O enunciado quer um programa que resolva a equação
usando o método do ponto fixo com iteração onde foi dada a função de iteração . - Condições iniciais e de parada fornecidas:
-
. - Critério de parada:
, onde aqui . - Número máximo de iterações: 100.
-
- Informação sobre os parâmetros:
. Isso é importante para a convergência (veremos como).
Resumo das perguntas implícitas que o programa deve responder:
- Implementar a iteração
começando em . - Parar quando
ou quando atingir 100 iterações. - Retornar/mostrar a solução aproximada
(e idealmente o número de iterações).
Passo 2
Definições e relações que vamos usar (explicando cada símbolo).
- Definimos a função cuja raiz procuramos:
Aqui e são constantes dadas, é a variável. - A função de iteração é
O método do ponto fixo busca um ponto tal que . Sempre que valer, então substituindo temos , ou seja, a raiz de . - Iteração prática: a sequência é definida por
com .
Passo 3
Por que essa escolha de
converge — teste da derivada (intuição prática).
- Derivada de
: (Explicando: derivada de é .) - Como
para todo , obtemos Como foi dado , então . Portanto existe uma constante tal que para todo . - Conclusão prática:
é uma contração global (Lipschitz com constante menor que 1). Pelo Teorema do Ponto Fixo de Banach, isso garante existência e unicidade do ponto fixo e convergência da iteração para para qualquer (portanto para ). Em termos práticos: a iteração irá convergir e de forma estável porque a derivada em módulo é menor que 1.
Passo 4
Critério de parada e como implementá-lo exatamente.
- O enunciado pede parar quando
. Aqui vamos avaliar sempre na nova aproximação (padrão usual: atualizar e testar o resíduo ). - Portanto o loop será:
- Dado
, calcule . - Calcule
. - Se
, pare e aceite como solução. - Caso contrário, prossiga até no máximo 100 iterações.
- Dado
- Observação prática: pode-se também checar a diferença
como critério alternativo, mas vamos seguir estritamente o pedido e usar .
Passo 5
Detalhes numéricos e cuidados de implementação (para a prova e para o programa).
- Use aritmética de ponto-flutuante (double precision é suficiente). Em Python, os floats já são double precision.
- A função trigonométrica
usa radianos; garantir que nenhum ângulo seja confundido com graus. - Verificar antes de começar se os parâmetros respeitam
. Se não respeitarem, o argumento de convergência que usamos fica inválido; o programa pode emitir uma mensagem de aviso ou continuar com cautela. - Garantir que a divisão por
não divida por zero (mas já evita ). - Limitar o número de iterações a 100 e retornar a aproximação final mesmo que não tenha sido atingido o critério (mas informar que não convergiu dentro do limite).
Passo 6
Exemplo rápido da primeira iteração (para fixar a ideia).
- Começando com
: Isso dá uma ideia imediata de onde a sequência inicia. - Em seguida calcula-se
e testa-se . Se não, continua-se com e assim por diante.
Passo 7
Pseudocódigo (passo a passo) — escrevendo para facilitar a implementação exata:
- Ler
e (valores reais). - Verificar se
; se não, avisar (mas ainda permitir a execução se desejar). - Inicializar
. - Para
até : -
. -
. - Se
, então terminar e devolver e . - Caso contrário,
e continuar.
-
- Se completar 100 iterações sem atender o critério, devolver a última
e indicar que o limite foi atingido.
Passo 8
Observações finais de estilo (para prova e para rodar o programa).
- Mostrar resultado com precisão adequada (por exemplo, imprimir com 12 casas decimais) para ter uma leitura clara.
- Indicar o número de iterações e se a convergência foi alcançada ou não.
- Em linguagem de programação: usar biblioteca matemática para
(em Python, módulo math). - Lembrete motivacional: com
a técnica é robusta — confie no processo e confira sempre o resíduo .
Resposta
#!/usr/bin/env python3
import math
import sys
def fixed_point(A, B, tol=1e-6, max_iter=100):
if A == 0:
raise ValueError("A must be nonzero.")
x = 0.0 # x0 = 0
for k in range(1, max_iter + 1):
x_new = - (B / A) * math.cos(x)
f = A * x_new + B * math.cos(x_new)
if abs(f) < tol:
return x_new, k, True
x = x_new
return x, max_iter, False
def main():
# Ler A e B do usuário (duas entradas separadas por espaço ou em linhas diferentes)
try:
dados = input("Digite A e B separados por espaço: ").strip().split()
if len(dados) < 2:
print("Entrada inválida. Forneça A e B.")
return
A = float(dados[0])
B = float(dados[1])
except Exception as e:
print("Erro na leitura dos valores:", e)
return
if not (abs(B) > 0 and A > abs(B)):
print("Aviso: pré-condição A > |B| > 0 não satisfeita. O método pode não convergir.")
try:
x, iters, convergiu = fixed_point(A, B)
except ValueError as e:
print("Erro:", e)
return
if convergiu:
print(f"Convergiu em {iters} iterações.")
else:
print(f"Não convergiu dentro de {iters} iterações (retornando última aproximação).")
print(f"x = {x:.12f}")
# opcional: mostrar o resíduo final
residuo = A * x + B * math.cos(x)
print(f"|f(x)| = {abs(residuo):.3e}")
if __name__ == "__main__":
main()