[JAVA] Précision du calcul du ratio de circonférence par la méthode de Monte Carlo

introduction

La méthode de Monte Carlo est une méthode de répétition d'essais utilisant des nombres aléatoires. Il est bien connu qu'il existe un moyen de trouver le rapport de circonférence de cette manière, mais ... j'ai soudain pensé. ** Est-ce vraiment plus précis que la méthode simple? ** ... Alors expérimentons réellement.

Comment trouver par la méthode Monte Carlo

Imaginez un carré 1 * 1, et mettez un quart de cercle avec un rayon de 1 dedans. Utilisez ** des nombres aléatoires pour obtenir beaucoup ** de points dans ce carré. Soit * N * le nombre de points placés. Si * N * est suffisamment grand, vous pouvez marquer uniformément. Parmi ces points, si les points contenus dans le cercle sont comptés comme * A *, l'aire du carré est 1 et l'aire du quart de cercle est * π / 4 *.

• A * * / * * N * = * π * * / * * 4 *
• π * = * 4 * \ * * A * * / * * N *. En raison de la nature des nombres pseudo-aléatoires, cette méthode a une plage de fluctuation assez grande (en théorie, quel que soit le nombre de tentatives effectuées, la valeur ne peut être comprise que entre 0-4), elle est donc effectuée trois fois pour écarter les cas extrêmes. J'ai décidé de prendre la valeur médiane. Code réel:

Monte.java

import java.util.Random;

public class Monte {
    public static void main(String[] args) {
        for (int i = 0; i < 3 ; i++) {
            monte();
        }
    }
    public static void monte() {
        Random r = new Random(System.currentTimeMillis());
        int cnt = 0;
        final int n = 400000000; //Nombre d'essais
        double x,y;
        for (int i = 0; i < n; i++) {
            x = r.nextDouble();
            y = r.nextDouble();
            //Ce point est-il dans le cercle?(La distance entre l'origine et le point est-elle inférieure ou égale à 1?)
            if(x * x + y * y <= 1){
               cnt++; 
            }
        }
        System.out.println((double)cnt / (double)n * 4D);
    }
}

Comment trouver un cheval rival

Imaginez un carré 1 * 1, et mettez un quart de cercle avec un rayon de 1 dedans. Faites beaucoup de points ** régulièrement espacés ** d'un bout à l'autre de ce carré. Soit * N * le nombre de points placés. Si * N * est suffisamment grand, vous pouvez marquer uniformément. (Autour d'un côté, des points avec seulement la racine carrée de * N * apparaîtront.) Parmi ces points, si les points contenus dans le cercle sont comptés comme * A *, l'aire du carré est 1 et l'aire du quart de cercle est * π / 4 *.

• A * * / * * N * = * π * * / * * 4 *
• π * = * 4 * \ * * A * * / * * N *. ~~ Réutilisation des phrases ~~ Code réel:

Grid.java

public class Grid {
    public static void main(String[] args) {
        int cnt = 0;
        final int ns = 20000; //Racine carrée du nombre d'essais
        for (double x = 0; x < ns; x++) {
            for (double y = 0; y < ns; y++) {
                if(x / (double)(ns - 1) * x / (double)(ns - 1) +
                    y / (double)(ns - 1) * y / (double)(ns - 1) <= 1D){
                    cnt++; 
                }
            }
        }
        System.out.println((double)cnt / ((double)ns * (double)ns) * 4D);
    }
}

résultat

Résultats de la méthode de Monte Carlo

Résultat global

Résumé

(Dans mon environnement, l'ordinateur est devenu lourd à partir d'environ 100000000.) Tant que le nombre d'essais est petit, on peut dire que la méthode de Monte Carlo est plus précise. Cependant, l'augmentation de la précision a commencé à diminuer d'environ 100000000, et peut-on dire que c'est la montagne de Seki avec des nombres pseudo-aléatoires?

en conclusion

** Parfois, une attaque aléatoire vaut mieux qu'une attaque totale! ** ** Cela dépend de la précision du nombre pseudo aléatoire utilisé, mais il est également amusant d'utiliser des nombres aléatoires. Cependant, il y a des limites, donc si vous voulez le trouver de manière complètement précise, il existe d'autres méthodes.