/*************************************************************************
* Compilation: javac StdRandom.java
* Execution: java StdRandom
* Dependencies: StdOut.java
*
* A library of static methods to generate pseudo-random numbers from
* different distributions (bernoulli, uniform, gaussian, discrete,
* and exponential). Also includes a method for shuffling an array.
*
*
* % java StdRandom 5
* seed = 1316600602069
* 59 16.81826 true 8.83954 0
* 32 91.32098 true 9.11026 0
* 35 10.11874 true 8.95396 3
* 92 32.88401 true 8.87089 0
* 72 92.55791 true 9.46241 0
*
* % java StdRandom 5
* seed = 1316600616575
* 96 60.17070 true 8.72821 0
* 79 32.01607 true 8.58159 0
* 81 59.49065 true 9.10423 1
* 96 51.65818 true 9.02102 0
* 99 17.55771 true 8.99762 0
*
* % java StdRandom 5 1316600616575
* seed = 1316600616575
* 96 60.17070 true 8.72821 0
* 79 32.01607 true 8.58159 0
* 81 59.49065 true 9.10423 1
* 96 51.65818 true 9.02102 0
* 99 17.55771 true 8.99762 0
*
*
* Remark
* ------
* - Relies on randomness of nextDouble() method in java.util.Random
* to generate pseudorandom numbers in [0, 1).
*
* - This library allows you to set and get the pseudorandom number seed.
*
* - Seehttp://www.honeylocust.com/RngPack/for an industrial
* strength random number generator in Java.
*
*************************************************************************/
importjava.util.Random;/*** Standard random. This class provides methods for generating
* random number from various distributions.
*
* For additional documentation, see Section 2.2 of
* Introduction to Programming in Java: An Interdisciplinary Approach by Robert Sedgewick and Kevin Wayne.
*
*@authorRobert Sedgewick
*@authorKevin Wayne*/
public final classStdRandom {private static Random random; //pseudo-random number generator
private static long seed; //pseudo-random number generator seed//static initializer
static{//this is how the seed was set in Java 1.4
seed =System.currentTimeMillis();
random= newRandom(seed);
}//don't instantiate
privateStdRandom() { }/*** Sets the seed of the psedurandom number generator.*/
public static void setSeed(longs) {
seed=s;
random= newRandom(seed);
}/*** Returns the seed of the psedurandom number generator.*/
public static longgetSeed() {returnseed;
}/*** Return real number uniformly in [0, 1).*/
public static doubleuniform() {returnrandom.nextDouble();
}/*** Returns an integer uniformly between 0 (inclusive) and N (exclusive).
*@throwsIllegalArgumentException if N <= 0*/
public static int uniform(intN) {if (N <= 0) throw new IllegalArgumentException("Parameter N must be positive");returnrandom.nextInt(N);
}/STATIC METHODS BELOW RELY ON JAVA.UTIL.RANDOM ONLY INDIRECTLY VIA//THE STATIC METHODS ABOVE.
///
/*** Returns a real number uniformly in [0, 1).
*@deprecatedclearer to use {@link#uniform()}*/
public static doublerandom() {returnuniform();
}/*** Returns an integer uniformly in [a, b).
*@throwsIllegalArgumentException if b <= a
*@throwsIllegalArgumentException if b - a >= Integer.MAX_VALUE*/
public static int uniform(int a, intb) {if (b <= a) throw new IllegalArgumentException("Invalid range");if ((long) b - a >= Integer.MAX_VALUE) throw new IllegalArgumentException("Invalid range");return a + uniform(b -a);
}/*** Returns a real number uniformly in [a, b).
*@throwsIllegalArgumentException unless a < b*/
public static double uniform(double a, doubleb) {if (!(a < b)) throw new IllegalArgumentException("Invalid range");return a + uniform() * (b-a);
}/*** Returns a boolean, which is true with probability p, and false otherwise.
*@throwsIllegalArgumentException unless p >= 0.0 and p <= 1.0*/
public static boolean bernoulli(doublep) {if (!(p >= 0.0 && p <= 1.0))throw new IllegalArgumentException("Probability must be between 0.0 and 1.0");return uniform()
}/*** Returns a boolean, which is true with probability .5, and false otherwise.*/
public static booleanbernoulli() {return bernoulli(0.5);
}/*** Returns a real number with a standard Gaussian distribution.*/
public static doublegaussian() {//use the polar form of the Box-Muller transform
doubler, 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);//Remark: y * Math.sqrt(-2 * Math.log(r) / r)//is an independent random gaussian
}/*** Returns a real number from a gaussian distribution with given mean and stddev*/
public static double gaussian(double mean, doublestddev) {return mean + stddev *gaussian();
}/*** Returns an integer with a geometric distribution with mean 1/p.
*@throwsIllegalArgumentException unless p >= 0.0 and p <= 1.0*/
public static int geometric(doublep) {if (!(p >= 0.0 && p <= 1.0))throw new IllegalArgumentException("Probability must be between 0.0 and 1.0");//using algorithm given by Knuth
return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 -p));
}/*** Return an integer with a Poisson distribution with mean lambda.
*@throwsIllegalArgumentException unless lambda > 0.0 and not infinite*/
public static int poisson(doublelambda) {if (!(lambda > 0.0))throw new IllegalArgumentException("Parameter lambda must be positive");if(Double.isInfinite(lambda))throw new IllegalArgumentException("Parameter lambda must not be infinite");//using algorithm given by Knuth//seehttp://en.wikipedia.org/wiki/Poisson_distribution
int k = 0;double p = 1.0;double L = Math.exp(-lambda);do{
k++;
p*=uniform();
}while (p >=L);return k-1;
}/*** Returns a real number with a Pareto distribution with parameter alpha.
*@throwsIllegalArgumentException unless alpha > 0.0*/
public static double pareto(doublealpha) {if (!(alpha > 0.0))throw new IllegalArgumentException("Shape parameter alpha must be positive");return Math.pow(1 - uniform(), -1.0/alpha) - 1.0;
}/*** Returns a real number with a Cauchy distribution.*/
public static doublecauchy() {return Math.tan(Math.PI * (uniform() - 0.5));
}/*** Returns a number from a discrete distribution: i with probability a[i].
* throws IllegalArgumentException if sum of array entries is not (very nearly) equal to 1.0
* throws IllegalArgumentException unless a[i] >= 0.0 for each index i*/
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("array entry " + i + " must be nonnegative: " +a[i]);
sum= sum +a[i];
}if (sum > 1.0 + EPSILON || sum < 1.0 -EPSILON)throw new IllegalArgumentException("sum of array entries does not approximately equal 1.0: " +sum);//the for loop may not return a value when both r is (nearly) 1.0 and when the//cumulative sum is less than 1.0 (as a result of floating-point roundoff error)
while (true) {double r =uniform();
sum= 0.0;for (int i = 0; i < a.length; i++) {
sum= sum +a[i];if (sum > r) returni;
}
}
}/*** Returns a real number from an exponential distribution with rate lambda.
*@throwsIllegalArgumentException unless lambda > 0.0*/
public static double exp(doublelambda) {if (!(lambda > 0.0))throw new IllegalArgumentException("Rate lambda must be positive");return -Math.log(1 - uniform()) /lambda;
}/*** Rearrange the elements of an array in random order.*/
public static voidshuffle(Object[] a) {int N =a.length;for (int i = 0; i < N; i++) {int r = i + uniform(N-i); //between i and N-1
Object temp =a[i];
a[i]=a[r];
a[r]=temp;
}
}/*** Rearrange the elements of a double array in random order.*/
public static void shuffle(double[] a) {int N =a.length;for (int i = 0; i < N; i++) {int r = i + uniform(N-i); //between i and N-1
double temp =a[i];
a[i]=a[r];
a[r]=temp;
}
}/*** Rearrange the elements of an int array in random order.*/
public static void shuffle(int[] a) {int N =a.length;for (int i = 0; i < N; i++) {int r = i + uniform(N-i); //between i and N-1
int temp =a[i];
a[i]=a[r];
a[r]=temp;
}
}/*** Rearrange the elements of the subarray a[lo..hi] in random order.*/
public static void shuffle(Object[] a, int lo, inthi) {if (lo < 0 || lo > hi || hi >=a.length) {throw new IndexOutOfBoundsException("Illegal subarray range");
}for (int i = lo; i <= hi; i++) {int r = i + uniform(hi-i+1); //between i and hi
Object temp =a[i];
a[i]=a[r];
a[r]=temp;
}
}/*** Rearrange the elements of the subarray a[lo..hi] in random order.*/
public static void shuffle(double[] a, int lo, inthi) {if (lo < 0 || lo > hi || hi >=a.length) {throw new IndexOutOfBoundsException("Illegal subarray range");
}for (int i = lo; i <= hi; i++) {int r = i + uniform(hi-i+1); //between i and hi
double temp =a[i];
a[i]=a[r];
a[r]=temp;
}
}/*** Rearrange the elements of the subarray a[lo..hi] in random order.*/
public static void shuffle(int[] a, int lo, inthi) {if (lo < 0 || lo > hi || hi >=a.length) {throw new IndexOutOfBoundsException("Illegal subarray range");
}for (int i = lo; i <= hi; i++) {int r = i + uniform(hi-i+1); //between i and hi
int temp =a[i];
a[i]=a[r];
a[r]=temp;
}
}/*** Unit test.*/
public static voidmain(String[] args) {int N = Integer.parseInt(args[0]);if (args.length == 2) StdRandom.setSeed(Long.parseLong(args[1]));double[] t = { .5, .3, .1, .1};
StdOut.println("seed = " +StdRandom.getSeed());for (int i = 0; i < N; i++) {
StdOut.printf("%2d " , uniform(100));
StdOut.printf("%8.5f ", uniform(10.0, 99.0));
StdOut.printf("%5b " , bernoulli(.5));
StdOut.printf("%7.5f ", gaussian(9.0, .2));
StdOut.printf("%2d ", discrete(t));
StdOut.println();
}
String[] a= "A B C D E F G".split(" ");for(String s : a)
StdOut.print(s+ " ");
StdOut.println();
}
}