randomdataimpl.java

Apache的common math数学软件包

     * 1000 * mean.</p>
     * 
     * @param mean mean of the Poisson distribution.
     * @return the random Poisson value.
     */
    public long nextPoisson(double mean) {
        if (mean <= 0) {
            throw new IllegalArgumentException("Poisson mean must be > 0");
        }
        double p = Math.exp(-mean);
        long n = 0;
        double r = 1.0d;
        double rnd = 1.0d;
        RandomGenerator rand = getRan();
        while (n < 1000 * mean) {
            rnd = rand.nextDouble();
            r = r * rnd;
            if (r >= p) {
                n++;
            } else {
                return n;
            }
        }
        return n;
    }

    /**
     * Generate a random value from a Normal (a.k.a. Gaussian) distribution
     * with the given mean, <code>mu</code> and the given standard deviation,
     * <code>sigma</code>.
     * 
     * @param mu the mean of the distribution
     * @param sigma the standard deviation of the distribution
     * @return the random Normal value
     */
    public double nextGaussian(double mu, double sigma) {
        if (sigma <= 0) {
            throw new IllegalArgumentException("Gaussian std dev must be > 0");
        }
        RandomGenerator rand = getRan();
        return sigma * rand.nextGaussian() + mu;
    }

    /**
     * Returns a random value from an Exponential distribution with the given
     * mean.
     * <p>
     * <strong>Algorithm Description</strong>:  Uses the
     * <a href="http://www.jesus.ox.ac.uk/~clifford/a5/chap1/node5.html">
     * Inversion Method</a> to generate exponentially distributed random values
     * from uniform deviates.</p>
     * 
     * @param mean the mean of the distribution
     * @return the random Exponential value
     */
    public double nextExponential(double mean)  {
        if (mean < 0.0)  {
            throw new IllegalArgumentException
                ("Exponential mean must be >= 0");
        }
        RandomGenerator rand = getRan();
        double unif = rand.nextDouble();
        while (unif == 0.0d) {
            unif = rand.nextDouble();
        }
        return -mean * Math.log(unif);
    }

    /**
     * {@inheritDoc}<p>
     * <strong>Algorithm Description</strong>: scales the output of
     * Random.nextDouble(), but rejects 0 values (i.e., will generate another
     * random double if Random.nextDouble() returns 0).
     * This is necessary to provide a symmetric output interval
     * (both endpoints excluded).</p>
     * 
     * @param lower the lower bound.
     * @param upper the upper bound.
     * @return a uniformly distributed random value from the interval (lower, upper)
     */
    public double nextUniform(double lower, double upper) {
        if (lower >= upper) {
            throw new IllegalArgumentException
            ("lower bound must be < upper bound");
        }
        RandomGenerator rand = getRan();

        // ensure nextDouble() isn't 0.0
        double u = rand.nextDouble();
        while(u <= 0.0){
            u = rand.nextDouble();
        }

        return lower + u * (upper - lower);
    }

    /**
     * Returns the RandomGenerator used to generate non-secure
     * random data.
     * <p>
     * Creates and initializes a default generator if null.</p>
     *
     * @return the Random used to generate random data
     * @since 1.1
     */
    private RandomGenerator getRan() {
        if (rand == null) {
            rand = new JDKRandomGenerator();
            rand.setSeed(System.currentTimeMillis());
        }
        return rand;
    }

    /**
     * Returns the SecureRandom used to generate secure random data.
     * <p>
     * Creates and initializes if null.</p>
     *
     * @return the SecureRandom used to generate secure random data
     */
    private SecureRandom getSecRan() {
        if (secRand == null) {
            secRand = new SecureRandom();
            secRand.setSeed(System.currentTimeMillis());
        }
        return secRand;
    }

    /**
     * Reseeds the random number generator with the supplied seed.
     * <p>
     * Will create and initialize if null.</p>
     *
     * @param seed the seed value to use
     */
    public void reSeed(long seed) {
        if (rand == null) {
            rand = new JDKRandomGenerator();
        }
        rand.setSeed(seed);
    }

    /**
     * Reseeds the secure random number generator with the current time
     * in milliseconds.
     * <p>
     * Will create and initialize if null.</p>
     */
    public void reSeedSecure() {
        if (secRand == null) {
            secRand = new SecureRandom();
        }
        secRand.setSeed(System.currentTimeMillis());
    }

    /**
     * Reseeds the secure random number generator with the supplied seed.
     * <p>
     * Will create and initialize if null.</p>
     *
     * @param seed the seed value to use
     */
    public void reSeedSecure(long seed) {
        if (secRand == null) {
            secRand = new SecureRandom();
        }
        secRand.setSeed(seed);
    }

    /**
     * Reseeds the random number generator with the current time
     * in milliseconds.
     */
    public void reSeed() {
        if (rand == null) {
            rand = new JDKRandomGenerator();
        }
        rand.setSeed(System.currentTimeMillis());
    }

    /**
     * Sets the PRNG algorithm for the underlying SecureRandom instance
     * using the Security Provider API.  The Security Provider API is defined in
     * <a href="http://java.sun.com/j2se/1.3/docs/guide/security/CryptoSpec.html#AppA">
     * Java Cryptography Architecture API Specification & Reference.</a>
     * <p>
     * <strong>USAGE NOTE:</strong> This method carries <i>significant</i>
     * overhead and may take several seconds to execute.
     * </p>
     *
     * @param algorithm the name of the PRNG algorithm
     * @param provider the name of the provider
     * @throws NoSuchAlgorithmException if the specified algorithm
     * is not available
     * @throws NoSuchProviderException if the specified provider
     * is not installed
     */
    public void setSecureAlgorithm(String algorithm, String provider)
        throws NoSuchAlgorithmException, NoSuchProviderException {
        secRand = SecureRandom.getInstance(algorithm, provider);
    }

    /**
     * Uses a 2-cycle permutation shuffle to generate a random permutation.
     * The shuffling process is described
     * <a href="http://www.maths.abdn.ac.uk/~igc/tch/mx4002/notes/node83.html">
     * here</a>.
     * @param n the population size.
     * @param k the number to choose.
     * @return the random permutation.
     */
    public int[] nextPermutation(int n, int k) {
        if (k > n) {
            throw new IllegalArgumentException
                ("permutation k exceeds n");
        }
        if (k == 0) {
            throw new IllegalArgumentException
                ("permutation k must be > 0");
        }

        int[] index = getNatural(n);
        shuffle(index, n - k);
        int[] result = new int[k];
        for (int i = 0; i < k; i++) {
            result[i] = index[n - i - 1];
        }

        return result;
    }

    /**
     * Uses a 2-cycle permutation shuffle to generate a random permutation.
     * <strong>Algorithm Description</strong>: Uses a 2-cycle permutation
     * shuffle to generate a random permutation of <code>c.size()</code> and
     * then returns the elements whose indexes correspond to the elements of
     * the generated permutation.
     * This technique is described, and proven to generate random samples,
     * <a href="http://www.maths.abdn.ac.uk/~igc/tch/mx4002/notes/node83.html">
     * here</a>
     * @param c Collection to sample from.
     * @param k sample size.
     * @return the random sample.
     */
    public Object[] nextSample(Collection c, int k) {
        int len = c.size();
        if (k > len) {
            throw new IllegalArgumentException
                ("sample size exceeds collection size");
        }
        if (k == 0) {
            throw new IllegalArgumentException
                ("sample size must be > 0");
        }

       Object[] objects = c.toArray();
       int[] index = nextPermutation(len, k);
       Object[] result = new Object[k];
       for (int i = 0; i < k; i++) {
           result[i] = objects[index[i]];
       }
       return result;
    }

    //------------------------Private methods----------------------------------

    /**
     * Uses a 2-cycle permutation shuffle to randomly re-order the last elements
     * of list.
     *
     * @param list list to be shuffled
     * @param end element past which shuffling begins
     */
    private void shuffle(int[] list, int end) {
        int target = 0;
        for (int i = list.length - 1 ; i >= end; i--) {
            if (i == 0) {
                target = 0;
            } else {
                target = nextInt(0, i);
            }
            int temp = list[target];
            list[target] = list[i];
            list[i] = temp;
        }
    }

    /**
     * Returns an array representing n.
     *
     * @param n the natural number to represent
     * @return array with entries = elements of n
     */
    private int[] getNatural(int n) {
        int[] natural = new int[n];
        for (int i = 0; i < n; i++) {
            natural[i] = i;
        }
        return natural;
    }
}