Calculo Numerico - Lista 02

Prévia do material em texto

1 
 
 
UNIVERSIDADE FEDERAL DO MARANHÃO 
CAMPUS BALSAS 
CURSO DE CIÊNCIA E TECNOLOGIA 
DISCIPLINA: CÁLCULO NUMÉRICO 
DOCENTE: DR. ANDERSSON ALLES DE JESUS 
 
 
 
 
 
LISTA 2 
 
 
JHESSYCA DANTAS MANARY 
 
 
 
 
 
 
 
 
 
BALSAS - MA 
2021 
 
 
2 
 
 
UNIVERSIDADE FEDERAL DO MARANHÃO 
JHESSYCA DANTAS MANARY 
 
 
 
 
 
 
 
LISTA 2 
 
 
 
 
Lista de exercícios 
apresentado à disciplina 
Cálculo Numérico do 
curso Ciência e 
Tecnologia, como 
requisito para obtenção 
de nota. 
 
 
 
Docente: Dr. Andersson Alles de Jesus 
 
 
 
 
 
 
BALSAS - MA 
2021
 
 
3 
 
1. Implemente em Python o método da Bisecção 
 
def f(x): 
 return x**3 - 9*x + 3 
 
a = float (input('Insira o limite inferior a: ')) 
b = float (input('Insira o limite inferior b: ')) 
iteracoes = int (input('Insira o número de iterações: ')) 
iteracao = 0 
if f(a)*f(b)<0: 
 while iteracao <= iteracoes: 
 c = (a+b)/2 
 if f(a)*f(b)<0: 
 b = c 
 elif f(a)*f(b)<0: 
 a = c 
 iteracao += 1 
 
 print('A raiz encontrada foi x = ', c) 
 print('f(x)= ', f(c)) 
 
else: 
 print('Não há raízes neste intervalo.') 
 
 
 
4 
 
2. Implemente em Python o método da Falsa Posição 
 
import numpy as np 
 
f = lambda x: x-2**(-x) 
 
inter = lambda a,b,erro: 1 + int((np.log(b-a)-
np.log(erro))//np.log(2)) 
 
a,b,erro = 1,2,10**(-5) 
 
k = iter(a,b,erro) 
 
x = (a*f(b)-b*f(a))/(f(b)-f(a)) 
 
for i in range(k): 
 if np.abs(f(x)) >= erro: 
 if f(a)*f(x)<0: 
 b = x 
 else: 
 a = x 
 else: 
 break 
 
print("Solução numérica: %f" %x) 
print("Iterações: %d" %i) 
 
 
 
 
5 
 
3. Implemente em Python o método de Newthon 
 
import numpy as np 
import mpmath as mp 
mp.dps = 15; mp.pretty = True 
 
f = lambda x: x-2**(-x) 
 
inter = lambda a,b,erro: 1 + int((np.log(b-a)-
np.log(erro))//np.log(2)) 
 
a,b,erro = 1,2,10**(-5) 
k = iter(a,b,erro) 
 
for i in range(k): 
 x = a-(f(a)/mp.diff(f,a)) 
 
 if np.abs((x-a)/a)<erro: 
 break 
 a = x 
 
print("Solução numérica: %f" %x) 
print("Iterações: %d" %i) 
 
 
 
 
6 
 
4. Localize graficamente as raízes das equações a seguir: 
a) 𝟒𝒄𝒐𝒔(𝒙) − 𝒆𝟐𝒙 = 𝟎 
 
 
b) 
𝒙
𝟐
− 𝒕𝒂𝒏(𝒙) = 𝟎 
 
 
 
 
7 
 
c) 𝟏 − 𝒙𝒍𝒏(𝒙) = 𝟎 
 
 
d) 𝟐𝒙 − 𝟑𝒙 = 𝟎 
 
e) 𝒙𝟑 + 𝒙 − 𝟏𝟎𝟎𝟎 = 𝟎 
 
 
8 
 
 
5. Seja 𝒇(𝒙) = (𝒙 + 𝟐)(𝒙 + 𝟏)𝟐𝒙(𝒙 − 𝟏)𝟑(𝒙 − 𝟐). Para qual zero de f o 
método da Bisseção converge quando aplicado aos intervalos a 
seguir? 
 
a) [-1,5; 2,5] 
 
def f(x): 
return ((x+2)*((x+1)**2)*(x*(x-1)**3)*(x-def 
b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 2.5) or (f(c) < -(1.5)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n =+ c 
X.append(n) 
Y.append(c) 
return a, n, X, Y 
a,n,x,y = b(-1.5,2.5) 
print("o método da Bissecção converge para o valor:", n) 
 
 
9 
 
b) [-0,5; 2,4] 
 
def f(x): 
return ((x+2)*((x+1)**2)*(x*(x-1)**3)*(x-2)) 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 2.4) or (f(c) < -(0.5)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n =+ c 
X.append(n) 
Y.append(c) 
return a, n, X, Y 
a,n,x,y = b(-0.5,2.4) 
print("o método da Bissecção converge para o valor:", n) 
 
 
 
 
 
10 
 
c) [-0,5; 3] 
 
def f(x): 
return ((x+2)*((x+1)**2)*(x*(x-1)**3)*(x-def 
b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 3) or (f(c) < -(0.5)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n =+ c 
X.append(n) 
Y.append(c) 
return a, n, X, Y 
a,n,x,y = b(-0.5,3) 
print("o método da Bissecção converge para o valor:", n) 
 
 
 
 
 
11 
 
d) [-3; -0,5] 
 
def f(x): 
return ((x+2)*((x+1)**2)*(x*(x-1)**3)*(x-def 
b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > (3)) or (f(c) < -(0.5)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n =+ c 
X.append(n) 
Y.append(c) 
return a, n, X, Y 
a,n,x,y = b(-3, -0.5) 
print("o método da Bissecção converge para o valor:", n) 
 
 
 
 
6. Sabe-se que a função 𝒇(𝒙) = 𝒙𝟑 − 𝒙 − 𝟏 tem uma raiz no intervalo [1 , 2] 
. Calcule uma aproximação com precisão 𝜀 = 10−6 para esta raiz, 
utilizando algum critério de parada, por meio do método da bissecção. 
 
a) Resolva manualmente (Até 6 Iterações). 
a b x f(x) 
1 2 1,5 0,875 
1 1,5 1,25 -0,296 
1,25 1,5 1,375 0,224 
1,25 1,375 1,312 -0,051 
1,312 1,375 1,343 0,082 
1,312 1,343 1,327 0,012 
 
 
 
 
12 
 
b) Resolva computacionalmente. 
 
def f(x): 
return ((x**3) - (x) - 1) def b(a,b): 
c = b 
n = 0 X = [] 
Y = [] 
while (f(c) > 0.000001) or (f(c) <- (0.000001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: b = c 
elif f(c)*f(b) < 0: a = c 
n += 1 
X.append(n) Y.append(c) 
return c, n, X, Y a,n,x,y = b(1, 
 
print("O valor da aproximação será:",a) 
print("O número de interações será: ",n) 
 
7. Sabe-se que a função 𝒇(𝒙) = 𝒙𝟑 − 𝒙 − 𝟏 tem uma raiz no intervalo [1,2] . 
Calcule uma aproximação com precisão 𝜀 = 10−6 para esta raiz, 
utilizando algum critério de parada, por meio do método da posição 
falsa. 
a) Resolva manualmente (Até 6 Iterações) 
 
x f(x) 
1 -1 
1,2 -0,47 
1,4 0,34 
1,6 1,5 
1,8 3,03 
2 5 
 
 
a f(a) b f(b) x f(x) 
1 -1 2 5 1,16 -0,59 
1,16 -0,57 2 5 1,23 -0,3 
1,23 -0,3 2 5 1,29 -0,14 
1,29 -0,14 2 5 1,31 -0,062 
1,31 -0,062 2 5 1,32 -0,028 
1,32 -0,028 2 5 1,32 -0,004 
 
 
13 
 
b) Resolva computacionalmente 
 
def f(x): 
return ((x**3) - (x) - 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.000001) or (f(c) <- (0.000001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
return c, n, X, Y 
a,n,x,y = b(1,2) 
print(" O valor será: ", a) 
print("Número de interações: ", n) 
 
8. Dobre a convergência para a raiz de 𝑓(𝑥) = 𝑥3 − 𝑥 − 1, nos exercícios 4 e 
5: 
a) Justifique por que a convergência para a raiz foi mais rápida por 
meio do método da posição falsa, do que por meio do método da 
bissecção; 
A raiz converge mais rápido pelo fato do cálculo estar sendo feito através da 
média ponderada, o que faz com que o intervalo vá convergindo mais 
rápido para raiz real da função. 
 
 
 
 
 
 
 
 
 
 
 
14 
 
 
 
9. Empregue códigos computacionais para resolver as seguintes 
equações, empregando os métodos da Bisseção, Falsa Posição e 
Newton . Como tolerância (precisão), empregue 10-10 e número 
máximo de iterações igual a 100. Apresente o resultado em uma tabela 
com os seguintes dados: 𝑥 e 𝑓(𝑥) [solução e valor da função para a 
solução encontrada, ambas com 15 dígitos), erro estimado na última 
iteração e número de iterações efetuadas. 
a) 𝒆−𝒙
𝟐
− 𝒄𝒐𝒔(𝒙); [𝟏; 𝟐] 
# Método da Bissecção############### 
def f(x): 
return np.exp(-x**2)- np.cos(x) 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < -(0.0000000001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(1,2) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
15 
 
#Método da Falsa posição######### 
def f(x): 
return np.exp(-x**2)- np.cos(x) 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - 
(0.0000000001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=100: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(1,2) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n)16 
 
##### Método de Newton ##### 
def f(x): 
return np.exp(-x**2)- np.cos(x) 
def df(x): 
return -2*np.exp(-x**2)* x - np.cos(x) 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - (0.0000000001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=100: 
break; 
 
return c, n, X, Y 
 
a,n,x,y = b(1,2) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n) 
 
 
 
 
17 
 
b) 𝒙𝟑 − 𝒙 − 𝟏; [𝟏; 𝟐] 
####### Método da Bissecção ######## 
def f(x): 
return ((x**3) - x - 1) 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) <- (0.0000000001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(1, 2) 
 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
18 
 
###### Método da Falsa Posição ###### 
def f(x): 
return ((x**3) - x - 1) 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 1) or (f(c) < (100)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(1,2) 
print(" O valor será: ", a) 
print("Número de interações: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
19 
 
##### Método de Newton ##### 
def f(x): 
return ((x**3) - x - 1) 
def df(x): 
return 3*x**2 -1 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - (0.0000000001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=100: 
break; 
 
return c, n, X, Y 
 
a,n,x,y = b(1,2) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
20 
 
c) 𝟒𝒔𝒆𝒏(𝐱) − 𝐞𝐱 ; [0; 1] 
 
# Método da Bissecção############### 
def f(x): 
return 4*np.sin(x) - np.exp (x) 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < -(0.0000000001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(0,1) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n)
 
 
21 
 
 
#Método da Falsa posição######### 
 def f(x): 
return 4*np.sin(x) - np.exp (x) 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - 
(0.0000000001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=100: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(0,1) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
22 
 
##### Método de Newton ##### 
def f(x): 
return 4*np.sin(x) - np.exp (x) 
def df(x): 
return 4*np.cos(x) - np.exp(x) 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - (0.0000000001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(0,1) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
23 
 
d) 𝑥log(𝑥) − 1; [2; 3] 
 
# Método da Bissecção############### 
def f(x): 
return x*np.log(x) - 1 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < -(0.0000000001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(2,3) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
24 
 
#Método da Falsa posição######### 
def f(x): 
return x*np.log(x) - 1 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - 
(0.0000000001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=100: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(2,3) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
25 
 
 
##### Método de Newton ##### 
def f(x): 
return x*np.log(x) - 1 
def df(x): 
return np.log(x) + 1 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0000000001) or (f(c) < - (0.0000000001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=100: 
break; 
return c, n, X, Y 
a,n,x,y = b(2, 3) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
26 
 
10. Utilize os métodos da Bisseção, Newton, Secante e Falsa Posição para 
encontrar soluções com precisão de 10-4 (ou 4 iterações) para os problemas a 
seguir. 
a) 𝑥 ³ − 𝑥 ² − 5 = 0; [1; 4] 
 
# Método da Bissecção############### 
def f(x): 
return x**3 - x**2 -5 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(1,4) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
27 
 
 
#Método da Falsa posição######### 
def f(x): 
return x**3 - x**2 - 5 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(1,4) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
28 
 
##### Método de Newton ##### 
def f(x): 
return x**3 - x**2 -5 
def df(x): 
return 3*x**2 - 2*x 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < - (0.0001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(1, 4) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
29 
 
b) x − cos(𝑥) = 0; [0; 𝜋⁄2] 
# Método da Bissecção############### 
def f(x): 
return x - np.cos(x) 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(0, np.pi/2) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
30 
 
#Método da Falsa posição######### 
 def f(x): 
return x - np.cos(x) 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b)< 0: 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(0, np.pi/2) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
31 
 
##### Método de Newton ##### 
def f(x): 
return x - np.cos(x) 
def df(x): 
return 1+np.sin(x) 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < - (0.0001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=4: 
break; 
 
return c, n, X, Y 
 
a,n,x,y = b(0, np.pi/2) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n)
 
 
32 
 
 
c) sen(𝑥) − 𝒆−𝒙 = 0; [0; 1] 
# Método da Bissecção############### 
def f(x): 
return np.sin(x) - np.exp(-x) 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(0,1) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
33 
 
#Método da Falsa posição######### 
 def f(x): 
return np.sin(x) - np.exp(-x) 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(0,1) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
34 
 
 
##### Método de Newton ##### 
def f(x): 
return np.sin(x) - np.exp(-x) 
def df(x): 
return np.cos(x) + np.exp(-x) 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < - (0.0001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(0,1) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
35 
 
d) 𝒆𝒙 − 𝟑𝒙𝟐 = 𝟎; [𝟑; 𝟓] 
# Método da Bissecção############### 
def f(x): 
return np.exp(x) - 3*x**2 
def b(a,b): 
c = b 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = (a+b)/2 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
n += 1 
X.append(n) 
Y.append(c) 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(3,5) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
36 
 
#Método da Falsa posição######### 
def f(x): 
return np.exp(x) - 3*x**2 
def b(a,b): 
c = 1 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < -(0.0001)): 
c = b - ((f(b)*(b-a))/(f(b)- f(a))) 
n += 1 
X.append(n) 
Y.append(c) 
if c==a or c==b: 
return c, n, X, Y 
if f(c)*f(a) < 0: 
b = c 
elif f(c)*f(b) < 0: 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
 
a,n,x,y = b(3,5) 
print("O valor da aproximação será: ", a) 
print("O número de interações será: ", n) 
 
 
37 
 
 
##### Método de Newton ##### 
def f(x): 
return np.exp(x) - 3*x**2 
def df(x): 
return np.cos(x) + np.exp(-x) 
def b(a,b): 
c = a 
n = 0 
X = [] 
Y = [] 
while (f(c) > 0.0001) or (f(c) < - (0.0001)): 
c = a - (f(a)/df(a)) 
n += 1 
X.append(n) 
Y.append(c) 
if a==c: 
return c, n, X, Y 
a = c 
if n >=4: 
break; 
return c, n, X, Y 
a,n,x,y = b(3, 5) 
print("O valor da raiz será: ", a) 
print("O valor de interações será: ", n)