Ao longo dos séculos, os Matemáticos criaram vários métodos para computar o valor da constante π.
Neste artigo, conheceremos um deles, o qual consiste em utilizar a fórmula da área do círculo em conjunto com o método de Monte Carlo.
Isso significa que utilizaremos uma amostragem de números aleatórios para realizar o cálculo.
O método apresentado está codificado nas linguagens Java e JavaScript.
Antes de começar, sempre que eu utilizar a sentença "dentro da circunferência", eu estarei me referindo à área delimitada pela circunferência.
A área da circunferência de raio unitário
Aprendemos no ensino fundamental (ou pelo menos deveríamos), que a área da circunferência de raio $r$ é
$$A=\pi r^2$$
Quando o raio é unitário, isto é, quando $r=1$, a área é igual ao valor da constante $\pi$
$$A(r=1)=\pi$$
Portanto, se sabemos calcular a área dessa circunferência, então sabemos calcular o valor de $\pi$.
Mas como faremos isso?
O método de Monte de Carlo
Método de Monte Carlo é um termo utilizado para se referir a qualquer método que resolve um problema gerando números aleatórios e observando se uma dada fração desses números satisfaz uma propriedade previamente estabelecida [1].
Para calcular a área da circunferência unitária, utilizaremos o método de integração de Monte Carlo. A ideia é colocar a circunferência dentro de uma figura, cuja área seja fácil de calcular, e sortear pontos aleatórios dentro da figura. Utilizaremos um quadrado.
Se o ponto sorteado estiver dentro da circunferência, então marcamos um acerto. Ao final dos sorteios, espera-se que a área da circunferência seja proporcional à taxa de acertos e à área do quadrado. Esse valor será uma aproximação para $\pi$.
"Espera-se" porque o método é estocástico, isto é, os resultados obtidos são aleatórios. Porém, para uma grande amostra de pontos, ele deve convergir para o resultado esperado, ou seja, $\pi$.
A taxa de acertos é a razão entre o número de acertos e o total de sorteios realizados. Este valor pode ser visto como uma aproximação da probabilidade de sortear um ponto e ele estar dentro da circunferência.
A probabilidade exata é igual a razão entre a área da circunferência e a área do quadrado
$$P=\frac{A_{\text{circ}}}{A_{\text{quad}}}$$
Onde $P$ é a probabilidade do ponto estar dentro da circunferência, $A_{\text{circ}}$ é a área da circunferência e $A_{\text{quad}}$ é a área do quadrado. Na circunferência unitária, temos $A_{\text{circ}}=\pi$, que implica em
$$\begin{gather*}P=\frac{\pi}{A_{\text{quad}}}\\\pi = P. A_{\text{quad}}\end{gather*}$$
Suponha que sorteamos $N$ pontos e que $N_{\text{acertos}}$ é o número de acertos, onde $N_{\text{acertos}}\leq N$. Então, $P$ será aproximadamente igual a $\cfrac{N_{\text{acertos}}}{N}$, portanto o valor aproximado de $\pi$ é dado por
$$\pi\approx \cfrac{N_{\text{acertos}}}{N}.A_{\text{quad}}$$
Quanto maior o número de sorteios, melhor será a aproximação.
Como verificar se um ponto está dentro da circunferência?
Por simplicidade, vamos utilizar a circunferência unitária com centro na origem, definida pela equação
$$x^2+y^2=1$$
Dado um ponto $(x,y)$, se o ponto está dentro da circunferência, então ele deve satisfazer a seguinte condição
$$x^2+y^2<1$$
Modelando a solução do problema
Para os cálculos, escolheremos um quadrado de lado 2 circunscrito na circunferência de raio 1.
No entanto, ao invés de utilizarmos as figuras completas, utilizaremos apenas a parte delas situada no primeiro quadrante. Em outras palavras, teremos 1/4 de circunferência dentro de um quadrado de lado 1.
Ou seja, ao invés de estimarmos $\pi$, estimaremos $\pi/4$. Depois é só multiplicar a aproximação por quatro para obter $\pi$.
Faremos isso por pura conveniência, pois normalmente as linguagens de programação oferecem métodos/funções que calculam números reais aleatórios entre 0 e 1 (na verdade, pseudoaleatórios).
O algoritmo em pseudocódigo é
01. monteCarloPi(n) 02. | acertos ← 0 03. | para i ← 0 até n 04. | | x ← sorteie um número real entre 0 e 1 05. | | y ← sorteie um número real entre 0 e 1 06. | | se(x * x + y * y < 1) 07. | | | acertos ← acertos + 1 08. | | fim_se 09. | fim_para 10. | retorne 4 * acertos / n 11. fim_monteCarloPi
Códigos
Os códigos a seguir implementam o pseudocódigo anterior.
Códgo em Java
/* * Código por Henrique Felipe * https://www.blogcyberini.com/ */ public class MonteCarloPi { /* * Calcula pi, utilizando o método de Monte Carlo. * * n é o número de pontos que serão sorteados no cálculo */ public static double pi(int n){ int acertos = 0; for(int i = 0; i < n; i++){ double x = Math.random(); double y = Math.random(); if(x * x + y * y < 1.0){ acertos++; } } return (double) (4.0 * acertos / n); } }
Código em JavaScript
/* * Calcula pi, utilizando o método de Monte Carlo. * * n é o número de pontos que serão sorteados no cálculo */ function pi(n){ var acertos = 0; var i; for(i = 0; i < n; i++){ var x = Math.random(); var y = Math.random(); if(x * x + y * y < 1){ acertos++; } } return 4.0 * acertos / n; }
Testes
A lista a seguir contém alguns exemplos de valores aproximados de π calculados utilizando a versão em Java dos códigos anteriores.
Pi (N = 4550000): 3,1420114285714287 (erro = 0,0133 %) Pi (N = 4600000): 3,1410617391304347 (erro = 0,0169 %) Pi (N = 4650000): 3,1411483870967740 (erro = 0,0141 %) Pi (N = 4700000): 3,1411310638297874 (erro = 0,0147 %) Pi (N = 4750000): 3,1431376842105263 (erro = 0,0492 %) Pi (N = 4800000): 3,1417941666666667 (erro = 0,0064 %) Pi (N = 4850000): 3,1421129896907220 (erro = 0,0166 %) Pi (N = 4900000): 3,1409257142857143 (erro = 0,0212 %) Pi (N = 4950000): 3,1430197979797980 (erro = 0,0454 %) Pi (N = 5000000): 3,1411624000000000 (erro = 0,0137 %)
Leia também
Referências
- [1] WEISSTEIN, E. W. Monte Carlo Method. Acesso em 25 de setembro de 2018.
Nenhum comentário:
Postar um comentário