30/08/2018 Atividade 2 - Cálculo Numérico

Para o dióxido de carbono (CO2), a equação de estado de um gás tem os seguintes coeficientes: a =
0, 401Pa m3 e b = 42, 7.10−6m3. Determine o volume ocupado por 1000 moléculas deste gás, à
temperatura de 300K e pressão de 3, 5.107Pa, pelo método de bissecção, com uma tolerância de 10-
12. Constante de Boltzmann é k = 1, 3806503.10-23 Joule K-1.

Faça também outros algoritmos para resolução usando os métodos de falsa-posição e de Newton-
Raphson.

Primeiramente plotamos o gráfico da função proposta:

    De inicio utilizaremos o critério de parada F(x) < tolerância, e o intervalo [-0.5,1] no qual pelo gráfico
sabemos que se encontra a raiz.

 Resolução pelo Método da Bisecção 

    O método da bisecção consiste em dividir ao meio o intervalo [a,b] que contenha a raiz sucessivas vezes
até atingir a tolerância estipulada.
    Algoritmo desenvolvido (em Python):
def f(x):
    return ((3.5*10**7) + (0.401*((1000/x)**2))) * (x - (1000*42.7*10**-6)) -
((1.3806503*10**-23)*1000*300)
def b(a,b):
    c = b
    n = 0
    X = []
    Y = []
    while (f(c) > 10**-12) or (f(c) < -(10**-12)):
        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(-0.5,1)
print(a,n)
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
plt.style.use('fivethirtyeight')
plt.plot(x,y, '-b', color='green')
plt.show()

    Resultado:
    V = 0.042699999999999995
    Número de iterações: 56

https://sites.google.com/site/calculonumerico2016ufabc/atividade-2 1/6
30/08/2018 Atividade 2 - Cálculo Numérico

Resolução pelo Método da Falsa-Posição

    O método da falsa-posição utiliza a média ponderada entre os limites do intervalo analisado para
escolher o valor da raiz com a tolerância permitida.

    Algoritmo desenlvolvido (em Python):

def f(x):
return ((3.5*10**7) + (0.401*((1000/x)**2))) * (x - (1000*42.7*10**-6)) -
((1.3806503*10**-23)*1000*300)
def fp(a,b):
c = 1
n = 0
X = []
Y = []
while (f(c) > 10**-12) or (f(c) < -(10**-12)):
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 = fp(-0.5,1)
print(a,n)
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
plt.style.use('fivethirtyeight')
plt.axis([-100, x[len(x)-1]+100, min(y)-0.1, max(y)+0.1])
plt.plot(x,y, '-b', color='green')
plt.show()

https://sites.google.com/site/calculonumerico2016ufabc/atividade-2 2/6
30/08/2018 Atividade 2 - Cálculo Numérico

    Resultado:
    V = 0.04270000000000034
    Número de iterações: 3167

    O critério de parada do código é o de F(x) < tolerância, porém utilizando esse método, nunca iria chegar
a precisão que queríamos de 10-12, pois foi observado que a partir de n = 3167 a suposta raiz da equação
não muda, ou seja, a partir de n= 3167 a raiz sempre será a mesma, por isso foi implementado ao código
uma estrutura de comparação, quando Pn = Pn-1 o código é interrompido evitando assim um looping
infinito. Ao calcularmos o F(0.004270000000000136) = 8.84473399906 *10-8 observamos que a precisão
dele é de 10-8 e não de 10-12 como foi proposto no enunciado.
Resolução pelo Método da Newton-Raphson:
def f(x):
    return ((3.5*10**7) + (0.401*((1000/x)**2))) * (x - (1000*42.7*10**-6)) -
((1.3806503*10**-23)*1000*300)
def df(x):
    return (3.5*10**7 - (0.401*(1000/x)**2) + (2*0.401*42.7*10**-6*(1000/x)**3))
def nr(a):    
    c = a
    n = 0
    X = []
    Y = []
    while (f(c) > 10**-12) or (f(c) < -(10**-12)):
        c = a - (f(a)/df(a))
        n += 1
        X.append(n)
        Y.append(c)
        if a==c:
            return c, n, X, Y
        a = c        
    return c, n,  X, Y
a,n,x,y = nr(1)
i t( )
https://sites.google.com/site/calculonumerico2016ufabc/atividade-2 3/6
30/08/2018 Atividade 2 - Cálculo Numérico
print(a,n)
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10))
plt.style.use('fivethirtyeight')
plt.plot(x,y, '-b', color='green')
plt.show()
 
    Resultado:
    V = 0.042699999999999995
    Número de iterações: 8

   

    Para o critério de parada F(x) < tolerância ao analisar todos os métodos implementados nesse problema
vemos que o de Newton-Raphson, foi o mais rápido e eficiente, uma vez que ele usou um número menor
de iterações e ele chegou a uma boa aproximação da raiz. 

    Agora analisaremos os métodos com o critério de parada (b-a) < tolerância onde a e b são as
extremidades do intervalo escolhido:

    
Resolução pelo Método da Bissecção:

    Algoritmo desenvolvido (em Python):

    def f(V):
a = 0.401
b = 42.7*10**-6
N = 1000
T = 300
3 5*10**7
https://sites.google.com/site/calculonumerico2016ufabc/atividade-2 4/6
30/08/2018 Atividade 2 - Cálculo Numérico
p = 3.5*10**7
k = 1.3806503*10**-23
return (p + a*(N/V)**2)*(V - N*b) - k*N*T
def iterar(e,a,b):
ni =0
while (b-a) >= e:
ni +=1
V = (a + b)/2.0
M = f(a)
if M * f(V) >0:
a=V
else:
b=V

print "V = ",V," Iteracoes: ",ni

a = -0.5
b = 1
iterar(10**-12,a,b)

    Resultado:
    V =0.0427000000002
    Número de iterações: 41

Resolução pelo Método da Falsa-Posição:

    Algoritmo desenvolvido (em Python):

def f(V):
a = 0.401
b = 42.7*10**-6
N = 1000
T = 300
p = 3.5*10**7
k = 1.3806503*10**-23
return (p + a*(N/V)**2)*(V - N*b) - k*N*T

def iterar(e,a,b):
ni = 0
#x = (a*f(b) - b*f(a))/(f(b) - f(a))
while (b-a)>= e:
ni +=1
x = (a*f(b) - b*f(a))/(f(b) - f(a))
if x==a or x==b:
break
if f(a)*f(x) >0:
a=x
else:
b=x

print "V = ",x," Iterações: ",ni

a = -0.5
b = 1
iterar(10**-12,a,b)

Resultado:
V =0.0427
Número de iterações: 3105

Resolução pelo Método de Newton-Raphson:

    Algoritmo desenvolvido (em Python):

def f(V):
a = 0.401
b = 42.7*10**-6
N = 1000
T = 300
p = 3.5*10**7
k = 1.3806503*10**-23
return (p + a*(N/V)**2)*(V - N*b) - k*N*T
https://sites.google.com/site/calculonumerico2016ufabc/atividade-2 5/6
30/08/2018 Atividade 2 - Cálculo Numérico

def fi(V):
a = 0.401
b = 42.7*10**-6
N = 1000
p = 3.5*10**7
return V - (f(V)/(p-(a*(N**2)*(V**-2))+(2*a*b*(N**3)*(V**-3))))

def iterar(x,e):

ni = 0
while abs(f(x))>= e:
ni +=1
x1 = fi(x)
if abs(x1 - x) <e:
x = x1
break
x = x1
print "V = ",x," Iterações: ",ni

iterar(1, 10**-12)

    Como o método de Newton necessita apenas de um chute inicial, executaremos o algoritmo para
ambas as extremidades do intervalo:
    Em x = -0.5:
        V = 0.0427
        Número de iterações: 27

        Em x = 1:
        V = 0.0427
        Número de iterações: 8

        Com os resultados vemos que com o critério de parada (b-a) < tolerância, tanto o método de Newton
quanto o método da falsa-posição nos dão resultados com boa aproximação da raiz da função, porém ao
analisar o número de iterações observamos que o método da falsa posição precisa de cerca de 300 vezes
mais iterações que o método de Newton e 75 vezes mais iterações que o método da bisecção.
        Agora comparando os critérios de parada, ambos deram boa aproximação para a raiz da função
porém o critério (b-a) < tolerância, em todos os três métodos o número de iterações foi menor do que o
critério f(x)< 0.

https://sites.google.com/site/calculonumerico2016ufabc/atividade-2 6/6