Considere a equação A x+B \cos (x)=0, com A>|B|>0, e \varphi(x)= - \frac{B}{A} \cos (x). Faça um programa que calcula x pelo método do ponto fixo com x_{0}=0, parada |f(x)| < 10^{-6}, 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 A x + B \cos(x) = 0 usando o método do ponto fixo com iteração x_{n+1} = \varphi(x_n),onde foi dada a função de iteração \varphi(x) = -\dfrac{B}{A}\cos(x).
  • Condições iniciais e de parada fornecidas:
    • x_0 = 0.
    • Critério de parada: |f(x)| < 10^{-6}, onde aqui f(x) = A x + B \cos(x).
    • Número máximo de iterações: 100.
  • Informação sobre os parâmetros: A > |B| > 0. Isso é importante para a convergência (veremos como).
Resumo das perguntas implícitas que o programa deve responder:
  • Implementar a iteração x_{n+1} = -\dfrac{B}{A}\cos(x_n) começando em x_0=0.
  • Parar quando |A x + B \cos(x)| < 10^{-6} ou quando atingir 100 iterações.
  • Retornar/mostrar a solução aproximada x (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: f(x) = A x + B \cos(x).Aqui A e B são constantes dadas, x é a variável.
  • A função de iteração é \varphi(x) = -\frac{B}{A}\cos(x).O método do ponto fixo busca um ponto x^* tal que x^* = \varphi(x^*). Sempre que x^*=\varphi(x^*) valer, então substituindo temos A x^* + B \cos(x^*) = 0, ou seja, a raiz de f.
  • Iteração prática: a sequência é definida por x_{n+1} = \varphi(x_n) = -\frac{B}{A}\cos(x_n),com x_0=0.

Passo 3

Por que essa escolha de \varphi converge — teste da derivada (intuição prática).
  • Derivada de \varphi: \varphi'(x) = \frac{B}{A}\sin(x).(Explicando: derivada de -\frac{B}{A}\cos(x) é -\frac{B}{A}(-\sin x)=\frac{B}{A}\sin x.)
  • Como |\sin(x)| \le 1 para todo x, obtemos |\varphi'(x)| \le \frac{|B|}{A}.Como foi dado A > |B|, então \dfrac{|B|}{A} < 1. Portanto existe uma constante L = \dfrac{|B|}{A} < 1 tal que |\varphi'(x)| \le L < 1 para todo x.
  • Conclusão prática: \varphi é 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 x^* e convergência da iteração x_{n+1}=\varphi(x_n) para x^* para qualquer x_0 (portanto para x_0=0). 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 |f(x)| < 10^{-6}. Aqui vamos avaliar f sempre na nova aproximação x_{n+1} (padrão usual: atualizar x e testar o resíduo |f(x)|).
  • Portanto o loop será:
    1. Dado x_n, calcule x_{n+1} = -\dfrac{B}{A}\cos(x_n).
    2. Calcule f(x_{n+1}) = A x_{n+1} + B \cos(x_{n+1}).
    3. Se |f(x_{n+1})| < 10^{-6}, pare e aceite x_{n+1} como solução.
    4. Caso contrário, prossiga até no máximo 100 iterações.
  • Observação prática: pode-se também checar a diferença |x_{n+1}-x_n| como critério alternativo, mas vamos seguir estritamente o pedido e usar |f(x)|.

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 \cos usa radianos; garantir que nenhum ângulo seja confundido com graus.
  • Verificar antes de começar se os parâmetros respeitam A > |B| > 0. 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 A não divida por zero (mas A>|B|>0 já evita A=0).
  • 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 x_0 = 0: x_1 = -\frac{B}{A}\cos(0) = -\frac{B}{A}\cdot 1 = -\frac{B}{A}.Isso dá uma ideia imediata de onde a sequência inicia.
  • Em seguida calcula-se f(x_1) = A x_1 + B \cos(x_1) e testa-se |f(x_1)| < 10^{-6}. Se não, continua-se com x_2 = -\dfrac{B}{A}\cos(x_1) e assim por diante.

Passo 7

Pseudocódigo (passo a passo) — escrevendo para facilitar a implementação exata:
  • Ler A e B (valores reais).
  • Verificar se A > |B| > 0; se não, avisar (mas ainda permitir a execução se desejar).
  • Inicializar x \leftarrow 0.
  • Para k = 1 até 100:
    1. x_{\text{novo}} \leftarrow -\dfrac{B}{A}\cos(x).
    2. r \leftarrow A \cdot x_{\text{novo}} + B \cdot \cos(x_{\text{novo}}).
    3. Se |r| < 10^{-6}, então terminar e devolver x_{\text{novo}} e k.
    4. Caso contrário, x \leftarrow x_{\text{novo}} e continuar.
  • Se completar 100 iterações sem atender o critério, devolver a última x 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 \cos (em Python, módulo math).
  • Lembrete motivacional: com A > |B| a técnica é robusta — confie no processo e confira sempre o resíduo |f(x)|.

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

Exercícios relacionados