Relatório Referente ao Segundo Trabalho

de Análise Numérica
Programa em Python que exemplifica os métodos da Bissecção, de Newton e da Secante

Ana Borsatti Nº 77946

Maria Eduarda Anjos Nº 79768
Yasmin Dias Nº 77733
Apresentação

O trabalho consiste em criarmos três códigos em PYTHON que calculam valores aproximados de
raízes de equações não lineares, usando o Método da Bissecção, Método de Newton e Método da
Secante.

Método da Bissecção
Outputs - Método da Bissecção

Método da Secante

import math

def secant_method(f, r0, r1, N):

k = 2 # k = número de iterações inicializadas como 2

y0 = f(r0) # calcula os valores da função f para os valores iniciais de r0 e r1

y1 = f(r1)

previous_r = r1 # inicializa a variável previous_r com o valor de r1

while k <= N: # itera até que k seja igual a N (número máximo de iterações permitidas)

r = r1 - y1 * (r1 - r0) / (y1 - y0) # cálculo de r_k usando o Método da Secante

rounded_r = round(r, 9) # Arredonda para 9 casas decimais

print(f"Iteração {k}: r ≈ {rounded_r:.9f}") # exibe informações sobre a iteração atual

if round(previous_r, 9) == rounded_r: # verifica se o valor rounded_r é igual ao valor anterior

de r arredondado para 9 casas decimais
 return rounded_r # se forem iguais, a solução foi encontrada

k += 1 # atualiza k a cada iteração

r0, y0, r1, y1 = r1, y1, r, f(r)

# r0 e y0 recebem os valores antigos de r1 e y1, que são as estimativas e valores da função da

iteração anterior

# r1 recebe o valor de r, que é o resultado da iteração atual do método da secante e é a estimativa

mais recente da raiz

# y1 recebe o valor de f(r), que é o valor da função para a estimativa mais recente r

previous_r = r # previous_r é atualizada para armazenar o valor atual de r, que é a estimativa

mais recente da raiz após a iteração atual

return "O Método falhou após N iterações" # não foi possível encontrar uma solução dentro do
limite de iterações

# solicita a função ao usuário

user_function = input("Digite a expressão da função f(x): ")

user_function = user_function.replace('e', 'math.e') # substitui 'e' pelo valor de Euler na

expressão

user_function = user_function.replace('pi', 'math.pi')

user_function = user_function.replace('sin', 'math.sin')

user_function = user_function.replace('cos', 'math.cos')

user_function = user_function.replace('tan', 'math.tan')

user_function = user_function.replace('log', 'math.log')

user_function = user_function.replace('sqrt', 'math.sqrt')

f = lambda x: eval(user_function) # define a função f(x) usando a função definida anteriormente

# solicita os valores ao usuário

r0 = float(input("Digite o valor de r0: "))

r1 = float(input("Digite o valor de r1: "))

N = int(input("Digite o número de iterações (N): "))

solucao_aproximada = secant_method(f, r0, r1, N)

if isinstance(solucao_aproximada, str):

print(solucao_aproximada) # se solucao_aproximada for uma string (indicando uma mensagem de

erro), imprime a mensagem de falha na tela

else:

print("Solução aproximada:", solucao_aproximada)

Outputs - Método da Secante

Método de Newton

import math

def metodo_newton(funcao_usuario, limite_inferior, limite_superior, tolerancia):

# Define a função baseada na entrada do usuário

def funcao(x_val):

contexto = {

'x': x_val,

'e': math.e,

'sin': math.sin,

'cos': math.cos,

'tan': math.tan,

'log': math.log,

'ln': math.log,

'pi': math.pi,
 'sqrt': math.sqrt,

'exp': math.exp

return eval(funcao_usuario, {}, contexto)

# Calcula a derivada da função usando uma diferença finita central

def derivada(x_val, h=1e-5):

return (funcao(x_val + h) - funcao(x_val)) / h

# Calcula a segunda derivada da função

def segunda_derivada(x_val, h=1e-5):

return (derivada(x_val + h) - derivada(x_val)) / h

# Encontra M1 e M2 para o erro majorante

M1 = min(abs(derivada(limite_inferior)), abs(derivada(limite_superior)))

M2 = max(abs(segunda_derivada(limite_inferior)),
abs(segunda_derivada(limite_superior)))

# Escolhe o ponto de partida baseado na segunda derivada

x_atual = limite_inferior if funcao(limite_inferior) *

segunda_derivada(limite_inferior) > 0 else limite_superior

iteracao = 0

while True:

iteracao += 1

fx_atual = funcao(x_atual)

dfx_atual = derivada(x_atual)

# Fórmula de Newton para encontrar o próximo x

 x_proximo = x_atual - fx_atual / dfx_atual

# Calcula o erro majorante ajustado

erro_maiorante = (M2 / (2 * M1)) * (abs(x_proximo - x_atual) ** 2)

# Verifica se o erro é menor que a tolerância para parar o loop

if erro_maiorante < tolerancia:

break

x_atual = x_proximo

print(f'Iteração {iteracao} -› x = {x_proximo:.9f}')

return x_atual

if __name__ == "__main__":

# Solicita ao usuário inserir a função e os limites do intervalo

funcao_str = input('Insira a função (em termos de x): ')

limite_a = float(input('Insira o limite inferior: '))

limite_b = float(input('Insira o limite superior: '))

# Define a tolerância como \(10^{-9}\)

tolerancia = 1e-9

# Chama o método de Newton e exibe o resultado

raiz = metodo_newton(funcao_str, limite_a, limite_b, tolerancia)

print(f'Raiz aproximada: x = {raiz:.9f}')

Outputs - Método de Newton

Referências:
Sebenta de Apontamentos de Análise Numérica, da Faculdade de Engenharia da Universidade do
Porto Licenciatura em Engenharia Electrotécnica e de Computadores. Docente:Aníbal Castilho
Coimbra de Matos, Setembro de 2005.