java蒙特卡洛算法求PI值（可视化）及三门问题

╰+哭是因爲堅強的太久メ 2022-05-24 02:29 176阅读 0赞

# 蒙特卡洛算法求PI值 #

## 工具类 ##

package com.egeo.jframetext;
    
    import java.awt.BasicStroke;
    import java.awt.Color;
    import java.awt.FontMetrics;
    import java.awt.Graphics2D;
    import java.awt.Image;
    import java.awt.geom.Ellipse2D;
    import java.awt.geom.Rectangle2D;
    
    import javax.swing.ImageIcon;
    
    
    public class AlgoVisHelper { 
    
        private AlgoVisHelper(){}
    
        public static final Color Red = new Color(0xF44336);
        public static final Color Pink = new Color(0xE91E63);
        public static final Color Purple = new Color(0x9C27B0);
        public static final Color DeepPurple = new Color(0x673AB7);
        public static final Color Indigo = new Color(0x3F51B5);
        public static final Color Blue = new Color(0x2196F3);
        public static final Color LightBlue = new Color(0x03A9F4);
        public static final Color Cyan = new Color(0x00BCD4);
        public static final Color Teal = new Color(0x009688);
        public static final Color Green = new Color(0x4CAF50);
        public static final Color LightGreen = new Color(0x8BC34A);
        public static final Color Lime = new Color(0xCDDC39);
        public static final Color Yellow = new Color(0xFFEB3B);
        public static final Color Amber = new Color(0xFFC107);
        public static final Color Orange = new Color(0xFF9800);
        public static final Color DeepOrange = new Color(0xFF5722);
        public static final Color Brown = new Color(0x795548);
        public static final Color Grey = new Color(0x9E9E9E);
        public static final Color BlueGrey = new Color(0x607D8B);
        public static final Color Black = new Color(0x000000);
        public static final Color White = new Color(0xFFFFFF);
    
    
        public static void strokeCircle(Graphics2D g, int x, int y, int r){
    
            Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
            g.draw(circle);
        }
    
        public static void fillCircle(Graphics2D g, int x, int y, int r){
    
            Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
            g.fill(circle);
        }
    
        public static void strokeRectangle(Graphics2D g, int x, int y, int w, int h){
    
            Rectangle2D rectangle = new Rectangle2D.Double(x, y, w, h);
            g.draw(rectangle);
        }
    
        public static void fillRectangle(Graphics2D g, int x, int y, int w, int h){
    
            Rectangle2D rectangle = new Rectangle2D.Double(x, y, w, h);
            g.fill(rectangle);
        }
    
        public static void setColor(Graphics2D g, Color color){
            g.setColor(color);
        }
    
        public static void setStrokeWidth(Graphics2D g, int w){
            int strokeWidth = w;
            g.setStroke(new BasicStroke(strokeWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        }
    
        public static void pause(int t) {
            try {
                Thread.sleep(t);
            }
            catch (InterruptedException e) {
                System.out.println("Error sleeping");
            }
        }
    
        public static void putImage(Graphics2D g, int x, int y, String imageURL){
    
            ImageIcon icon = new ImageIcon(imageURL);
            Image image = icon.getImage();
    
            g.drawImage(image, x, y, null);
        }
    
        public static void drawText(Graphics2D g, String text, int centerx, int centery){
    
            if(text == null)
                throw new IllegalArgumentException("Text is null in drawText function!");
    
            FontMetrics metrics = g.getFontMetrics();
            int w = metrics.stringWidth(text);
            int h = metrics.getDescent();
            g.drawString(text, centerx - w/2, centery + h);
        }
    
    }

## 视图层 ##

package com.egeo.jframetext;
    
    import java.awt.Dimension;
    import java.awt.Graphics;
    import java.awt.Graphics2D;
    import java.awt.Point;
    import java.awt.RenderingHints;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    
    public class AlgoFrame extends JFrame{ 
    
        private int canvasWidth;
        private int canvasHeight;
    
        public AlgoFrame(String title, int canvasWidth, int canvasHeight){
    
            super(title);
    
            this.canvasWidth = canvasWidth;
            this.canvasHeight = canvasHeight;
    
            AlgoCanvas canvas = new AlgoCanvas();
            setContentPane(canvas);
            pack();
    
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setResizable(false);
    
            setVisible(true);
        }
    
        public AlgoFrame(String title){
    
            this(title, 1024, 768);
        }
    
        public int getCanvasWidth(){
       return canvasWidth;}
        public int getCanvasHeight(){
       return canvasHeight;}
    
        // data
        private MonteCarloPiData data;
        public void render(MonteCarloPiData data){
            this.data = data;
            repaint();
        }
    
        private class AlgoCanvas extends JPanel{ 
    
            public AlgoCanvas(){
                // 双缓存
                super(true);
            }
    
            @Override
            public void paintComponent(Graphics g) {
                super.paintComponent(g);
    
                Graphics2D g2d = (Graphics2D)g;
    
                // 抗锯齿
                RenderingHints hints = new RenderingHints(
                        RenderingHints.KEY_ANTIALIASING,
                        RenderingHints.VALUE_ANTIALIAS_ON);
                hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
                g2d.addRenderingHints(hints);
    
                // 具体绘制
                AlgoVisHelper.setStrokeWidth(g2d, 3);
                AlgoVisHelper.setColor(g2d, AlgoVisHelper.Blue);
                Circle circle = data.getCircle();
                AlgoVisHelper.strokeCircle(g2d, circle.getX(), circle.getY(), circle.getR());
    
                for(int i = 0 ; i < data.getPointsNumber() ; i ++){
                    Point p = data.getPoint(i);
                    //判断点是否在圆里
                    if(circle.contain(p))
                        AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                    else
                        AlgoVisHelper.setColor(g2d, AlgoVisHelper.Green);
    
                    AlgoVisHelper.fillCircle(g2d, p.x, p.y, 3);
                }
            }
    
            @Override
            public Dimension getPreferredSize(){
                return new Dimension(canvasWidth, canvasHeight);
            }
        }
    }

## 实体类 ##

package com.egeo.jframetext;
    
    import java.awt.Point;
    
    public class Circle { 
    
        private int x, y, r;
    
        public Circle(int x, int y, int r){
            this.x = x;
            this.y = y;
            this.r = r;
        }
    
        public int getX(){ return x; }
        public int getY(){ return y; }
        public int getR(){ return r; }
    
        public boolean contain(Point p){
            return Math.pow(p.x - x, 2) + Math.pow(p.y - y, 2) <= r*r;
        }
    }

## 控制层 ##

package com.egeo.jframetext;
    
    import java.awt.EventQueue;
    import java.awt.Point;
    
    public class AlgoVisualizer { 
    
        private static int DELAY = 40;
    
        private MonteCarloPiData data;
        private AlgoFrame frame;
        private int N;
    
        public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){
            //判断高度宽度是否相等（是否为正方形）
            if(sceneWidth != sceneHeight)
                throw new IllegalArgumentException("This demo must be run in a square window!");
    
            this.N = N;
            //在正方形内画圆
            Circle circle = new Circle(sceneWidth/2, sceneHeight/2, sceneWidth/2);
            data = new MonteCarloPiData(circle);
    
            // 初始化视图
            EventQueue.invokeLater(() -> {
                frame = new AlgoFrame("Monte Carlo", sceneWidth, sceneHeight);
    
                new Thread(() -> {
                    run();
                }).start();
            });
        }
    
        public void run(){
    
            for(int i = 0 ; i < N ; i ++){
                //每100次进行一次绘制
                if( i % 100 == 0) {
                    frame.render(data);
                    //等待时间
                    AlgoVisHelper.pause(DELAY);
                    //控制台打印PI值
                    System.out.println(data.estimatePi());
                }
    
                int x = (int)(Math.random() * frame.getCanvasWidth());
                int y = (int)(Math.random() * frame.getCanvasHeight());
                data.addPoint(new Point(x, y));
            }
    
        }
    
        public static void main(String[] args) {
    
            int sceneWidth = 800;
            int sceneHeight = 800;
            int N = 20000;
    
            AlgoVisualizer vis = new AlgoVisualizer(sceneWidth, sceneHeight, N);
        }
    }

## 逻辑处理类 ##

package com.egeo.jframetext;
    
    import java.awt.Point;
    import java.util.LinkedList;
    
    public class MonteCarloPiData { 
    
        private Circle circle;
        private LinkedList<Point> points;
        private int insideCircle = 0;
    
        public MonteCarloPiData(Circle circle){
            this.circle = circle;
            points = new LinkedList<Point>();
        }
    
        public Circle getCircle(){
            return circle;
        }
    
        public int getPointsNumber(){
            return points.size();
        }
    
        public Point getPoint(int i){
            if(i < 0 || i >= points.size())
                throw new IllegalArgumentException("out of bound in getPoint!");
    
            return points.get(i);
        }
    
        public void addPoint(Point p){
            points.add(p);
            //是否在圆内
            if(circle.contain(p))
                insideCircle ++;
        }
    
        public double estimatePi(){
    
            if(points.size() == 0)
                return 0.0;
    
            int circleArea = insideCircle;
            int squareArea = points.size();
            return (double)circleArea * 4 / squareArea;
        }
    }

## 程序运行效果 ##

![这里写图片描述][70]

# 蒙特卡洛算法求解三门问题 #

package com.egeo.jframetext;
    
    
    public class ThreeGatesExperiment {
        //模拟次数
        private int N;
    
        public ThreeGatesExperiment(int N){
    
            if(N <= 0)
                throw new IllegalArgumentException("N must be larger than 0!");
    
            this.N = N;
        }
    
        public void run(boolean changeDoor){
    
            int wins = 0;
            for(int i = 0 ; i < N ; i ++)
                if(play(changeDoor))
                    wins ++;
    
            System.out.println(changeDoor ? "Change" : "Not Change");
            System.out.println("winning rate: " + (double)wins/N);
        }
    
        private boolean play(boolean changeDoor){
    
            // Door 0, 1, 2
            //随机中奖的门
            int prizeDoor = (int)(Math.random() * 3);
            //观众选中的门
            int playerChoice = (int)(Math.random() * 3);
            //是否换门
            if( playerChoice == prizeDoor)
                return changeDoor ? false : true;
            else
                return changeDoor ? true : false;
        }
    
        public static void main(String[] args) {
    
            int N = 10000000;
            ThreeGatesExperiment exp = new ThreeGatesExperiment(N);
    
            exp.run(true);
            System.out.println();
            exp.run(false);
        }
    }

![这里写图片描述][70 1]

[70]: /images/20220524/8d0081906b1544fb80545f58bc7dc6b0.png
[70 1]: /images/20220524/8d3d5af7ec6f4f6b9f3c6b190eafd783.png