Cálculo Numérico- UFABC
Sequencias que possuem um limite qualquer recebem o nome de convergentes. Se tomarmos a seguinte sequencia (5,5,5,5,5..), podemos afirmar que ela converge à 5. Em uma outra sucessão, onde os números ficam cada vez menores, se aproximando de zero, ocorre a convergência para o zero.
Na ausência de um limite da soma da série (seja ele um número real ou até mesmo complexo), tem-se uma sucessão divergente. Em muitos casos, a divergência ocorre quando a sequência assume valores cada vez maiores, que tendem ao infinito. No caso do exercício propriamente dito, após um determinado n utilizado, ocorre algo um pouco distinto: a sequencia apresenta resultados alternados, e é impossível o estabelecimento de um limite.
É interessante ressaltar que, o fato dos resultados serem alternados, não garante divergência. Se a sequencia dos valores absolutos convergir para zero, então uma sequencia com sinal alternada será convergente. Esse no entanto, não é o caso do exercício resolvido, já que os números ficam cada vez mais afastados do zero ( sejam eles positivos ou negativos ).
O programa utilizado para a realização do código foi o Scilab.
A sucessão apresentada pelo exercício teoricamente deveria convergir para zero à medida em que n aumenta. No entanto isso não pode ser constatado, como mostraremos a seguir.
O resultado é condizente com a teoria até valores de n=17,. A partir desse valor, ela apresenta comportamento inadequado.
Abaixo, temos o código utilizado, e os resultados até n=17.
Aqui, numa segunda formação do código, colocamos o valor de n até 80. Fica claro o resultado inesperado, com resultados de sinais alternados, e que se afastam cada vez mais do zero. Como são muitos valores de retorno, utilizaremos apenas resultados até n=80. No entanto, os testes realizados com valores superiores apresentaram o mesmo comportamento alternado.
Resultado obtido com o código (apenas análise dos resultados): a sucessão diverge (com sinais alternados) à medida que
o valor de n aumenta.
Esse resultado divergente, como ja foi comentado acima não é o esperado. Primeiramente, a função apresenta comportamento convergente, até n=17, e depois se torna divergente. Isso mostra que ocorreu algum erro no cálculo realizado pela máquiona, e que esse erro, foi se acumulando, até que se tornou muito grande, com grandes saltos e variação de valores( erro exponencial).
Esse erro acumulado, deve-se ao fato de que o primeiro valor da sequencia apresenta uma conta com um úmero irracional, que é arredondado pela máquina quando se torna um ponto flutuante.
O cálculo de π pelo modelo referido no enunciado é chamado de Método de Monte Carlo (MC). Criado pelos matemáticos John Neumann e Stainslaw Ulam. O nome foi dado por Ulam em homenagem ao seu tio, frequentador dos cassinos de Monte Carlo famosos por seus jogos que dependem de fatores aleatórios, como por exemplo, a roleta.
O método permite simular processos que dependam de fatores aleatórios ou problemas matemáticos que não dependam desses fatores a partir de uma adequação do modelo.
Para calcular uma aproximação bastante precisa de π pelo Método Monte Carlo deve-se considerar um círculo trigonométrico centrado na origem, inscrito em um quadrado de lado igual a dois, que consequentemente, também está centrado na origem; distribuir aleatoriamente pontos cujas coordenadas estejam dentro do quadrado e caso o ponto esteja também inscrito no círculo, ele é considerado, caso contrário, é excluído da conta.
A razão entre o número total de pontos que está dentro do círculo e o quádruplo da quantidade de pontos distribuídos é aproximadamente igual a π. Desde que seja distribuído um número de pontos suficientemente grande.
O código se baseia na comparação das distâncias dos pontos distribuídos – por isso é crucial que tanto o círculo quanto o quadrado estejam centrados na origem.
Usamos o Programa Matlab para a elaboração do mesmo.
function calcpi = pimmc(n)
format long
for n = 1000:1000:100000 esse valor pode ser alterado, vai depender
x = rand(n,1); % de quão rápida é a máquina (inicial:passo:final)
y = rand(n,1);
z = x.^2+y.^2;
v = (z <= 1);
m = sum(v);
calcpi = 4*m/n
EA = abs(pi - calcpi) %calcula os erros para cada valor de n
ER = EA/abs(pi) %e de pi calculado
hold on;
plot(n,calcpi,'r.'); %gráfico de n x valor de pi calculado em vermelho
plot(n,EA,'b.'); %gráfico de n x erro absoluto em azul
plot(n,ER,'g.'); %gráfico de n x erro relativo em verde
legend('n x Valor calculado de pi','n x Erro absoluto','n x Erro relativo');
grid on;
end
RESULTADO:
Para o último valor de pi calculado, ou seja, para n = 100000, obtivemos:
>>
calcpi =
3.144320000000000
EA =
0.002727346410207
ER =
8.681413254167246e-04
ans =
3.144320000000000
Para este problema, implementou-se o seguinte cógico m Scilab:
format (25);
pi=0;
for m=0:11
pi=pi+([(4/(8*m+1))-(2/(8*m+4))-(1/(8*m+5))-(1/(8*m+6))]*16^-m)
u=(%pi/pi);
if u==1
disp(m,pi)
end
end
disp("pi="+string(%pi)+"")
disp ("compare resultado--> %pi/pi = "+string(u)+"")
Que retorna o seguinte resultado na console:
-1->exec('C:\Users\Montagnini\Documents\SCILAB\Exercício 3 - lista 2.sce', -1)
3.1415926535897931159980
10.
3.1415926535897931159980
11.
pi=3.1415926535897931159980
compare resultado--> %pi/pi = 1
O código foi implementado de modo a obter os seguintes resultados:
*format (25) na primeira linha para obter um número com o maior número de casas decimais permitido pelo SCILAB.
*cria-se a variável u = %pi ( o pi da memória do programa) / pi (calculado pelo método numérico) na quinta linha.
*Define-se a condição u=1, para que saibamos quando o valor de pi calculado seja igual ao valor de pi da máquina, na sexta linha.
* Por fim, o programa mostra o número da m-ésima iteração, e o correspondente valor de pi calculado, na sétima linha.
*Após o término dos laços, o programa mostra o valor de pi da máquina (%pi), e em seguida exibe a frase: “compare resultado à %pi/pi = “, e o valor do resultado após o sinal de igual.
Fazendo o programa rodar com diversos valores de m, observa-se que na décima iteração o programa já atinge um valor de pi com a mesma precisão da máquina, com valores repetidos para maiores valores de m.