Calculando o valor de Pi via método de Monte Carlo

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

• Cálculo Recursivo de Pi via Algoritmo de Gauss-Legendre (Java e C)
• Algoritmo de Gauss-Legendre iterativo para o cálculo de pi

Referências

• [1] WEISSTEIN, E. W. Monte Carlo Method. Acesso em 25 de setembro de 2018.