符合28个概率分布函数的随机数生成的Java代码实现（更新中）

接口：

public interface hanshu {
    void rand_lianxu_print(double a1,int []num,int n);
    void choose_hanshu(int n,int []num,int m);

    double Beta_Distribution(double alpha, double beta);//(1)
    int Binomial_Distribution(double probaility, int N);//(2)
    double Cauchy_Distribution(double a1,double x0, double lamda);//(3)参数：随机数（0-1）
    double Chisquare_Distribution(int k, double mean, double sigama);//(4)
    double Constantreal_Distribution(int i);//(5)---
    double Enumerated_Distribution(int i);//(6)---
    double Exponential_Distribution(double a1);//(7)
    double F_Distribution(int n1, int n2,double normol_mean,double normol_sigama);//(8)
    double Gamma_Distribution(int i);//(9)--
    int Geometric_Distribution(double probaility);//（10）参数：k次成功的概率中介
    double Gumbel_Distribution(double a1, double k, double miu, double sigma);//(11)
    int Hypergeometric_Distribution(int N, int n,int m);//(12)
    double Laplace_Distribution(double beta);//14
    double Levy_Distribution(int i);//(15)---
    double Logistic_Distribution(double a1);//16参数：随机数（0-1）
    double MultivariateNormal_Distribution(int i);//(17)---
    double Nakagami_Distribution(double possiblity,int r);//(18)
    double Normal_Distribution(double mean, double sigama);//(19)
    double Pareto_Distribution(int xmin,int k);//(20)
    int Pascal_Distribution(double possiblity,int r);//(21)
    int Possion_Distribution(int lamda);//(22)参数：lamda
    double T_Distribution(int n1, double normol_mean,double normol_sigama);//(23)
    double Triangular_Distribution(int a,int b, int c, double a1);//(24)
    double UniformInteger_Distribution(int i);//(25)---
    double UniformReal_Distribution(int i);//(26)---
    double Weibull_Distribution(double a, double b);//(27)
    double Zipf_Distribution(double a1);//28参数：随机数（0-1）

}

主类：

import org.w3c.dom.ls.LSInput;
import java.util.Arrays;
import java.util.Scanner;
import static java.lang.Math.log;
import java.lang.Math.*;


public class distribution<T> implements hanshu{
    private static final int Max = 1 << 10;

    public static void main(String[] args) {
        distribution z = new distribution();
        int []num={0,0,0,0,0,0,0,0,0,0,
                   0,0,0,0,0,0,0,0,0,0,
                   0,0,0,0,0,0,0,0,0,0,
                   0,0,0,0,0,0,0,0,0,0,0};//求频率个数
        double x;
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您要产生的随机数个数?");
        int rand_num = in.nextInt();
        System.out.println("请输入随机数符合的分布函数?（输入序号即可）");
        System.out.println("1、Beta_Distribution;2、Binomial_Distribution3、Cauchy_Distribution");
        int hanshu_choose = in.nextInt();
        z.choose_hanshu(hanshu_choose,num,rand_num);//选择函数进行处理


        //输出随机数个数
        for(int i=0;i<num.length;i++){
            System.out.println(num[i]);//根据区间输出随机数
        }

    }

    @Override
    public double Logistic_Distribution(double a1) {

        return Math.log(a1+0.5/(0.5-a1));
    }

    @Override
    public double Weibull_Distribution(double a, double b){
       double u,x;
       u = Math.random();
       u = -Math.log(u);
       x = b * Math.pow(u, 1.0/a);
       return x;
    }

    @Override
    public double Exponential_Distribution(double a1){
        double z;
        z=-1/log(1-a1);
        return z;
    }
    @Override
    public double Cauchy_Distribution(double a1,double x0, double lamda){
        double z;
        z=lamda*Math.tan((a1-0.5)*3.141)+x0;
        return z;
    }
    @Override
    //随机数，形状参数、中心参数、展宽参数
    public double Gumbel_Distribution(double a1, double k, double miu, double sigma){
        double z;
        z = sigma*(Math.pow(Math.log(1/a1),-k)-1)/k+miu;
        return z;
    }
    @Override
    public double Zipf_Distribution(double a1){

        return 0.1/a1;

    }

    //https://www.cnblogs.com/liam-ji/p/11624215.html
    @Override
    public double Beta_Distribution(double alpha, double beta){
        double u, v;
        double x=1.0,y=1.0;
        while(x+y>1.0){
            u = Math.random();
            v = Math.random();
            x = Math.pow(u,1/alpha);
            y = Math.pow(v,1/beta);
        }
        return x/(x+y);
    }

    @Override
    public double Normal_Distribution(double mean, double sigama){
        int i ;
        double x=1.0,y;
        for (i=0;i<12;i++){
            x+=Math.random();
        }
        x = x-6.0;
        y = mean+x*sigama;
        return y;
    }

    @Override
    public double Chisquare_Distribution(int k, double mean, double sigama){
        double dv = 0.0;
        for (int i=0;i<k;i++){
            double p_dv = Normal_Distribution(mean, sigama);
            dv+=p_dv*p_dv;
        }
        return dv;
    }

    @Override
    public double F_Distribution(int n1, int n2,double normol_mean,double normol_sigama){
        double r1=1.0,r2=1.0;
        for(int i=0;i<n1;i++){
            r1+=Chisquare_Distribution(n1,normol_mean,normol_sigama);
        }
        for (int j=0;j<n2;j++){
            r2+=Chisquare_Distribution(n2,normol_mean,normol_sigama);
        }
        return (r1/n1)/(r2/n2);
    }

    @Override
    public double T_Distribution(int n1, double normol_mean,double normol_sigama){
        double r1=1.0,r2=1.0;
        for(int i=0;i<n1;i++){
            r1+=Chisquare_Distribution(n1,normol_mean,normol_sigama);//卡方分布
        }
        r2 = Normal_Distribution(normol_mean, normol_sigama);//正态分布
        return r2/Math.sqrt(r1/n1);
    }

    //https://www.cnblogs.com/liam-ji/p/11631363.html
    @Override
    public double Laplace_Distribution(double beta){
        double u1=Math.random();
        double u2=Math.random();
        double x;
        if(u1<=0.5){
            x = -beta*Math.log(1.0-u2);
        }
        else{
            x = beta*Math.log(u2);
        }
        return x;

    }

    @Override
    public double Pareto_Distribution(int xmin,int k){
        double r = Math.random();
        if(r<xmin)return 0;
        else {
            return Math.pow(k*Math.pow(xmin,k)/Math.pow(xmin,k+1),1/k+1);
        }
    }

    @Override
    public int Geometric_Distribution(double probaility){

        int rnd = 0;
        while(true){
            rnd++;
            double num = Math.random();
            if(Math.random()<probaility){
                break;
            }
        }
        return rnd;
    }
    @Override
    public int Hypergeometric_Distribution(int N, int n,int M){//总数量、抽出的数量、指定的数量
        int rnd=0;
        for(int i=0;i<n;i++){
            if(Math.random()<M/N){
                rnd++;
            }
        }
        return rnd;
    }



    @Override
    public int Binomial_Distribution(double probaility, int N){

        int rnd = 0;
        while(N>0){

            if(Math.random()<probaility){
                rnd++;
            }
            N--;
        }
        return rnd;
    }
    @Override
    public int Possion_Distribution(int lamda){
        double p=1.0;//初始概率
        int rnd = 0;//离散判断次数
        double L = Math.exp(-lamda);//临界值，认为是接近0
        while(p<=L){
            rnd++;
            p = Math.random();
        }
        return rnd;
    }

    @Override
    public double Gamma_Distribution(int i){

        return i;
    }
//https://blog.csdn.net/ma123rui/article/details/105436076?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~first_rank_v2~rank_v25-2-105436076.nonecase&utm_term=nakagami%E5%88%86%E5%B8%83&spm=1000.2123.3001.4430
    @Override
    public double Nakagami_Distribution(double possiblity,int r){

        return Math.sqrt(Gamma_Distribution(r));
    }
    public int Pascal_Distribution(double possiblity,int r){
        int rnd=0,k=0;
        double num;
        while(true){
            k++;
            num = Math.random();
            if(num<possiblity){
                rnd++;
            }
            if(rnd>r){
                break;
            }
        }
        return k;
    }

    @Override
    public double Triangular_Distribution(int a,int b, int c, double a1){
        if(a1>=a&&a1<=c){
            return a+(a1*(b-a)*(c-a)/2);
        }
        else if (a1>=c&&a1<=b){
            return b-(a1*(b-a)*(b-c)/2);
        }
        else return 0;
    }
    @Override
    public double Constantreal_Distribution(int i){return 1.0;}

    @Override
    public double Enumerated_Distribution(int i){return 1.0;}

    @Override
    public double Levy_Distribution(int i){return 1.0;}

    @Override
    public double MultivariateNormal_Distribution(int i){return 1.0;}

    @Override
    public double UniformInteger_Distribution(int i){return 1.0;}

    @Override
    public double UniformReal_Distribution(int i){return 1.0;}
    //验证随机数并返回区间概率
    @Override
    public void rand_lianxu_print(double a1,int []num,int n){
        double i= -5.0;
        int j=0;
        if (a1>0){
            System.out.println(a1);
        }

        while(i<5.1){
            if(a1>=i&&a1<=i+0.5){
                num[j]++;
                break;
            }
            j++;
            i = i+0.5;
        }
    }
    @Override
    public void rand_lianxu_print_1(double a1,int []num,int n,double c){
        double i= 0.5,k,k1;
        int j=0;
        if (a1>0){

            System.out.println(a1+"hahahahaha");
        }

        while(i<10){

            k = Math.log(i+0.5/(0.5-i));
            k1 = Math.log(i+0.55/(0.55-i));
            System.out.println(k+"k"); 
            System.out.println(k1+"k1");

            if(a1>=k&&a1<=k1){
                num[j]++;
                break;
            }
            j++;
            i = i+0.05;
        }
    }

    @Override
    public double rand_lianxu_print_2(double a1){
        return 1/(1+Math.exp(-a1));
    }

    @Override
    public void choose_hanshu(int n,int []num,int m){
        Scanner in = new Scanner(System.in);
        switch (n){
            case 1:
                System.out.println("请输入参数alpha和beta");
                double alpha = in.nextDouble();
                double beta = in.nextDouble();
                double x;
                for(int i=0;i<m;i++){
                    x=Beta_Distribution(alpha,beta);//产生随机数并根据接口代入到函数中，随机数在0-1之间
                    rand_lianxu_print(x*10,num,m);
                }
                break;
            case 2:
                System.out.println("请输入参数probility和N");
                double probaility = in.nextDouble();
                int N = in.nextInt();
                double x2;
                for(int i=0;i<m;i++){
                    x2=Binomial_Distribution(probaility,N);//产生随机数并根据接口代入到函数中，随机数在0-1之间
                    rand_lianxu_print(x2,num,m);
                }
                break;
            case 3:
                System.out.println("请输入参数x0和lamda");
                double x0 = in.nextDouble();
                double lamda= in.nextDouble();
                double x3;
                for(int i=0;i<m;i++){
                    x3=Cauchy_Distribution(Math.random(),x0,lamda);//产生随机数并根据接口代入到函数中，随机数在0-1之间
                    rand_lianxu_print(x3,num,m);
                }
                break;
            case 4:
                double x4,c;
                for(int i=0;i<m;i++){
                    c = Math.random();
                    x4=Logistic_Distribution(c);//产生随机数并根据接口代入到函数中，随机数在0-1之间
                    rand_lianxu_print_1(x4,num,m,c);
                }
                break;
            case 5:
                for(double i =1.0;i<1000;i++){
                    System.out.println(rand_lianxu_print_2(i));
                }
                break;
            default:break;
        }
    }
}

持续更新中。

Java新手，请大佬对有问题的地方评论指点