Java: calcola il valore di PI utilizzando Math Formulas-Part-1

Jan 08 2023

Ciao a tutti, prima di tutto, permettetemi di augurarvi un felice anno nuovo 2023. Che tu possa raggiungere tutti i tuoi obiettivi personali e professionali.

Ciao a tutti,

Prima di tutto, lascia che ti auguro un felice anno nuovo 2023. Che tu possa raggiungere tutti i tuoi obiettivi personali e professionali.

Oggi calcoleremo il valore di PI utilizzando diversi metodi in Java.

π (pronunciato "pi") è una costante matematica che rappresenta il rapporto tra la circonferenza di un cerchio e il suo diametro. È una costante fondamentale in matematica e ha molte importanti applicazioni in geometria, trigonometria e calcolo.

Il valore di π è approssimativamente uguale a 3,14159.

Tuttavia, è un numero irrazionale, il che significa che non può essere espresso esattamente come frazione. Di conseguenza, il valore di π viene solitamente approssimato a un certo numero di cifre decimali.

Il valore di π è noto e studiato da migliaia di anni e sono stati sviluppati molti metodi diversi per calcolarlo con elevata precisione. Alcuni famosi esempi di formule per calcolare il valore di π includono la formula Leibniz, il metodo Monte Carlo, la formula Bailey-Borwein-Plouffe e la formula Srinivasa Ramanujan, la formula Newotn ecc.

Nella matematica moderna, π è rappresentato dal simbolo "π" ed è spesso usato nelle formule per rappresentare il valore del rapporto tra la circonferenza di un cerchio e il suo diametro. Ad esempio, la formula per la circonferenza di un cerchio è data da:

C = 2 * π * r

dove Cè la circonferenza, πè il valore di π ed rè il raggio del cerchio.

Esistono diversi modi per calcolare il valore di PI in matematica.

In questo post, calcoleremo il valore di PI utilizzando diversi metodi in java. Questo sarà un post in 2 parti. Nella prima parte, calcoleremo PI utilizzando il metodo normale, la formula di Leibniz, il metodo Monte Carlo e la formula Bailey-Borwein-Plouffe (BBP) in Java.

Per calcolare il valore di π (pi greco) con un numero elevato di cifre decimali in Java, è possibile utilizzare la BigDecimalclasse e la MathContextclasse dal java.mathpacchetto.

Ecco un esempio di come puoi calcolare il valore di π fino a 100 cifre decimali:

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

Si noti che il valore di π calcolato utilizzando questo metodo è solo un'approssimazione, poiché il vero valore di π è un numero irrazionale che non può essere rappresentato esattamente come un decimale.

Puoi anche utilizzare altri metodi per calcolare il valore di π con un numero elevato di cifre decimali, come la formula di Leibniz o il metodo Monte Carlo.

Calcola il valore di π usando la formula di Leibniz

Per calcolare il valore di π utilizzando la formula di Leibniz in Java, è possibile utilizzare un ciclo per iterare sui termini della formula e utilizzare la BigDecimalclasse del java.mathpacchetto per memorizzare i risultati intermedi e finali con un elevato grado di precisione.

La formula di Leibniz per π è una serie infinita che può essere espressa come:

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

Ciascun termine della serie viene calcolato dividendo 4 per un numero intero dispari e aggiungendo o sottraendo il risultato in base alla parità del termine (pari o dispari). La somma dei termini della serie si avvicina al valore di π all'aumentare del numero di termini.

Ecco un esempio di come è possibile utilizzare la formula di Leibniz per calcolare il valore di π a 100 cifre decimali in 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);
  }
}

Si noti che la formula di Leibniz è solo uno dei tanti metodi per calcolare il valore di π con un gran numero di cifre decimali. Altri metodi includono il metodo Monte Carlo e la formula Bailey-Borwein-Plouffe.

Calcolare il valore di π utilizzando il metodo Monte Carlo

Per calcolare il valore di π con un numero elevato di cifre decimali utilizzando il metodo Monte Carlo in Java, è possibile utilizzare la Randomclasse del java.utilpacchetto per generare punti casuali all'interno di un quadrato unitario e contare il numero di punti che rientrano in un quarto di cerchio inscritto all'interno del quadrato. Il rapporto tra il numero di punti all'interno del quarto di cerchio e il numero totale di punti è un'approssimazione di π/4. Moltiplicando questo rapporto per 4, si ottiene un'approssimazione di π.

Ecco un esempio di come è possibile utilizzare il metodo Monte Carlo per calcolare il valore di π a 100 cifre decimali in 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);
   }
 }

Si noti che il metodo Monte Carlo è solo uno dei tanti metodi per calcolare il valore di π con un gran numero di cifre decimali. Altri metodi includono la formula Leibniz e la formula Bailey-Borwein-Plouffe.

Calcolare il valore di π con la formula Bailey–Borwein–Plouffe

Per calcolare il valore di π con un numero elevato di cifre decimali utilizzando la formula Bailey–Borwein–Plouffe (BBP) in Java, è possibile utilizzare la BigDecimalclasse del java.mathpacchetto per memorizzare i risultati intermedi e finali con un elevato grado di precisione.

La formula BBP per π è una serie infinita che può essere espressa come:

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

dove k è un numero intero positivo e la somma viene presa su tutti i valori di k. Ciascun termine della serie viene calcolato dividendo una serie di costanti per una potenza di 16 e sommando o sottraendo il risultato. La somma dei termini della serie si avvicina al valore di π all'aumentare del numero di termini.

Ecco un esempio di come è possibile utilizzare la formula BBP per calcolare il valore di π a 100 cifre decimali in 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);
   }
 }

Si noti che la formula BBP è solo uno dei tanti metodi per calcolare il valore di π con un gran numero di cifre decimali. Altri metodi includono la formula di Srinivasa Ramanujan , la formula di Newton , l'utilizzo della moltiplicazione di matrici, l'utilizzo (Fast Fourier Transform (FFT) ecc.

Speriamo che ti sia piaciuto questo post di conoscere PI con un po 'più da vicino con java. Questi sono solo alcuni modi in cui il PI può essere calcolato. PI è un concetto affascinante e misterioso che continua ad affascinare l'immaginazione di scienziati e non scienziati.

Il nostro prossimo post si concentrerà sul calcolo del valore di π Altri metodi come la formula di Srinivasa Ramanujan, la formula di Newton, utilizzando la moltiplicazione di matrici, utilizzando (Fast Fourier Transform (FFT) ecc.