StdRandom提供一系列的靜態(tài)方法用于產(chǎn)生滿(mǎn)足多種需求的隨機(jī)數(shù)，具體代碼如下：
package crazymonkey.math;
import java.util.Random;
/**
* 此類(lèi)提供一系列產(chǎn)生隨機(jī)數(shù)的方法，以滿(mǎn)足不同用例需要
* @author crazyMonkey
*/
public final class StdRandom {
//隨機(jī)數(shù)對(duì)象
private static Random random;
//用于產(chǎn)生隨機(jī)數(shù)的種子
private static long seed;
// 靜態(tài)初始化區(qū)域
static {
//產(chǎn)生隨機(jī)數(shù)種子
seed = System.currentTimeMillis();
random = new Random(seed);
}
private StdRandom() { }
/***********************************************************
* 產(chǎn)生基本的隨機(jī)數(shù)
***********************************************************/
/**
* 獲取此類(lèi)實(shí)例的偽隨機(jī)種子生成器
*/
public static void setSeed(long s) {
seed = s;
random = new Random(seed);
}
/**
* 獲取此類(lèi)實(shí)例提供的偽隨機(jī)種子生成器
*/
public static long getSeed() {
return seed;
}
/**
* 返回一個(gè)隨機(jī)的范圍在[0,1)之間的double類(lèi)型的數(shù)
*/
public static double uniform() {
return random.nextDouble();
}
/**
* 返回一個(gè)隨機(jī)的范圍在[0,N)之間的int類(lèi)型的數(shù)
*/
public static int uniform(int N) {
return random.nextInt(N);
}
/**
* 返回一個(gè)范圍在 [0, 1)的實(shí)數(shù)
*/
public static double random() {
return uniform();
}
/**
* 返回一個(gè)范圍在 [a, b)的int類(lèi)型值
*/
public static int uniform(int a, int b) {
return a + uniform(b - a);
}
/**
* 返回一個(gè)范圍在 [a, b)的實(shí)數(shù)
*/
public static double uniform(double a, double b) {
return a + uniform() * (b-a);
}
/**
* 返回一個(gè)隨機(jī)boolean值,該p表示此布爾值為真的概率
* @param p 0~1 之間的double值,表示產(chǎn)生boolean真值的可能性
*/
public static boolean bernoulli(double p) {
return uniform() < p;
}
/**
* 返回一個(gè)隨機(jī)boolean值,此布爾值為真的概率為0.5
*/
public static boolean bernoulli() {
return bernoulli(0.5);
}
/***********************************************************
* 產(chǎn)生滿(mǎn)足特定概率分布的實(shí)數(shù)
***********************************************************/
/**
* 返回一個(gè)滿(mǎn)足標(biāo)準(zhǔn)正態(tài)分布的實(shí)數(shù)
*/
public static double gaussian() {
double r, x, y;
do {
x = uniform(-1.0, 1.0);
y = uniform(-1.0, 1.0);
r = x*x + y*y;
} while (r >= 1 || r == 0);
return x * Math.sqrt(-2 * Math.log(r) / r);
}
/**
* 返回一個(gè)滿(mǎn)足平均值為mean,標(biāo)準(zhǔn)差為stddev的正態(tài)分布的實(shí)數(shù)
* @param mean 正態(tài)分布的平均值
* @param stddev 正太分布的標(biāo)準(zhǔn)差
*/
public static double gaussian(double mean, double stddev) {
return mean + stddev * gaussian();
}
/**
* 返回一個(gè)滿(mǎn)足幾何分布的整型值 平均值為1/p
*/
public static int geometric(double p) {
// Knuth
return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));
}
/**
* 根據(jù)指定的參數(shù)返回一個(gè)滿(mǎn)足泊松分布的實(shí)數(shù)
*/
public static int poisson(double lambda) {
// 使用 Knuth 的算法
// 參見(jiàn)
int k = 0;
double p = 1.0;
double L = Math.exp(-lambda);
do {
k++;
p *= uniform();
} while (p >= L);
return k-1;
}
/**
* 根據(jù)指定的參數(shù)按返回一個(gè)滿(mǎn)足帕雷托分布的實(shí)數(shù)
*/
public static double pareto(double alpha) {
return Math.pow(1 - uniform(), -1.0/alpha) - 1.0;
}
/**
* 返回一個(gè)滿(mǎn)足柯西分布的實(shí)數(shù)
*/
public static double cauchy() {
return Math.tan(Math.PI * (uniform() - 0.5));
}
/**
* 返回一個(gè)滿(mǎn)足離散分布的int類(lèi)型的數(shù)
* @param a 算法產(chǎn)生隨機(jī)數(shù)過(guò)程中需要使用此數(shù)組的數(shù)據(jù)，a[i]代表i出現(xiàn)的概率
* 前提條件 a[i] 非負(fù)切和接近 1.0
*/
public static int discrete(double[] a) {
double EPSILON = 1E-14;
double sum = 0.0;
for (int i = 0; i < a.length; i++) {
if (a[i] < 0.0) throw new IllegalArgumentException("數(shù)組元素 " + i + " 為負(fù)數(shù): " + a[i]);
sum = sum + a[i];
}
if (sum > 1.0 + EPSILON || sum < 1.0 - EPSILON)
throw new IllegalArgumentException("數(shù)組各個(gè)元素之和為: " + sum);
while (true) {
double r = uniform();
sum = 0.0;
for (int i = 0; i < a.length; i++) {
sum = sum + a[i];
if (sum > r) return i;
}
}
}
/**
* 返回一個(gè)滿(mǎn)足指數(shù)分布的實(shí)數(shù)，該指數(shù)分布比率為lambda
*/
public static double exp(double lambda) {
return -Math.log(1 - uniform()) / lambda;
}
/***********************************************************
* 數(shù)組操作
***********************************************************/
/**
* 隨機(jī)打亂指定的Object型數(shù)組
* @param a 待打亂的Object型數(shù)組
*/
public static void shuffle(Object[] a) {
int N = a.length;
for (int i = 0; i < N; i++) {
int r = i + uniform(N-i);
Object temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
/**
* 隨機(jī)打亂指定的double型數(shù)組
* @param a 待打亂的double型數(shù)組
*/
public static void shuffle(double[] a) {
int N = a.length;
for (int i = 0; i < N; i++) {
int r = i + uniform(N-i);
double temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
/**
* 隨機(jī)打亂指定的int型數(shù)組
* @param a 待打亂的int型數(shù)組
*/
public static void shuffle(int[] a) {
int N = a.length;
for (int i = 0; i < N; i++) {
int r = i + uniform(N-i);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
/**
* 隨機(jī)打亂指定Object類(lèi)型數(shù)組中指定范圍的數(shù)據(jù)
*
* @param a 指定的數(shù)組
* @param lo 起始位置
* @param hi 結(jié)束位置
*/
public static void shuffle(Object[] a, int lo, int hi) {
if (lo < 0 || lo > hi || hi >= a.length) {
throw new IndexOutOfBoundsException("不合法的邊界");
}
for (int i = lo; i <= hi; i++) {
int r = i + uniform(hi-i+1);
Object temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
/**
* 隨機(jī)打亂指定double類(lèi)型數(shù)組中指定范圍的數(shù)據(jù)
*
* @param a 指定的數(shù)組
* @param lo 起始位置
* @param hi 結(jié)束位置
*/
public static void shuffle(double[] a, int lo, int hi) {
if (lo < 0 || lo > hi || hi >= a.length) {
throw new IndexOutOfBoundsException("不合法的邊界");
}
for (int i = lo; i <= hi; i++) {
int r = i + uniform(hi-i+1);
double temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
/**
* 隨機(jī)打亂指定int類(lèi)型數(shù)組中指定范圍的數(shù)據(jù)
*
* @param a 指定的數(shù)組
* @param lo 起始位置
* @param hi 結(jié)束位置
*/
public static void shuffle(int[] a, int lo, int hi) {
if (lo < 0 || lo > hi || hi >= a.length) {
throw new IndexOutOfBoundsException("不合法的邊界");
}
for (int i = lo; i <= hi; i++) {
int r = i + uniform(hi-i+1);
int temp = a[i];
a[i] = a[r];
a[r] = temp;
}
}
}
更多信息請(qǐng)查看IT技術(shù)專(zhuān)欄
公考類(lèi)
招聘類(lèi)
各類(lèi)考試
公眾號(hào)
事業(yè)單位
當(dāng)前位置：