Trabalho 1 - Métodos Numéricos Computacionais

Prévia do material em texto

Exercício 1
Considerando e , utilizei o seguinte programa para testar valores de entre 
 e :
f(x) = e
1
x
1+e
1
x
g(x) = 1
+1e
−1
x
x
0.1 0.001
In [ ]:
from math import e 
def f(x): 
 return((e**(1/x))/(1+(e**(1/x)))) 
def g(x): 
 return(1/((e**(-1/x))+1)) 
x = 0.1 
while (x > 0.001): 
 print(x, g(x)) 
 x = x - 0.0001 
x = 0.1 
while (x > 0.001): 
 print(x, f(x)) 
 x = x - 0.0001 
A função rodou normalmente e o último valor mostrado foi e 
. Já a função retornou erro de Overflow para valores abaixo de 
, ou seja, valores abaixo disso não são exatamente representáveis pelo
sistema de ponto flutuante.
g(x) x = 0.001099999999998172
g(x) = 1.0 f(x)
x = 0.0014999999999981723
Exercício 2
A Série de Taylor de em torno de pode ser escrita como . O
seguinte programa aproxima o valor de com um termo a mais a cada iteração.
f(x) = ln(1 + x) x = 0 ∑∞n=1
(−1)
n+1
n
xn
ln(1 + x)
In [16]:
ln_ant = 0 
n = 1 
x = 0 
for n in range(1,11,1): 
 ln = ln_ant + ((((-1)**(n+1))/n)*(x**n)) 
 print ("Valor com {} termos = {}". format(n, ln)) 
 ln_ant = ln 
Para calcular o valor de foi utilizado .ln(0.8) x = −0.2
In [18]:
from math import log 
ln_ant = 0 
n = 1 
x = -0.2 
err = 100 
while (err > 0.0001): 
 ln = ln_ant + ((((-1)**(n+1))/n)*(x**n)) 
 err = ln - log(0.8) 
 print ("Valor com {} termos = {:.17f} || Erro = {}". format(n, ln, err)) 
 ln_ant = ln 
 n = n+1 
Exercício 3
Pelo Princípio de Arquimedes, temos que o peso do fluído deslocado é igual ao peso da parte submersa,
sabendo que temos a seguinte relação:P = V ∗ ρ
.=Vtrρtr Vwρw
Sabendo que o volume para um tronco de cone é dado por , substituiremos na
relação anterior e chegamos em:
V = ( + + )πh
3
r21 r
2
2 r1r2
Valor com 1.00000000000000000 termos = 0.0 
Valor com 2.00000000000000000 termos = 0.0 
Valor com 3.00000000000000000 termos = 0.0 
Valor com 4.00000000000000000 termos = 0.0 
Valor com 5.00000000000000000 termos = 0.0 
Valor com 6.00000000000000000 termos = 0.0 
Valor com 7.00000000000000000 termos = 0.0 
Valor com 8.00000000000000000 termos = 0.0 
Valor com 9.00000000000000000 termos = 0.0 
Valor com 10.00000000000000000 termos = 0.0 
Valor com 1 termos = -0.20000000000000001 || Erro = 0.023143551314209698 
Valor com 2 termos = -0.22000000000000003 || Erro = 0.0031435513142096805 
Valor com 3 termos = -0.22266666666666671 || Erro = 0.0004768846475430022 
Valor com 4 termos = -0.22306666666666672 || Erro = 7.688464754299074e-05 
( + + ) = ( + + )πh
3
r21 r
2
2 r1r2
πh
3
r22 r
2
3 r2r3
Utilizando semelhança de triângulos, temos que é o raio superior do tronco de cone submerso e é dado
por e também que . Substituindo essas informações na relação anterior,
deixamos tudo em função de . Os valores de , , , e já são conhecidos e inseridos
diretamente no código. Reorganizando, ficamos com a seguinte equação:
r3
= 0, 5 + 0, 5r3 h1 = 1 −h2 h1
h1 r1 r2 h ρw ρtr
(h − )( + + (( ( ) + ) )) − (h ( + + )) =ρw
ρtr
h1 ( ( ) + )h1
( − )r2 r1
h
r1
2
r22 h1
( − )r2 r1
h
r1 r2 r
2
1 r
2
2 r1r2
Método da Bisseção
O seguinte programa foi montado para encontrar a raíz da equação pelo método da bisseção. Foram usados
valores arbitrários e para iniciar o processo iterativo. Considerando um erro foi
encontrado que m
a = 0 b = 1 ε = 0.000001
= 0.8757777214050293h1
In [14]:
a = 0.0 
b = 1.0 
err = 10.0 
h_ant = 0.0 
h = 1.0 
r1 = 0.5 
r2 = 1.0 
ptr = 200.0 
pw = 1000.0 
def f(h1): 
 return (pw/ptr*(h-h1)*((h1*(r2-r1)/h+r1)**2+r2**2+(h1*(r2-r1)/h+r1)*r2)-h*(r1**2+r2
**2+r1*r2)) 
while (err>0.000001): 
 h1 = (a+b)/2 
 if (f(h1)*f(a) < 0): 
 b = h1 
 elif (f(h1)*f(a) > 0): 
 a = h1 
 
 err = abs(h1-h_ant)/abs(h1) 
 h_ant = h1 
 
 # print ("h1 = %.8f"%h1,"m | Erro absoluto = %.8f"% err) 
 print ("h1 = {:.16f} m || Erro absoluto = {}".format(h1,err)) 
Método das Secantes
Pelo método das secantes utilizamos e para iniciar o processo iterativo. Considerando um
erro foi encontrado que m.
a = 0.1 b = 1
ε = 0.000001 = 0.8757774553406681h1
h1 = 0.5000000000000000 m | Erro absoluto = 1.0 
h1 = 0.7500000000000000 m | Erro absoluto = 0.3333333333333333 
h1 = 0.8750000000000000 m | Erro absoluto = 0.14285714285714285 
h1 = 0.9375000000000000 m | Erro absoluto = 0.06666666666666667 
h1 = 0.9062500000000000 m | Erro absoluto = 0.034482758620689655 
h1 = 0.8906250000000000 m | Erro absoluto = 0.017543859649122806 
h1 = 0.8828125000000000 m | Erro absoluto = 0.008849557522123894 
h1 = 0.8789062500000000 m | Erro absoluto = 0.0044444444444444444 
h1 = 0.8769531250000000 m | Erro absoluto = 0.0022271714922048997 
h1 = 0.8759765625000000 m | Erro absoluto = 0.0011148272017837235 
h1 = 0.8754882812500000 m | Erro absoluto = 0.0005577244841048522 
h1 = 0.8757324218750000 m | Erro absoluto = 0.00027878449958182325 
h1 = 0.8758544921875000 m | Erro absoluto = 0.00013937282229965157 
h1 = 0.8757934570312500 m | Erro absoluto = 6.969126768415918e-05 
h1 = 0.8757629394531250 m | Erro absoluto = 3.484684810258912e-05 
h1 = 0.8757781982421875 m | Erro absoluto = 1.7423120480878125e-05 
h1 = 0.8757705688476562 m | Erro absoluto = 8.711636132382022e-06 
h1 = 0.8757743835449219 m | Erro absoluto = 4.355799093122629e-06 
h1 = 0.8757762908935547 m | Erro absoluto = 2.1778948033252097e-06 
h1 = 0.8757772445678711 m | Erro absoluto = 1.0889462158574526e-06 
h1 = 0.8757777214050293 m | Erro absoluto = 5.444728114779224e-07 
In [13]:
err = 10.0 
a = 0.1 
b = 1.0 
h = 1.0 
r1 = 0.5 
r2 = 1.0 
ptr = 200.0 
pw = 1000.0 
def f(h1): 
 return (pw/ptr*(h-h1)*((h1*(r2-r1)/h+r1)**2+r2**2+(h1*(r2-r1)/h+r1)*r2)-h*(r1**2+r2
**2+r1*r2)) 
while (err> 0.000001): 
 h1 = (a*f(b)-b*f(a))/(f(b)-f(a)) 
 
 err = abs(h1-b)/abs(h1) 
 
 a = b 
 b = h1 
 
 print ("h1 = {:.16f} m || Erro absoluto = {}".format(h1,err)) 
Exercício 4
Método do Ponto Fixo
Após substituir os valores fornecidos para e temos a equação . Como a função
depende do cosseno, haverão infinitar raizes, o código encontra apenas a primeira raiz positiva. Foi
montada uma estrutura de repetição para encontrar encontrar a raiz com erro . Utilizando o
método do ponto fixo, definimos uma função . Dentro do intervalo 
 a raiz converge para .
k w y(x) = 8 cos(3t)e−0.5t
ε = 0.0001
φ( ) =ti+1 8 cos(3 ) +ti e−0.5ti ti t
2
i
− −−−−−−−−−−−−−−−−
√
I = [0.5, 3] t = 0.5235867285136321
h1 = 0.8110661268556005 m | Erro absoluto = 0.2329450915141431 
h1 = 0.8715842884854528 m | Erro absoluto = 0.06943466332443224 
h1 = 0.8759257253003604 m | Erro absoluto = 0.004956398344641507 
h1 = 0.8757771234430501 m | Erro absoluto = 0.00016967999429584555 
h1 = 0.8757774553406681 m | Erro absoluto = 3.7897483649587e-07 
In [4]:
from math import e, cos, sin, sqrt 
t_ant = 0 
t = 0.5 
err = 100 
while (err > 0.001): 
 t = sqrt(t*(e**(-0.5*t))*cos(3*t) + (t**2)) 
 err = abs(t-t_ant)/abs(t) 
 t_ant = t 
 print(t) 
Método de Newton
Utilizando o método de Newton que possui processo iterativo , ou seja 
, e utilizando o mesmo intervalo usado no método anterior, a raiz
convergiu para .
φ( ) =ti ti
y( )ti
( )y ′ ti
φ( ) =ti ti
8 cos(3 )e−0.5ti ti
8(−0.5 cos(3 )−3 sin(3 ))e−0.5ti ti e
−0.5ti ti
t = 0.5238070926739486
0.5268254872588678 
0.5230930966833093 
0.5236767238598269 
0.5235867285136321 
In [7]:
from math import e, cos, sin 
t = 0.5 
t_ant = 3 
err = 10 
i =0 
while (err > 0.001): 
 t = t - (8*e**(0.5*t)*cos(3*t))/(8*((0.5*e**(0.5*t)*cos(3*t)) - (3*e*(0.5*t)*sin(3*
t)))) 
 err = abs(t-t_ant)/abs(t) 
 t_ant = t 
 i=i+1 
 print(i,t) 
Pode-se perceber que pelo método do ponto fixo, foram necessária apenas iterações para encontrar a raiz
com erro , enquanto que pelo método de Newton foram necessárias iterações, o que exige
um maior processamento.
4
ε = 0.001 25
Exercício 5
Inicialmente convertemos todos os valores fornecidos para metros para que a manipulação da equação
ficasse mais simples. Após substituir os valoresencontramos a derivada desta equação já que, segundo o
exercício, a deflexão máxima da viga se dá quando .= 0
dy
dx
= (−5) + 121.5 − 410.0625
dy
dx
t4 t2
1 0.5456839417680746 
2 0.507260160200553 
3 0.5382990658360312 
4 0.5123254395184768 
5 0.5334713012805768 
6 0.5158443602674111 
7 0.5302648012849571 
8 0.518278024758718 
9 0.5281148732006791 
10 0.5199546862436862 
11 0.5266649212776504 
12 0.5211063742281583 
13 0.5256834148922331 
14 0.5218957176708846 
15 0.5250174131381041 
16 0.5224358602935116 
17 0.5245647831855919 
18 0.5228050628813962 
19 0.5242568425199965 
20 0.5230572261404439 
21 0.5240471918769517 
22 0.5232293590791957 
23 0.5239043909325806 
24 0.5233468175427157 
25 0.5238070926739486 
Utilizando o método de newton, utilizamos o código abaixo para encontrar a raiz.
In [8]:
t = 4 
t_ant = 0 
for i in range (0,6,1): 
 t = t - (((-5)*t**4)+121.5*t**2 + (-410.0625))/(((-20)*t**3) + (243*t)) 
 err = abs(t-t_ant)/abs(t) 
 t_ant = t 
 print(t) 
4.824472402597403 
4.553546978757538 
4.501817871271201 
4.500002199254208 
4.500000000003225 
4.5