Meaningles drivel about random points in a circle (and Bertrands paradox)

[Piet Souris]

The other day I was watching one of those brilliant 3blue1brown-youtubies, where the man talked about Bertrands paradox. That paradox is about an equilateral triangle and its surrounding circle, and the question is: what is the chance that a random chord of this circle has lenght greater that the side of that triangle?

Bertrand (a French mathematician) gave a few very convincing ways to determine that chance, and in each case he got a different outcome.

For instance: method 1 was choosing a point on the circle, such that that point is also a vertex of the triangle. It is then easy to see that the chance is 1/3.

Method 2 involves taking a radius of the circle, such that that radius is perpendicular to one of the triangles sides. If we pick a random point on this radius and take the chord through this point that is perpendicular to the radius, then it is easy to see that the chance is 1/2.

Huh?

Reading Wikipedia (Dutch version) about this, it stated that that paradox is not a paradox at all, since it is not defined how one would choose a random chord. Now, the English version is a lot more detailed, as I noticed later, but that made me curious. What exactly was that difference between method one and method 2? After some thinking (at the cost of some nightrest) it occurred that in method 1 you can choose the second point freely: any point on the circle it just as likely as any other point. In method 2, however, choosing a random point on that radius, and looking at the corresponding point on the circle, we see that we do not get equal likely points on that circle! For points lying on the right half of the radius, the corresponding point on the circle will be on 2/3 of the quartercircle above, and for points on left half of the radius, we would get 1/3 of the quartercircle above. So, we do not get equal-likely points on the circle.

Pfff.

That gave me the idea of drawing random points within a given circle. Now, an obvious method is: choose a random length r from 0 to the radius, choose a random angle a between 0 and 2PI, and draw the point (r, a) (in polar coordinates). However, this gives a problem: if we divide the circle in two parts: circle A with half of the radius, and B being the rest of the circle, then half the points will end up in A, and half the points will end up in B. But B's surface is three times as large as A's surface, so A will look more dense than B. How can we choose a random length r such that we will get a uniform coverage of the circle? To get a uniform coverage, it seems that if we choose two radii r1 > r2, then the circle with r1 should get more points than the circle with r2, probably in the ratio of the circumference of both. So, a promising candidate for choosing a length r is having the distribution f(r) = alpha * r, for values between 0 and 1. And to get a proper distribution, it is easy to see that alpha should be 2.

So, to choose a length between 0 and 1, we use the distribution with cdf F(x) = x^2.
To get samples from such a distribution, we proceed as follows: draw the graph of F(x), and choose a point y with y = random.nextDouble(). Go from the point (0, y) horizontally until we intersect with the graph of F(x). For that point of intersection, we have that that point is (x, y) for some value of x, but it is also the point (x, F(x)), and since F(x) = x^2, we see that y = x^2, giving x = sqrt(y). In other words: we deterime some value y with y = random.nextDouble(), and take as length sqrt(y).

To see the outcome of all this, I made a little program that shows four circles, full of random points. The upper left shows points for which the length was determined with random.nextDouble, and upper right where the lengths are choosen from the distribution that I described above.

At the bottom, I repeated the process, albeit I now used a discrete version of the distribution above, with 10 different radii.
The discrete distribution for the bottom right is:

P[radius = i] = i / 55, for i = 1, ... 10.

And to answer your question: do you really have nothing better to do? Well, now I have, 'cause the mrs just ordered me to to the vacuum cleaning.

public class RandomPointsOnCircle {
    
    BufferedImage buf1, buf2, buf3, buf4;
    int radius = 200;
    Color background = Color.WHITE;
    Color foreground = Color.RED;
    int back = background.getRGB();
    int fore = foreground.getRGB();
    JPanel display;
    final JLabel label = new JLabel();
    Random random;
    int aantalLoops = 500;
    int aantalPuntenPerLoopContinu = 100;
    int aantalPuntenPerLoopDiscreet = 5;
    int nrOfRadii = 10;
    TreeMap<Integer, Integer> radiiTable;
    
    SwingWorker<Boolean, Void> sw;
        
    public static void main(String... args) {
        SwingUtilities.invokeLater(RandomPointsOnCircle::new);
    }
    
    RandomPointsOnCircle() {
        buf1 = new BufferedImage(radius * 2, radius * 2, BufferedImage.TYPE_INT_ARGB);
        buf2 = new BufferedImage(radius * 2, radius * 2, BufferedImage.TYPE_INT_ARGB);
        buf3 = new BufferedImage(radius * 2, radius * 2, BufferedImage.TYPE_INT_ARGB);
        buf4 = new BufferedImage(radius * 2, radius * 2, BufferedImage.TYPE_INT_ARGB);
        initieerBufs();
        initieerRadiiTable();

        random = new Random();
        
        display = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                g.drawImage(buf1, 25, 25, null);
                g.drawImage(buf2, radius * 2 + 50, 25, null);
                g.drawImage(buf3, 25, radius * 2 + 50, null);
                g.drawImage(buf4, radius * 2 + 50, radius * 2 + 50, null);
            }
            @Override
            public Dimension getPreferredSize() {
                return new Dimension(radius * 4 + 75, radius * 4 + 100);
            }
            @Override
            public Color getBackground() {
                return Color.YELLOW;
            }
        };
        
        var ml = new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent m) {
                processMouseclick(m);
            }
        };
        display.addMouseListener(ml);

        var f = new JFrame("random points on a circle");
        var c = f.getContentPane();
        c.add(label, BorderLayout.PAGE_START);
        c.add(display, BorderLayout.CENTER);
        f.pack();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
        
        sw = new Worker();
        sw.execute();
    }
    
    private void initieerRadiiTable() {
        radiiTable = new TreeMap<Integer, Integer>();
        var som = 0;
        for (int i = 0; i < nrOfRadii; i++) {
            som += i;
            radiiTable.put(som, (i + 1) * radius / nrOfRadii);
        }
    }
    
    private void processMouseclick(MouseEvent m) {
        sw.cancel(true);
        initieerBufs();
        sw = new Worker();
        sw.execute();
    }
    
    private void initieerBufs() {
        prepareBufIm(buf1, radius, background);
        prepareBufIm(buf2, radius, background);
        prepareBufIm(buf3, radius, background);
        prepareBufIm(buf4, radius, background);  
    }
    
    private static void prepareBufIm(BufferedImage buf, int radius, Color col) {
        var g = buf.getGraphics();
        g.setColor(col);
        g.fillRect(0, 0, radius * 2, radius * 2);
        g.dispose();
    }
    
    private class Worker extends SwingWorker<Boolean, Void> {
        
        @Override
        public Boolean doInBackground() {
            var g2dBuf3 = buf3.createGraphics();
            var g2dBuf4 = buf4.createGraphics();
            g2dBuf3.setColor(foreground);
            g2dBuf4.setColor(foreground);
            
            int randomMax = nrOfRadii * (nrOfRadii + 1) / 2;
            
            for (int aantal = 1; aantal <= aantalLoops; aantal++) {
                for (int i = 1; i <= aantalPuntenPerLoopContinu; i++ ) {
                    
                    var rad1 = random.nextDouble(radius);
                    var angle1 = random.nextDouble(PI * 2);
                    var p = Point.getPoint(rad1, angle1, radius);
                    buf1.setRGB(p.x(), p.y(), fore);
                    
                    var radhelp = sqrt(random.nextDouble());
                    var rad2 = (int) (radius * radhelp);
                    var angle2 = random.nextDouble(PI * 2);
                    p = Point.getPoint(rad2, angle2, radius);
                    buf2.setRGB(p.x(), p.y(), fore);
                }
                
                for (int i = 1; i <= aantalPuntenPerLoopDiscreet; i++) {
                    var rad3 = random.nextInt(nrOfRadii + 1) * radius / nrOfRadii;
                    var angle3 = random.nextDouble(PI * 2);
                    var p = Point.getPoint(rad3, angle3, radius);
                    g2dBuf3.fillOval(p.x() - 1, p.y() - 1, 3, 3);
//                    buf3.setRGB(p.x(), p.y(), fore);
                    
                    var rad4 = radiiTable.floorEntry(random.nextInt(randomMax)).getValue();
                    var angle4 = random.nextDouble(PI * 2);
                    p = Point.getPoint(rad4, angle4, radius);
                    g2dBuf4.fillOval(p.x() - 1, p.y() - 1, 3, 3);
//                    buf4.setRGB(p.x(), p.y(), fore);
                }
                
                label.setText("aantal punten: " + aantal * aantalPuntenPerLoopContinu + " (click to restart)");
                SwingUtilities.invokeLater(display::repaint);
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                }
                catch (InterruptedException e) {
                    System.out.println("interrupted");
                    return true;
                }
            }
            return true;
        }
    }
}

record Point(int x, int y) {
    public static Point getPoint(double radius, double angle, double correction) {
        var px = radius * cos(angle) + correction;
        var py = radius * sin(angle) + correction;
        return new Point((int) px, (int) py);
    }
}