Cálculo Numérico

Cálculo Numérico
Victor Santiago - 202051631961
Pedro Magalhães - 202051158573
Andrezza Guimarães - 202051534401
Victor Medeiros - 20210254541191
Edgar Freitas - 202051699991
Jeziel Carlos de Andrade - 202104004265
1
• Introdução
O cálculo numérico pode ser entendido como um conjunto de ferramentas ou

métodos a fim de obter soluções de problemas matemáticos de forma
aproximada, principalmente quando se é tratado de problemas no qual não
possuem soluções exatas, portanto precisam ser resolvidos numericamente.
Primeiramente, será realizada a elaboração gráfica das funções 𝑓 (𝑥 ) = 𝑥 3 −

5𝑥 2 − 17𝑥 e 𝑓 (𝑥 ) = 𝑐𝑜𝑠 2 𝑥 + 2𝑥 − 2 , com o objetivo de analisar qual o intervalo
que será usado no método intervelar, da Bisseção, e qual ou quais valores iniciais
para o método aberto, de Newton-Raphson, na elaboração de um programa com
linguagem Python, a fim de obter uma aproximação de uma raiz das funções.
Vale ressaltar que, o critério de parada é de 𝜀 = 10−4 e o número máximo de

interações é de 30.
• Elaboração Gráfica das funções – Geogebra

▪ 𝑓 (𝑥 ) = 𝑥 3 − 5𝑥 2 − 17𝑥
O intervalo analisado foi de [-2.4, 0] e o valor inicial é de -2.3.
2
▪ 𝑓 (𝑥 ) = 𝑐𝑜𝑠 2 𝑥 + 2𝑥 − 2
O intervalo analisado foi de [0.5, 1] e o valor inicial é de 0.7.
• Método da Bisseção:
Para y = f (x) sendo uma função contínua no intervalo [a, b] e possuindo uma
única raiz.
Tal método consiste em dividir o intervalo [a, b], de forma iterativa utilizando
a seguinte fórmula:
Após obter o resultado, através do Teorema de Bolzano, é verificado se a raiz

está contida na primeira ou na segunda metade do intervalo, este é repetido para
aquela metade que contém a raiz de f(x) = 0, ou seja, aquela em que a função, y =
f(x), tem valores numéricos com sinais opostos nos seus extremos.
3
• Método de Newton-Raphson
Desenvolvido por Isaac Newton e Joseph Raphson, ao contrário do Método da

Bisseção, seu primeiro passo consiste em escolher uma aproximação inicial. Após
isso, calcula-se através das derivadas a equação da reta tangente da função nesse
ponto e a interseção dela com o eixo das abcissas, a fim de encontrar uma melhor
aproximação para a raiz. Tal método é repetido e seu processo iterativo é dado
por:
𝑥𝑛 é uma aproximação inicial
n indica a n-ésima iteração do algoritmo
𝑓′(𝑥𝑛) é a derivada da função 𝑓 no ponto 𝑥𝑛
• Programa - Python
def f(x):
return (x**3) - (5* x**2) - 17*x

def bisseccao(a, b, Erro, itMax):
it = 0
x=a
Er = 1
while (Er >= Erro and it < itMax):
xold = x
x = (a+b)/2
Er = abs((x - xold)/x)
if (f(a)*f(x) < 0):
b=x
4
else:
a=x
it = it + 1
return (x, Er, it)
print('Método da Bissecção: Função 1 \n')
a = float(input('Intervalo a: '))
b = float(input('Intervalo b: '))
Erro = float(input('Informe a precisão: '))
itMax = 30
res = bisseccao(a, b, Erro, itMax)
print('O valor da raíz é: ', res[0])

print('O erro relativo foi: ', res[1])
print('O número de iterações foi: ', res[2])
print('\n')
def f(x):
import math
return (math.cos(x))**2 + (2 * x) - 2
def bisseccao(a, b, Erro, itMax):
it = 0
x=a
Er = 1
while (Er >= Erro and it < itMax):
xold = x
x = (a+b)/2
Er = abs((x - xold)/x)
if (f(a)*f(x) < 0):
b=x
else:
5
a=x
it = it + 1
return (x, Er, it)
print('Método da Bissecção: Função 2 \n')
a = float(input('Intervalo a: '))
b = float(input('Intervalo b: '))
Erro = float(input('Informe a precisão: '))
itMax = 30
res = bisseccao(a, b, Erro, itMax)
print('O valor da raíz é: ', res[0])

print('O erro relativo foi: ', res[1])
print('O número de iterações foi: ', res[2])
print('\n')
print('Método de Newton-Raphson: Função 1 \n')

xi = float(input('Digite o valor de X0: '))
precisao = float(input('Digite o valor de precisão: '))
print('\n')
xk = 999999.999
contador = 0
def teste (x):
fx = (x**3) - (5* x**2) - 17*x

fdx = (3*x**2) - (10*x) - 17
divisao = fx/fdx
return divisao
while (abs((xk-xi)/xk)) > precisao or contador == 30:

x = xi
6
xi = (x) - teste(x)
x = xi
xk = (x) - teste(x)
contador = contador + 1
print('Iteração {}'.format(contador))
print('\n')
print('O valor da raiz aproximada encontrada foi: {}'.format(xk))
print('O valor do erro relativo percentual encontrado foi:
{}'.format((abs((xk-xi)/xk))))
print('\n')
import math
print('Método de Newton-Raphson: Função 2 \n')

xi = float(input('Digite o valor de X0: '))
precisao = float(input('Digite o valor de precisão: '))
print('\n')
xk = 999999.999
contador = 0
def teste (x):

fx = ((math.cos(x))**2) + (2 * x) - 2
fdx = -(math.sin(2*x)) + 2
divisao = fx/fdx
return divisao
while (abs((xk-xi)/xk)) > precisao or contador == 30:

x = xi
xi = (x) - teste(x)
x = xi
7
xk = (x) - teste(x)
contador = contador + 1
print('Iteração {}'.format(contador))
print('\n')
print('O valor da raiz aproximada encontrada foi: {}'.format(xk))
print('O valor do erro relativo percentual encontrado foi:
{}'.format((abs((xk-xi)/xk))))
print('\n')
• Conclusão
▪ Função 1: 𝑓(𝑥 ) = 𝑥 3 − 5𝑥 2 − 17𝑥

▪ Função 2: 𝑓(𝑥 ) = 𝑐𝑜𝑠 2 𝑥 + 2𝑥 − 2
Levando em consideração os resultados obtidos vemos que na primeira

função o Método Newton-Raphson converge em apenas 2 interações enquanto o
Método de Bisseção converge em 14 iterações. Entretanto, na segunda função o
Método Newton-Raphson converge em 1 iteração e o Método da Bisseção em 13
iterações, comprovando assim que o primeiro método referido (Newton-
Raphson) converge mais rápido. Outrossim, podemos notar que a porcentagem
de erro em ambas as funções é menor quando foi usado o Método Newton-
Raphson. Vê-se também que as raízes encontradas por cada método são muito
semelhantes com diferença de apenas 0,0001 em ambas as funções.
Avaliando os resultados obtidos podemos dizer que: o Método Newton-

Raphson converge mais rápido e mantem uma porcentagem de erro menor ao ser
comparado com o Método da Bisseção.
Com base nessas afirmações podemos concluir que o método Newton-

Raphson é mais adequado para encontrar as raízes das funções.
8
Bibliografia
http://www.decom.ufop.br/bcc760/material_de_apoio/notas_de_aulas/notas_r
aizes.pdf
https://www.conexaogeoclima.com.br/post/o_que_e_calculo_numerico
http://www.dma.uem.br/kit/calculo-numerico-2/copy_of_kit-
newtonraphson.pdf

Cálculo Numérico - Bisseção e Newton Raphson em Python

Enviado por

Direitos autorais:

Formatos disponíveis

Cálculo Numérico - Bisseção e Newton Raphson em Python

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Cálculo Numérico - Bisseção e Newton Raphson em Python

Enviado por

Direitos autorais:

Formatos disponíveis

Victor Santiago - 202051631961

Pedro Magalhães - 202051158573

Andrezza Guimarães - 202051534401

Victor Medeiros - 20210254541191

Edgar Freitas - 202051699991

Jeziel Carlos de Andrade - 202104004265

O cálculo numérico pode ser entendido como um conjunto de ferramentas ou

Primeiramente, será realizada a elaboração gráfica das funções 𝑓 (𝑥 ) = 𝑥 3 −

Vale ressaltar que, o critério de parada é de 𝜀 = 10−4 e o número máximo de

• Elaboração Gráfica das funções – Geogebra

Após obter o resultado, através do Teorema de Bolzano, é verificado se a raiz

Desenvolvido por Isaac Newton e Joseph Raphson, ao contrário do Método da

𝑥𝑛 é uma aproximação inicial

n indica a n-ésima iteração do algoritmo

𝑓′(𝑥𝑛) é a derivada da função 𝑓 no ponto 𝑥𝑛

return (x**3) - (5* x**2) - 17*x

print('O valor da raíz é: ', res[0])

print('O valor da raíz é: ', res[0])

print('Método de Newton-Raphson: Função 1 \n')

def teste (x):

fx = (x**3) - (5* x**2) - 17*x

while (abs((xk-xi)/xk)) > precisao or contador == 30:

print('Método de Newton-Raphson: Função 2 \n')

def teste (x):

while (abs((xk-xi)/xk)) > precisao or contador == 30:

▪ Função 1: 𝑓(𝑥 ) = 𝑥 3 − 5𝑥 2 − 17𝑥

Levando em consideração os resultados obtidos vemos que na primeira

Avaliando os resultados obtidos podemos dizer que: o Método Newton-

Com base nessas afirmações podemos concluir que o método Newton-

Você também pode gostar