Java: Calcular o valor do PI usando fórmulas matemáticas-Parte-1

Jan 08 2023

Olá a todos, em primeiro lugar, desejo-lhes um feliz ano novo de 2023. Que você alcance todos os seus objetivos pessoais e profissionais.

Olá a todos,

Em primeiro lugar, desejo-lhe um feliz ano novo de 2023. Que você alcance todos os seus objetivos pessoais e profissionais.

Hoje, calcularemos o valor do PI usando diferentes métodos em Java.

π (pronuncia-se “pi”) é uma constante matemática que representa a razão entre a circunferência de um círculo e seu diâmetro. É uma constante fundamental em matemática e tem muitas aplicações importantes em geometria, trigonometria e cálculo.

O valor de π é aproximadamente igual a 3,14159.

No entanto, é um número irracional, o que significa que não pode ser expresso exatamente como uma fração. Como resultado, o valor de π é geralmente aproximado a um certo número de casas decimais.

O valor de π é conhecido e estudado há milhares de anos, e muitos métodos diferentes foram desenvolvidos para calculá-lo com alta precisão. Alguns exemplos famosos de fórmulas para calcular o valor de π incluem a fórmula de Leibniz, o método de Monte Carlo, a fórmula de Bailey-Borwein-Plouffe e a fórmula de Srinivasa Ramanujan, a fórmula de Newotn, etc.

Na Matemática Moderna, π é representado pelo símbolo “π” e é freqüentemente usado em fórmulas para representar o valor da razão entre a circunferência de um círculo e seu diâmetro. Por exemplo, a fórmula para a circunferência de um círculo é dada por:

C = 2 * π * r

onde Cé a circunferência, πé o valor de π e ré o raio do círculo.

Existem várias maneiras de calcular o valor do PI em matemática.

Nesta postagem, calcularemos o valor do PI usando diferentes métodos em java. Este será um post de 2 partes. Na primeira parte, calcularemos o PI usando o método Normal, a Fórmula de Leibniz, o método de Monte Carlo e a fórmula de Bailey–Borwein–Plouffe (BBP) em Java.

Para calcular o valor de π (pi) para um grande número de casas decimais em Java, você pode usar a BigDecimalclasse e a MathContextclasse do java.mathpacote.

Aqui está um exemplo de como você pode calcular o valor de π até 100 casas decimais:

package com.grp.connect.math.pi;

import java.math.BigDecimal;
import java.math.MathContext;

public class PICalculator1 {
  public static void main(String[] args) {
    // Set the precision to 100 decimal places
    MathContext mc = new MathContext(100);

    // Use the value of PI from the Math class as a starting point
    BigDecimal pi = new BigDecimal(Math.PI, mc);

    // Print the value of PI up to 100 decimal places
    System.out.println(pi);
  }
}

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679

Observe que o valor de π calculado usando esse método é apenas uma aproximação, pois o valor verdadeiro de π é um número irracional que não pode ser representado exatamente como um decimal.

Você também pode usar outros métodos para calcular o valor de π com um grande número de casas decimais, como a fórmula de Leibniz ou o método de Monte Carlo.

Calcule o valor de π usando a fórmula de Leibniz

Para calcular o valor de π usando a fórmula de Leibniz em Java, você pode usar um loop para iterar os termos da fórmula e usar a BigDecimalclasse do java.mathpacote para armazenar os resultados intermediários e finais com alto grau de precisão.

A fórmula de Leibniz para π é uma série infinita que pode ser expressa como:

π = 4/1–4/3 + 4/5–4/7 + 4/9–4/11 + …

Cada termo da série é calculado dividindo 4 por um número inteiro ímpar e adicionando ou subtraindo o resultado com base na paridade do termo (ímpar ou par). A soma dos termos da série se aproxima do valor de π conforme o número de termos aumenta.

Aqui está um exemplo de como você pode usar a fórmula de Leibniz para calcular o valor de π com 100 casas decimais em Java:

package com.grp.connect.math.pi;

import java.math.BigDecimal;
import java.math.MathContext;

public class PICalculator2 {
  public static void main(String[] args) {
    // Set the precision to 100 decimal places
    MathContext mc = new MathContext(100);

    // Initialize the sum to 0
    BigDecimal sum = new BigDecimal(0, mc);

    // Set the number of terms to calculate
    int n = 10000;

    // Loop over the terms of the series
    for (int i = 1; i <= n; i++) {
      // Calculate the current term of the series
      BigDecimal term = new BigDecimal(4, mc).divide(new BigDecimal(2 * i - 1, mc), mc);

      // Add or subtract the term based on the parity
      if (i % 2 == 0) {
        sum = sum.subtract(term, mc);
      } else {
        sum = sum.add(term, mc);
      }
    }

    // Print the value of PI to 100 decimal places
    System.out.println(sum);
  }
}

Observe que a fórmula de Leibniz é apenas um dos muitos métodos para calcular o valor de π com um grande número de casas decimais. Outros métodos incluem o método de Monte Carlo e a fórmula de Bailey-Borwein-Plouffe.

Para calcular o valor de π usando o método de Monte Carlo

Para calcular o valor de π com um grande número de casas decimais usando o método Monte Carlo em Java, você pode usar a Randomclasse do java.utilpacote para gerar pontos aleatórios dentro de um quadrado unitário e contar o número de pontos que caem dentro de um quarto de círculo inscrito no quadrado. A razão entre o número de pontos dentro do quarto de círculo e o número total de pontos é uma aproximação de π/4. Multiplicando essa razão por 4, você pode obter uma aproximação de π.

Aqui está um exemplo de como você pode usar o método de Monte Carlo para calcular o valor de π com 100 casas decimais em Java:

package com.grp.connect.math.pi;

 import java.math.BigDecimal;
 import java.math.MathContext;
 import java.util.Random;

 public class PICalculator3 {
   public static void main(String[] args) {
     // Set the precision to 100 decimal places
     MathContext mc = new MathContext(100);

     // Set the number of points to generate
     int n = 1000000;

     // Create a random number generator
     Random rng = new Random();

     // Initialize the counters for points inside and outside the quarter-circle
     int inside = 0;
     int outside = 0;

     // Generate the points and count them
     for (int i = 0; i < n; i++) {
       // Generate a random point within the unit square
       double x = rng.nextDouble();
       double y = rng.nextDouble();

       // Check if the point is inside the quarter-circle
       if (x * x + y * y < 1) {
         inside++;
       } else {
         outside++;
       }
     }

     // Calculate the ratio of points inside the quarter-circle to the total number of points
     BigDecimal ratio = new BigDecimal(inside, mc).divide(new BigDecimal(n, mc), mc);

     // Multiply the ratio by 4 to obtain an approximation of PI
     BigDecimal pi = ratio.multiply(new BigDecimal(4, mc), mc);

     // Print the value of PI to 100 decimal places
     System.out.println(pi);
   }
 }

Observe que o método de Monte Carlo é apenas um dos muitos métodos para calcular o valor de π com um grande número de casas decimais. Outros métodos incluem a fórmula de Leibniz e a fórmula de Bailey-Borwein-Plouffe.

Calcule o valor de π com a fórmula de Bailey–Borwein–Plouffe

Para calcular o valor de π com um grande número de casas decimais usando a fórmula Bailey–Borwein–Plouffe (BBP) em Java, você pode usar a BigDecimalclasse do java.mathpacote para armazenar os resultados intermediários e finais com alto grau de precisão.

A fórmula BBP para π é uma série infinita que pode ser expressa como:

π = ∑[4/(8k + 1) — 2/(8k + 4) — 1/(8k + 5) — 1/(8k + 6)]

onde k é um inteiro positivo e a soma é feita sobre todos os valores de k. Cada termo da série é calculado dividindo uma série de constantes por uma potência de 16 e somando ou subtraindo o resultado. A soma dos termos da série se aproxima do valor de π conforme o número de termos aumenta.

Aqui está um exemplo de como você pode usar a fórmula BBP para calcular o valor de π para 100 casas decimais em Java:

package com.grp.connect.math.pi;

 import java.math.BigDecimal;
 import java.math.MathContext;

 public class PICalculator4 {
   public static void main(String[] args) {
     // Set the precision to 100 decimal places
     MathContext mc = new MathContext(100);

     // Initialize the sum to 0
     BigDecimal sum = new BigDecimal(0, mc);

     // Set the number of terms to calculate
     int n = 100;

     // Loop over the terms of the series
     for (int k = 0; k < n; k++) {
       // Calculate the current term of the series
       BigDecimal term1 = new BigDecimal(4, mc).divide(new BigDecimal(8 * k + 1, mc), mc);
       BigDecimal term2 = new BigDecimal(2, mc).divide(new BigDecimal(8 * k + 4, mc), mc);
       BigDecimal term3 = new BigDecimal(1, mc).divide(new BigDecimal(8 * k + 5, mc), mc);
       BigDecimal term4 = new BigDecimal(1, mc).divide(new BigDecimal(8 * k + 6, mc), mc);
       BigDecimal term = term1.subtract(term2, mc).subtract(term3, mc).subtract(term4, mc);

       // Add the term to the sum
       sum = sum.add(term, mc);
     }

     // Print the value of PI to 100 decimal places
     System.out.println(sum);
   }
 }

Observe que a fórmula BBP é apenas um dos muitos métodos para calcular o valor de π com um grande número de casas decimais. Outros métodos incluem a fórmula de Srinivasa Ramanujan, a fórmula de Newton, usando a multiplicação de matrizes, usando (transformada rápida de Fourier (FFT) etc.

Esperamos que você tenha gostado deste post de conhecer o PI um pouco mais de perto com o java. Estas são apenas algumas maneiras pelas quais o PI pode ser calculado. PI é um conceito fascinante e misterioso que continua a cativar a imaginação de cientistas e não cientistas.

Nosso próximo post se concentrará no cálculo do valor de π Outros métodos como a fórmula de Srinivasa Ramanujan, a fórmula de Newton, usando a multiplicação de matrizes, usando (transformada rápida de Fourier (FFT) etc.