[JAVA] Accuracy of pi calculation by Monte Carlo method

Introduction

The Monte Carlo method is a method of repeating trials using random numbers. It is well known that there is a way to find the pi in this way ... but I suddenly thought. ** Is it really more accurate than the straightforward method? ** ... So let's actually experiment.

How to find by Monte Carlo method

Imagine a 1 * 1 square, and put a quarter of a circle with a radius of 1 in it. Use ** random numbers to get a lot of ** points in this square. Let * N * be the number of points placed. If * N * is large enough, you can score evenly. Of these points, if the points contained in the circle are counted as * A *, the area of the square is 1 and the area of the 1/4 circle is * π / 4 *.

• A * * / * * N * = * π * * / * * 4 *
• π * = * 4 * \ * * A * * / * * N *. Due to the nature of pseudo-random numbers, this method has a fairly large fluctuation range (theoretically, no matter how many attempts are made, the value can only be between 0 and 4), so it is performed three times to discard extreme cases. I decided to take the median. Actual 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; //Number of trials
        double x,y;
        for (int i = 0; i < n; i++) {
            x = r.nextDouble();
            y = r.nextDouble();
            //Is this point in the circle?(Is the distance from the origin to the point 1 or less?)
            if(x * x + y * y <= 1){
               cnt++; 
            }
        }
        System.out.println((double)cnt / (double)n * 4D);
    }
}

How to find a rival horse

Imagine a 1 * 1 square, and put a quarter of a circle with a radius of 1 in it. Make a lot of ** evenly spaced ** points from end to end in this square. Let * N * be the number of points placed. If * N * is large enough, you can score evenly. (Around one side, points with only the square root of * N * will appear.) Of these points, if the points contained in the circle are counted as * A *, the area of the square is 1 and the area of the 1/4 circle is * π / 4 *.

• A * * / * * N * = * π * * / * * 4 *
• π * = * 4 * \ * * A * * / * * N *. ~~ Reuse of sentences ~~ Actual code:

Grid.java

public class Grid {
    public static void main(String[] args) {
        int cnt = 0;
        final int ns = 20000; //Square root of number of trials
        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);
    }
}

result

Results of the Monte Carlo method

Overall result

Summary

(In my environment, the computer became heavy from around 100000000.) As long as the number of trials is small, it can be said that the Monte Carlo method is more accurate. However, the increase in accuracy has begun to decline from around 100000000, and can this be said to be a mountain of seki with pseudo-random numbers?

in conclusion

** Sometimes a random attack is better than a total attack! ** ** It depends on the accuracy of the pseudo-random numbers used, but using random numbers is also fun. However, there are limits, so if you want to find it completely accurately, there are other methods.