[JAVA] Genauigkeit der Berechnung des Umfangsverhältnisses nach der Monte-Carlo-Methode

Einführung

Die Monte-Carlo-Methode ist eine Methode zum Wiederholen von Versuchen unter Verwendung von Zufallszahlen. Es ist bekannt, dass es einen Weg gibt, das Umfangsverhältnis auf diese Weise zu finden, aber ... dachte ich plötzlich. ** Ist es wirklich genauer als die einfache Methode? ** ... Also lass uns tatsächlich experimentieren.

So finden Sie nach der Monte-Carlo-Methode

Stellen Sie sich ein 1 * 1-Quadrat vor und setzen Sie ein Viertel eines Kreises mit einem Radius von 1 ein. Verwenden Sie ** Zufallszahlen, um viele ** Punkte in diesem Quadrat zu erhalten. Sei * N * die Anzahl der platzierten Punkte. Wenn * N * groß genug ist, können Sie gleichmäßig punkten. Wenn von diesen Punkten die im Kreis enthaltenen Punkte als * A * gezählt werden, beträgt die Fläche des Quadrats 1 und die Fläche des Viertelkreises * π / 4 *.

• A * * / * * N * = * π * * / * * 4 *
• π * = * 4 * \ * * A * * / * * N *. Aufgrund der Natur von Pseudozufallszahlen weist diese Methode einen ziemlich großen Schwankungsbereich auf (theoretisch kann der Wert unabhängig von der Anzahl der Versuche nur zwischen 0 und 4 liegen), sodass sie dreimal ausgeführt wird, um Extremfälle zu verwerfen. Ich habe mich für den Medianwert entschieden. Aktueller Code:

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; //Anzahl von Versuchen
        double x,y;
        for (int i = 0; i < n; i++) {
            x = r.nextDouble();
            y = r.nextDouble();
            //Ist dieser Punkt im Kreis?(Ist der Abstand vom Ursprung zum Punkt 1 oder geringer?)
            if(x * x + y * y <= 1){
               cnt++; 
            }
        }
        System.out.println((double)cnt / (double)n * 4D);
    }
}

Wie man ein konkurrierendes Pferd findet

Stellen Sie sich ein 1 * 1-Quadrat vor und setzen Sie ein Viertel eines Kreises mit einem Radius von 1 ein. Machen Sie in diesem Quadrat viele ** gleichmäßig verteilte ** Punkte von Ende zu Ende. Sei * N * die Anzahl der platzierten Punkte. Wenn * N * groß genug ist, können Sie gleichmäßig punkten. (Auf einer Seite erscheinen Punkte mit nur der Quadratwurzel von * N *.) Wenn von diesen Punkten die im Kreis enthaltenen Punkte als * A * gezählt werden, beträgt die Fläche des Quadrats 1 und die Fläche des Viertelkreises * π / 4 *.

• A * * / * * N * = * π * * / * * 4 *
• π * = * 4 * \ * * A * * / * * N *. ~~ Wiederverwendung von Sätzen ~~ Aktueller Code:

Grid.java

public class Grid {
    public static void main(String[] args) {
        int cnt = 0;
        final int ns = 20000; //Quadratwurzel der Anzahl der Versuche
        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);
    }
}

Ergebnis

Ergebnisse der Monte-Carlo-Methode

Gesamtergebnis

Zusammenfassung

(In meiner Umgebung wurde der Computer von ungefähr 100000000 schwer.) Solange die Anzahl der Versuche gering ist, kann gesagt werden, dass die Monte-Carlo-Methode genauer ist. Die Zunahme der Genauigkeit hat jedoch begonnen, von etwa 100000000 abzunehmen, und kann man sagen, dass dies der Berg von Seki mit Pseudozufallszahlen ist?

abschließend

** Manchmal ist ein zufälliger Angriff besser als ein totaler Angriff! ** ** ** Es hängt von der Genauigkeit der verwendeten Pseudozufallszahl ab, aber es macht auch Spaß, Zufallszahlen zu verwenden. Es gibt jedoch Grenzen. Wenn Sie es also vollständig genau finden möchten, gibt es andere Methoden.