Considere a equação X^{n}-A=0, que permite calcular \sqrt[n]{A}. Faça um programa que resolve a equação pelo método da secante com x_{0}=1 e x_{1}=1+\frac{(-1-1)}{\mathrm{m}}. O critério de parada é |f(x_{n})| < 10^{-8} ou |f(x_{n+1})-f(x_{n})| < 10^{-12} (erro) ou 50 iterações (erro).

Passo 1

O que o enunciado pede e quais dados foram dados.
  • Pede-se um programa que resolva a equação \;X^{n}-A=0\;, ou seja, que calcule \sqrt[n]{A} (uma raiz real de ordem \;n\;).
  • O método exigido é o método da secante, com condições iniciais:
    • x_0 = 1,
    • x_1 = 1 + \dfrac{(-1-1)}{\mathrm{m}}. Note que \dfrac{(-1-1)}{\mathrm{m}} = -\dfrac{2}{\mathrm{m}}, então x_1 = 1 - \dfrac{2}{\mathrm{m}}.
  • Critérios de parada (parar quando qualquer uma das condições for satisfeita):
    • \lvert f(x_k)\rvert < 10^{-8}, onde f(x)=x^{n}-A;
    • \lvert f(x_{k+1}) - f(x_k)\rvert < 10^{-12};
    • ou atingir 50 iterações (falha em convergir dentro do limite).
  • Observações importantes que já estão definidas pelo enunciado e que o programa deve respeitar:
    • O parâmetro \mathrm{m} aparece no enunciado; como não foi dado explicitamente, o programa deve aceitar \mathrm{m} como entrada (deve ser diferente de zero).
    • O método deve tratar casos numéricos problemáticos (divisão por zero no denominador da secante, iterações que não convergem).

Passo 2

Explicando o método da secante (conceito e fórmula) — aula curta e prática.
  • Ideia: em vez de usar a derivada (como no método de Newton), a secante aproxima a derivada por uma diferença entre dois pontos. Para f:\mathbb{R}\to\mathbb{R} dados dois pontos x_{k-1} e x_k, a reta secante que passa por (x_{k-1},f(x_{k-1})) e (x_k,f(x_k)) tem equação que leva à fórmula da iteração: x_{k+1}=x_k - f(x_k)\,\frac{x_k-x_{k-1}}{f(x_k)-f(x_{k-1})}.
    • Explicação linha a linha: a inclinação aproximada da derivada em x_k é \dfrac{f(x_k)-f(x_{k-1})}{x_k-x_{k-1}}. Substitui-se essa inclinação na fórmula de Newton x_{k+1}=x_k - \dfrac{f(x_k)}{f'(x_k)} e obtém-se a fórmula acima.
  • Características práticas:
    • Não requer cálculo explícito de f'.
    • Pode convergir mais rápido que métodos de ordem 1, mas não tem a garantia global do método da bisseção; pode divergir em más escolhas iniciais.
    • Requer que f(x_k)-f(x_{k-1})\neq 0 (senão divisão por zero).

Passo 3

Aplicando o método ao problema específico f(x)=x^{n}-A.
  • Definição da função: f(x)=x^{n}-A.
    • Aqui n é a ordem da raiz que queremos ( n inteiro positivo) e A é o número cujo n-ésima raiz procuramos.
  • Condição de existência de raiz real:
    • Se A>0: existe uma raiz real positiva.
    • Se A=0: raiz trivial x=0.
    • Se A<0 e n é par: não existe raiz real (seria complexa). O programa deve detectar isto e avisar.
    • Se A<0 e n é ímpar: existe raiz real negativa (podemos tentar convergir para ela).
  • Inicialização exigida pelo enunciado: x_0=1,\qquad x_1=1-\frac{2}{\mathrm{m}}.
    • O programa precisa checar \mathrm{m}\neq 0 e aceitar \mathrm{m} como parâmetro de entrada.
  • Fórmula de iteração a usar: x_{k+1}=x_k - f(x_k)\frac{x_k-x_{k-1}}{f(x_k)-f(x_{k-1})}.
    • Após obter x_{k+1}, atualiza-se x_{k-1}\leftarrow x_k e x_k\leftarrow x_{k+1}.

Passo 4

Critérios de parada e checagens numéricas (explicando o porquê das tolerâncias).
  • Critérios pedidos:
    • \lvert f(x_k)\rvert < 10^{-8}. Interpretação: o valor da função está suficientemente próximo de zero — encontramos uma boa raiz.
    • \lvert f(x_{k+1}) - f(x_k)\rvert < 10^{-12}. Interpretação: as avaliações sucessivas de f estão praticamente iguais — iterações não estão mais mudando a função (estabilização).
    • Ou 50 iterações (critério de saída por falha).
  • Ordem de verificação: a cada iteração, após calcular f(x_k) e o novo x_{k+1} (e f(x_{k+1})), verifique:
    1. se \lvert f(x_{k+1})\rvert < 10^{-8} então parar e aceitar x_{k+1};
    2. senão se \lvert f(x_{k+1}) - f(x_k)\rvert < 10^{-12} então parar e aceitar x_{k+1};
    3. senão continuar até o máximo de 50 iterações.
  • Tratamento de casos numéricos ruins:
    • Se f(x_k)-f(x_{k-1})=0 (ou muito próximo de zero), evita divisão por zero e interrompe com mensagem de falha.
    • Se houver overflow (valores muito grandes) ou NaN, interrompe e informa falha.
  • Observação prática: a secante pode oscilar ou divergir se as escolhas iniciais forem ruins; por isso é importante identificar e reportar não-convergência.

Passo 5

Detalhes de implementação (escolhas de programação e interfaces que o programa terá).
  • Entradas do programa:
    • A (real),
    • n (inteiro positivo),
    • \mathrm{m} (número real ou inteiro, diferente de zero) — usado para definir x_1.
  • Saídas:
    • Aproximação da raiz x,
    • Número de iterações realizadas,
    • Informação de convergência (convergiu por qual critério ou não convergiu).
  • Comportamento desejado:
    • Usar exatamente x_0 e x_1 conforme enunciado.
    • Implementar os critérios de parada pedidos.
    • Tratar caso inválido quando A<0 e n par — informar que não existe raiz real.
    • Evitar divisão por zero e avisar quando isto ocorrer.
  • Linguagem sugerida: Python (pela clareza e pela facilidade de testar). O código será fornecido pronto para execução.

Passo 6

Pseudocódigo do algoritmo (passo a passo de execução).
  • Pseudocódigo:
    • Ler A,n,\mathrm{m}.
    • Verificar se n é inteiro positivo e \mathrm{m}\neq 0.
    • Se A<0 e n par: informar que não existe raiz real e sair.
    • Definir x_0=1, x_1=1-\dfrac{2}{\mathrm{m}}.
    • Calcular f_0=f(x_0)=x_0^{n}-A, f_1=f(x_1)=x_1^{n}-A.
    • Para k de 1 até 50:
      • Se \lvert f_1\rvert < 10^{-8}: convergiu — retornar x_1.
      • Se \lvert f_1 - f_0\rvert < 10^{-12}: convergiu — retornar x_1.
      • Se \lvert f_1 - f_0\rvert é numericamente zero: parar e reportar falha (divisão por zero).
      • Calcular x_2 = x_1 - f_1\cdot\dfrac{x_1-x_0}{f_1-f_0}.
      • Atualizar x_0\leftarrow x_1, f_0\leftarrow f_1, x_1\leftarrow x_2, f_1\leftarrow f(x_1).
    • Se loop terminar sem critério satisfeito: reportar não-convergência (atingiu 50 iterações).
  • Recomenda-se imprimir uma tabela de iterações (opcional) contendo k, x_k, f(x_k) para depuração.

Passo 7

Exemplo numérico prático (para ver passo a passo as primeiras iterações e entender possíveis dificuldades).
  • Exemplo: tomar A=27, n=3, \mathrm{m}=10.
    • x_0=1.
    • x_1=1-\dfrac{2}{10}=0{,}8.
    • Calcular f(x)=x^3-27.
    • f(x_0)=1^3-27=-26.
    • f(x_1)=0{,}8^3-27=0{,}512-27=-26{,}488.
    • Verificar critérios: \lvert f(x_1)\rvert não é menor que 10^{-8} e \lvert f(x_1)-f(x_0)\rvert=0{,}488 não é menor que 10^{-12}.
    • Calcular o próximo ponto pela fórmula da secante: x_2 = x_1 - f(x_1)\frac{x_1-x_0}{f(x_1)-f(x_0)} = 0{,}8 - (-26{,}488)\frac{-0{,}2}{-0{,}488}.
      • Primeiro calcule \dfrac{x_1-x_0}{f(x_1)-f(x_0)} = \dfrac{-0{,}2}{-0{,}488}\approx 0{,}409836.
      • Depois f(x_1)\cdot essa fração \approx -26{,}488\times 0{,}409836\approx -10{,}853.
      • Logo x_2 \approx 0{,}8 - (-10{,}853) = 11{,}653.
    • Note que já nesta etapa ocorreu um grande overshoot (valor grande de x_2). Isto ilustra que, dependendo de \mathrm{m} e dos valores iniciais, a secante pode produzir valores grandes/intermediários antes de convergir. Por isso, o programa deve estar preparado para detectar não convergência ou overflow.
  • Conclusão do exemplo: a secante pode convergir, mas também pode oscilar; os critérios de parada e as checagens numéricas são essenciais.

Passo 8

Observações finais didáticas e dicas para usar o programa na prova (como raciocinar rápido).
  • Na prova, ao ver esse enunciado:
    1. Identifique f(x)=x^{n}-A.
    2. Calcule x_0=1, x_1=1-\dfrac{2}{m} (lembre que -1-1 = -2).
    3. Use a fórmula da secante para iterar; sempre compute f nos pontos antes de aplicar o critério de parada.
    4. Verifique rapidamente se A<0 e n par — nesse caso diga que não há raiz real.
    5. Se for necessário justificar convergência, explique que a secante não garante convergência global, mas apresenta convergência superlinear localmente quando a raiz é simples.
  • Dica prática para a prova: escreva explicitamente os primeiros dois f(x_0) e f(x_1), depois um cálculo manual de x_2 com passos (calcular a fração \dfrac{x_1-x_0}{f(x_1)-f(x_0)} primeiro, multiplicar por f(x_1), enfim calcule x_2). Isso mostra controle do método.

Passo 9

Código pronto (pequenas instruções de uso e o que o programa imprime).
  • O programa entregue implementa exatamente o descrito nas etapas anteriores: aceita entradas A,n,\mathrm{m}, usa x_0=1, x_1=1-\dfrac{2}{\mathrm{m}}, aplica a fórmula da secante, checa os critérios de parada e protege contra divisões por zero e casos sem raiz real.
  • O código está pronto para copiar/colar e executar em Python 3. Recomenda-se testar com valores simples, por exemplo A=27,n=3,m=10 para observar comportamento (mas lembre-se do overshoot mostrado no exemplo).

Resposta

# Método da secante para resolver x^n - A = 0
# Entrada: A (float), n (int > 0), m (float, diferente de zero)
# Critérios de parada:
#   |f(x_k)| < 1e-8
#   |f(x_{k+1}) - f(x_k)| < 1e-12
#   ou 50 iterações

def secante_root(A, n, m, max_iter=50, tol_f=1e-8, tol_df=1e-12, verbose=False):
    # checagens de entrada
    if n <= 0 or int(n) != n:
        raise ValueError("n deve ser inteiro positivo.")
    n = int(n)
    if m == 0:
        raise ValueError("m deve ser diferente de zero (pois x1 = 1 - 2/m).")
    # caso A < 0 e n par: não existe raiz real
    if A < 0 and n % 2 == 0:
        raise ValueError("A < 0 e n par -> não existe raiz real.")
    # inicialização
    x0 = 1.0
    x1 = 1.0 - 2.0 / float(m)  # x1 = 1 + (-2)/m
    def f(x):
        return x**n - A
    f0 = f(x0)
    f1 = f(x1)
    if verbose:
        print(f"it\t x\t\t f(x)")
        print(f"0\t{x0:.12g}\t{f0:.12g}")
        print(f"1\t{x1:.12g}\t{f1:.12g}")
    # iterações
    for k in range(1, max_iter+1):
        # checar critérios de parada com f1 (valor atual)
        if abs(f1) < tol_f:
            return {'root': x1, 'iter': k-1, 'status': 'converged_f', 'froot': f1}
        if abs(f1 - f0) < tol_df:
            return {'root': x1, 'iter': k-1, 'status': 'converged_df', 'froot': f1}
        denom = (f1 - f0)
        if denom == 0 or abs(denom) < 1e-20:
            # denominador zero (ou numericamente muito pequeno) -> falha
            return {'root': x1, 'iter': k-1, 'status': 'failure_division_by_zero', 'froot': f1}
        # fórmula da secante
        x2 = x1 - f1 * (x1 - x0) / denom
        # atualizar
        x0, f0 = x1, f1
        x1 = x2
        f1 = f(x1)
        if verbose:
            print(f"{k+1}\t{x1:.12g}\t{f1:.12g}")
        # checar os critérios de parada logo após computar x2 (poderia ter saído aqui também)
        if abs(f1) < tol_f:
            return {'root': x1, 'iter': k, 'status': 'converged_f', 'froot': f1}
        if abs(f1 - f0) < tol_df:
            return {'root': x1, 'iter': k, 'status': 'converged_df', 'froot': f1}
    # se chegou aqui, não convergiu dentro do número máximo de iterações
    return {'root': x1, 'iter': max_iter, 'status': 'max_iter_exceeded', 'froot': f1}

# Exemplo de uso:
if __name__ == "__main__":
    # exemplo: A = 27, n = 3, m = 10
    A = 27.0
    n = 3
    m = 10
    res = secante_root(A, n, m, verbose=True)
    print("\nResultado:")
    print(res)

Exercícios relacionados