Considere a equação
, que permite calcular
. Faça um programa que resolve a equação pelo método da secante com
e
. O critério de parada é
ou
(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
, ou seja, que calcule (uma raiz real de ordem ). - O método exigido é o método da secante, com condições iniciais:
-
, -
. Note que , então .
-
- Critérios de parada (parar quando qualquer uma das condições for satisfeita):
-
, onde ; -
; - 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
aparece no enunciado; como não foi dado explicitamente, o programa deve aceitar 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).
- O parâmetro
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
dados dois pontos e , a reta secante que passa por e tem equação que leva à fórmula da iteração: - Explicação linha a linha: a inclinação aproximada da derivada em
é . Substitui-se essa inclinação na fórmula de Newton e obtém-se a fórmula acima.
- Explicação linha a linha: a inclinação aproximada da derivada em
- Características práticas:
- Não requer cálculo explícito de
. - 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
(senão divisão por zero).
- Não requer cálculo explícito de
Passo 3
Aplicando o método ao problema específico
.
- Definição da função:
- Aqui
é a ordem da raiz que queremos ( inteiro positivo) e é o número cujo -ésima raiz procuramos.
- Aqui
- Condição de existência de raiz real:
- Se
: existe uma raiz real positiva. - Se
: raiz trivial . - Se
e é par: não existe raiz real (seria complexa). O programa deve detectar isto e avisar. - Se
e é ímpar: existe raiz real negativa (podemos tentar convergir para ela).
- Se
- Inicialização exigida pelo enunciado:
- O programa precisa checar
e aceitar como parâmetro de entrada.
- O programa precisa checar
- Fórmula de iteração a usar:
- Após obter
, atualiza-se e .
- Após obter
Passo 4
Critérios de parada e checagens numéricas (explicando o porquê das tolerâncias).
- Critérios pedidos:
-
. Interpretação: o valor da função está suficientemente próximo de zero — encontramos uma boa raiz. -
. Interpretação: as avaliações sucessivas de 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
e o novo (e ), verifique: - se
então parar e aceitar ; - senão se
então parar e aceitar ; - senão continuar até o máximo de 50 iterações.
- se
- Tratamento de casos numéricos ruins:
- Se
(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.
- Se
- 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:
-
(real), -
(inteiro positivo), -
(número real ou inteiro, diferente de zero) — usado para definir .
-
- Saídas:
- Aproximação da raiz
, - Número de iterações realizadas,
- Informação de convergência (convergiu por qual critério ou não convergiu).
- Aproximação da raiz
- Comportamento desejado:
- Usar exatamente
e conforme enunciado. - Implementar os critérios de parada pedidos.
- Tratar caso inválido quando
e par — informar que não existe raiz real. - Evitar divisão por zero e avisar quando isto ocorrer.
- Usar exatamente
- 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
. - Verificar se
é inteiro positivo e . - Se
e par: informar que não existe raiz real e sair. - Definir
, . - Calcular
, . - Para k de 1 até 50:
- Se
: convergiu — retornar . - Se
: convergiu — retornar . - Se
é numericamente zero: parar e reportar falha (divisão por zero). - Calcular
. - Atualizar
, , , .
- Se
- Se loop terminar sem critério satisfeito: reportar não-convergência (atingiu 50 iterações).
- Ler
- Recomenda-se imprimir uma tabela de iterações (opcional) contendo
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
, , . -
. -
. - Calcular
. -
. -
. - Verificar critérios:
não é menor que e não é menor que . - Calcular o próximo ponto pela fórmula da secante:
- Primeiro calcule
. - Depois
essa fração . - Logo
.
- Primeiro calcule
- Note que já nesta etapa ocorreu um grande overshoot (valor grande de
). Isto ilustra que, dependendo de 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:
- Identifique
. - Calcule
, (lembre que ). - Use a fórmula da secante para iterar; sempre compute
nos pontos antes de aplicar o critério de parada. - Verifique rapidamente se
e par — nesse caso diga que não há raiz real. - 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.
- Identifique
- Dica prática para a prova: escreva explicitamente os primeiros dois
e , depois um cálculo manual de com passos (calcular a fração primeiro, multiplicar por , enfim calcule ). 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
, usa , , 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
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)