org.apache.commons.math3.random
Class RandomDataImpl

java.lang.Object
  extended by org.apache.commons.math3.random.RandomDataImpl
All Implemented Interfaces:
Serializable, RandomData

Deprecated. to be removed in 4.0. Use RandomDataGenerator instead

@Deprecated
public class RandomDataImpl
extends Object
implements RandomData, Serializable

Generates random deviates and other random data using a RandomGenerator instance to generate non-secure data and a SecureRandom instance to provide data for the nextSecureXxx methods. If no RandomGenerator is provided in the constructor, the default is to use a Well19937c generator. To plug in a different implementation, either implement RandomGenerator directly or extend AbstractRandomGenerator.

Supports reseeding the underlying pseudo-random number generator (PRNG). The SecurityProvider and Algorithm used by the SecureRandom instance can also be reset.

For details on the default PRNGs, see Random and SecureRandom.

Usage Notes:

Version:
$Id: RandomDataImpl.java 1421917 2012-12-14 15:05:18Z erans $
See Also:
Serialized Form

Constructor Summary
RandomDataImpl()
          Deprecated. Construct a RandomDataImpl, using a default random generator as the source of randomness.
RandomDataImpl(RandomGenerator rand)
          Deprecated. Construct a RandomDataImpl using the supplied RandomGenerator as the source of (non-secure) random data.
 
Method Summary
 double nextBeta(double alpha, double beta)
          Deprecated. Generates a random value from the Beta Distribution.
 int nextBinomial(int numberOfTrials, double probabilityOfSuccess)
          Deprecated. Generates a random value from the Binomial Distribution.
 double nextCauchy(double median, double scale)
          Deprecated. Generates a random value from the Cauchy Distribution.
 double nextChiSquare(double df)
          Deprecated. Generates a random value from the ChiSquare Distribution.
 double nextExponential(double mean)
          Deprecated. Generates a random value from the exponential distribution with specified mean.
 double nextF(double numeratorDf, double denominatorDf)
          Deprecated. Generates a random value from the F Distribution.
 double nextGamma(double shape, double scale)
          Deprecated. Generates a random value from the Gamma Distribution.
 double nextGaussian(double mu, double sigma)
          Deprecated. Generates a random value from the Normal (or Gaussian) distribution with specified mean and standard deviation.
 String nextHexString(int len)
          Deprecated. Generates a random string of hex characters of length len.
 int nextHypergeometric(int populationSize, int numberOfSuccesses, int sampleSize)
          Deprecated. Generates a random value from the Hypergeometric Distribution.
 int nextInt(int lower, int upper)
          Deprecated. Generates a uniformly distributed random integer between lower and upper (endpoints included).
 int nextInversionDeviate(IntegerDistribution distribution)
          Deprecated. use the distribution's sample() method
 double nextInversionDeviate(RealDistribution distribution)
          Deprecated. use the distribution's sample() method
 long nextLong(long lower, long upper)
          Deprecated. Generates a uniformly distributed random long integer between lower and upper (endpoints included).
 int nextPascal(int r, double p)
          Deprecated. Generates a random value from the Pascal Distribution.
 int[] nextPermutation(int n, int k)
          Deprecated. Generates an integer array of length k whose entries are selected randomly, without repetition, from the integers 0, ..., n - 1 (inclusive).
 long nextPoisson(double mean)
          Deprecated. Generates a random value from the Poisson distribution with the given mean.
 Object[] nextSample(Collection<?> c, int k)
          Deprecated. Returns an array of k objects selected randomly from the Collection c.
 String nextSecureHexString(int len)
          Deprecated. Generates a random string of hex characters from a secure random sequence.
 int nextSecureInt(int lower, int upper)
          Deprecated. Generates a uniformly distributed random integer between lower and upper (endpoints included) from a secure random sequence.
 long nextSecureLong(long lower, long upper)
          Deprecated. Generates a uniformly distributed random long integer between lower and upper (endpoints included) from a secure random sequence.
 double nextT(double df)
          Deprecated. Generates a random value from the T Distribution.
 double nextUniform(double lower, double upper)
          Deprecated. Generates a uniformly distributed random value from the open interval (lower, upper) (i.e., endpoints excluded).
 double nextUniform(double lower, double upper, boolean lowerInclusive)
          Deprecated. Generates a uniformly distributed random value from the interval (lower, upper) or the interval [lower, upper).
 double nextWeibull(double shape, double scale)
          Deprecated. Generates a random value from the Weibull Distribution.
 int nextZipf(int numberOfElements, double exponent)
          Deprecated. Generates a random value from the Zipf Distribution.
 void reSeed()
          Deprecated. Reseeds the random number generator with System.currentTimeMillis() + System.identityHashCode(this)).
 void reSeed(long seed)
          Deprecated. Reseeds the random number generator with the supplied seed.
 void reSeedSecure()
          Deprecated. Reseeds the secure random number generator with the current time in milliseconds.
 void reSeedSecure(long seed)
          Deprecated. Reseeds the secure random number generator with the supplied seed.
 void setSecureAlgorithm(String algorithm, String provider)
          Deprecated. Sets the PRNG algorithm for the underlying SecureRandom instance using the Security Provider API.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

RandomDataImpl

public RandomDataImpl()
Deprecated. 
Construct a RandomDataImpl, using a default random generator as the source of randomness.

The default generator is a Well19937c seeded with System.currentTimeMillis() + System.identityHashCode(this)). The generator is initialized and seeded on first use.


RandomDataImpl

public RandomDataImpl(RandomGenerator rand)
Deprecated. 
Construct a RandomDataImpl using the supplied RandomGenerator as the source of (non-secure) random data.

Parameters:
rand - the source of (non-secure) random data (may be null, resulting in the default generator)
Since:
1.1
Method Detail

nextHexString

public String nextHexString(int len)
                     throws NotStrictlyPositiveException
Deprecated. 
Generates a random string of hex characters of length len.

The generated string will be random, but not cryptographically secure. To generate cryptographically secure strings, use RandomData.nextSecureHexString(int).

Algorithm Description: hex strings are generated using a 2-step process.

  1. len / 2 + 1 binary bytes are generated using the underlying Random
  2. Each binary byte is translated into 2 hex digits

Specified by:
nextHexString in interface RandomData
Parameters:
len - the desired string length.
Returns:
the random string.
Throws:
NotStrictlyPositiveException - if len <= 0.

nextInt

public int nextInt(int lower,
                   int upper)
            throws NumberIsTooLargeException
Deprecated. 
Generates a uniformly distributed random integer between lower and upper (endpoints included).

The generated integer will be random, but not cryptographically secure. To generate cryptographically secure integer sequences, use RandomData.nextSecureInt(int, int).

Specified by:
nextInt in interface RandomData
Parameters:
lower - lower bound for generated integer
upper - upper bound for generated integer
Returns:
a random integer greater than or equal to lower and less than or equal to upper
Throws:
NumberIsTooLargeException - if lower >= upper

nextLong

public long nextLong(long lower,
                     long upper)
              throws NumberIsTooLargeException
Deprecated. 
Generates a uniformly distributed random long integer between lower and upper (endpoints included).

The generated long integer values will be random, but not cryptographically secure. To generate cryptographically secure sequences of longs, use RandomData.nextSecureLong(long, long).

Specified by:
nextLong in interface RandomData
Parameters:
lower - lower bound for generated long integer
upper - upper bound for generated long integer
Returns:
a random long integer greater than or equal to lower and less than or equal to upper
Throws:
NumberIsTooLargeException - if lower >= upper

nextSecureHexString

public String nextSecureHexString(int len)
                           throws NotStrictlyPositiveException
Deprecated. 
Generates a random string of hex characters from a secure random sequence.

If cryptographic security is not required, use RandomData.nextHexString(int).

Algorithm Description: hex strings are generated in 40-byte segments using a 3-step process.

  1. 20 random bytes are generated using the underlying SecureRandom.
  2. SHA-1 hash is applied to yield a 20-byte binary digest.
  3. Each byte of the binary digest is converted to 2 hex digits.

Specified by:
nextSecureHexString in interface RandomData
Parameters:
len - the length of the string to be generated
Returns:
a random string of hex characters of length len
Throws:
NotStrictlyPositiveException - if len <= 0

nextSecureInt

public int nextSecureInt(int lower,
                         int upper)
                  throws NumberIsTooLargeException
Deprecated. 
Generates a uniformly distributed random integer between lower and upper (endpoints included) from a secure random sequence.

Sequences of integers generated using this method will be cryptographically secure. If cryptographic security is not required, RandomData.nextInt(int, int) should be used instead of this method.

Definition: Secure Random Sequence

Specified by:
nextSecureInt in interface RandomData
Parameters:
lower - lower bound for generated integer
upper - upper bound for generated integer
Returns:
a random integer greater than or equal to lower and less than or equal to upper.
Throws:
NumberIsTooLargeException - if lower >= upper.

nextSecureLong

public long nextSecureLong(long lower,
                           long upper)
                    throws NumberIsTooLargeException
Deprecated. 
Generates a uniformly distributed random long integer between lower and upper (endpoints included) from a secure random sequence.

Sequences of long values generated using this method will be cryptographically secure. If cryptographic security is not required, RandomData.nextLong(long, long) should be used instead of this method.

Definition: Secure Random Sequence

Specified by:
nextSecureLong in interface RandomData
Parameters:
lower - lower bound for generated integer
upper - upper bound for generated integer
Returns:
a random long integer greater than or equal to lower and less than or equal to upper.
Throws:
NumberIsTooLargeException - if lower >= upper.

nextPoisson

public long nextPoisson(double mean)
                 throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the Poisson distribution with the given mean.

Definition: Poisson Distribution

Algorithm Description:

Specified by:
nextPoisson in interface RandomData
Parameters:
mean - the mean of the Poisson distribution
Returns:
a random value following the specified Poisson distribution
Throws:
NotStrictlyPositiveException - if mean <= 0.

nextGaussian

public double nextGaussian(double mu,
                           double sigma)
                    throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the Normal (or Gaussian) distribution with specified mean and standard deviation.

Definition: Normal Distribution

Specified by:
nextGaussian in interface RandomData
Parameters:
mu - the mean of the distribution
sigma - the standard deviation of the distribution
Returns:
a random value following the specified Gaussian distribution
Throws:
NotStrictlyPositiveException - if sigma <= 0.

nextExponential

public double nextExponential(double mean)
                       throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the exponential distribution with specified mean.

Definition: Exponential Distribution

Algorithm Description: Uses the Algorithm SA (Ahrens) from p. 876 in: [1]: Ahrens, J. H. and Dieter, U. (1972). Computer methods for sampling from the exponential and normal distributions. Communications of the ACM, 15, 873-882.

Specified by:
nextExponential in interface RandomData
Parameters:
mean - the mean of the distribution
Returns:
a random value following the specified exponential distribution
Throws:
NotStrictlyPositiveException - if mean <= 0.

nextUniform

public double nextUniform(double lower,
                          double upper)
                   throws NumberIsTooLargeException,
                          NotFiniteNumberException,
                          NotANumberException
Deprecated. 
Generates a uniformly distributed random value from the open interval (lower, upper) (i.e., endpoints excluded).

Definition: Uniform Distribution lower and upper - lower are the location and scale parameters, respectively.

Algorithm Description: 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).

Specified by:
nextUniform in interface RandomData
Parameters:
lower - the exclusive lower bound of the support
upper - the exclusive upper bound of the support
Returns:
a uniformly distributed random value between lower and upper (exclusive)
Throws:
NumberIsTooLargeException - if lower >= upper
NotFiniteNumberException - if one of the bounds is infinite
NotANumberException - if one of the bounds is NaN

nextUniform

public double nextUniform(double lower,
                          double upper,
                          boolean lowerInclusive)
                   throws NumberIsTooLargeException,
                          NotFiniteNumberException,
                          NotANumberException
Deprecated. 
Generates a uniformly distributed random value from the interval (lower, upper) or the interval [lower, upper). The lower bound is thus optionally included, while the upper bound is always excluded.

Definition: Uniform Distribution lower and upper - lower are the location and scale parameters, respectively.

Algorithm Description: if the lower bound is excluded, 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).

Specified by:
nextUniform in interface RandomData
Parameters:
lower - the lower bound of the support
upper - the exclusive upper bound of the support
lowerInclusive - true if the lower bound is inclusive
Returns:
uniformly distributed random value in the (lower, upper) interval, if lowerInclusive is false, or in the [lower, upper) interval, if lowerInclusive is true
Throws:
NumberIsTooLargeException - if lower >= upper
NotFiniteNumberException - if one of the bounds is infinite
NotANumberException - if one of the bounds is NaN
Since:
3.0

nextBeta

public double nextBeta(double alpha,
                       double beta)
Deprecated. 
Generates a random value from the Beta Distribution. This implementation uses inversion to generate random values.

Parameters:
alpha - first distribution shape parameter
beta - second distribution shape parameter
Returns:
random value sampled from the beta(alpha, beta) distribution
Since:
2.2

nextBinomial

public int nextBinomial(int numberOfTrials,
                        double probabilityOfSuccess)
Deprecated. 
Generates a random value from the Binomial Distribution. This implementation uses inversion to generate random values.

Parameters:
numberOfTrials - number of trials of the Binomial distribution
probabilityOfSuccess - probability of success of the Binomial distribution
Returns:
random value sampled from the Binomial(numberOfTrials, probabilityOfSuccess) distribution
Since:
2.2

nextCauchy

public double nextCauchy(double median,
                         double scale)
Deprecated. 
Generates a random value from the Cauchy Distribution. This implementation uses inversion to generate random values.

Parameters:
median - the median of the Cauchy distribution
scale - the scale parameter of the Cauchy distribution
Returns:
random value sampled from the Cauchy(median, scale) distribution
Since:
2.2

nextChiSquare

public double nextChiSquare(double df)
Deprecated. 
Generates a random value from the ChiSquare Distribution. This implementation uses inversion to generate random values.

Parameters:
df - the degrees of freedom of the ChiSquare distribution
Returns:
random value sampled from the ChiSquare(df) distribution
Since:
2.2

nextF

public double nextF(double numeratorDf,
                    double denominatorDf)
             throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the F Distribution. This implementation uses inversion to generate random values.

Parameters:
numeratorDf - the numerator degrees of freedom of the F distribution
denominatorDf - the denominator degrees of freedom of the F distribution
Returns:
random value sampled from the F(numeratorDf, denominatorDf) distribution
Throws:
NotStrictlyPositiveException - if numeratorDf <= 0 or denominatorDf <= 0.
Since:
2.2

nextGamma

public double nextGamma(double shape,
                        double scale)
                 throws NotStrictlyPositiveException
Deprecated. 

Generates a random value from the Gamma Distribution.

This implementation uses the following algorithms:

For 0 < shape < 1:
Ahrens, J. H. and Dieter, U., Computer methods for sampling from gamma, beta, Poisson and binomial distributions. Computing, 12, 223-246, 1974.

For shape >= 1:
Marsaglia and Tsang, A Simple Method for Generating Gamma Variables. ACM Transactions on Mathematical Software, Volume 26 Issue 3, September, 2000.

Parameters:
shape - the median of the Gamma distribution
scale - the scale parameter of the Gamma distribution
Returns:
random value sampled from the Gamma(shape, scale) distribution
Throws:
NotStrictlyPositiveException - if shape <= 0 or scale <= 0.
Since:
2.2

nextHypergeometric

public int nextHypergeometric(int populationSize,
                              int numberOfSuccesses,
                              int sampleSize)
                       throws NotPositiveException,
                              NotStrictlyPositiveException,
                              NumberIsTooLargeException
Deprecated. 
Generates a random value from the Hypergeometric Distribution. This implementation uses inversion to generate random values.

Parameters:
populationSize - the population size of the Hypergeometric distribution
numberOfSuccesses - number of successes in the population of the Hypergeometric distribution
sampleSize - the sample size of the Hypergeometric distribution
Returns:
random value sampled from the Hypergeometric(numberOfSuccesses, sampleSize) distribution
Throws:
NumberIsTooLargeException - if numberOfSuccesses > populationSize, or sampleSize > populationSize.
NotStrictlyPositiveException - if populationSize <= 0.
NotPositiveException - if numberOfSuccesses < 0.
Since:
2.2

nextPascal

public int nextPascal(int r,
                      double p)
               throws NotStrictlyPositiveException,
                      OutOfRangeException
Deprecated. 
Generates a random value from the Pascal Distribution. This implementation uses inversion to generate random values.

Parameters:
r - the number of successes of the Pascal distribution
p - the probability of success of the Pascal distribution
Returns:
random value sampled from the Pascal(r, p) distribution
Throws:
NotStrictlyPositiveException - if the number of successes is not positive
OutOfRangeException - if the probability of success is not in the range [0, 1].
Since:
2.2

nextT

public double nextT(double df)
             throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the T Distribution. This implementation uses inversion to generate random values.

Parameters:
df - the degrees of freedom of the T distribution
Returns:
random value from the T(df) distribution
Throws:
NotStrictlyPositiveException - if df <= 0
Since:
2.2

nextWeibull

public double nextWeibull(double shape,
                          double scale)
                   throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the Weibull Distribution. This implementation uses inversion to generate random values.

Parameters:
shape - the shape parameter of the Weibull distribution
scale - the scale parameter of the Weibull distribution
Returns:
random value sampled from the Weibull(shape, size) distribution
Throws:
NotStrictlyPositiveException - if shape <= 0 or scale <= 0.
Since:
2.2

nextZipf

public int nextZipf(int numberOfElements,
                    double exponent)
             throws NotStrictlyPositiveException
Deprecated. 
Generates a random value from the Zipf Distribution. This implementation uses inversion to generate random values.

Parameters:
numberOfElements - the number of elements of the ZipfDistribution
exponent - the exponent of the ZipfDistribution
Returns:
random value sampled from the Zipf(numberOfElements, exponent) distribution
Throws:
NotStrictlyPositiveException - if numberOfElements <= 0 or exponent <= 0.
Since:
2.2

reSeed

public void reSeed(long seed)
Deprecated. 
Reseeds the random number generator with the supplied seed.

Will create and initialize if null.

Parameters:
seed - the seed value to use

reSeedSecure

public void reSeedSecure()
Deprecated. 
Reseeds the secure random number generator with the current time in milliseconds.

Will create and initialize if null.


reSeedSecure

public void reSeedSecure(long seed)
Deprecated. 
Reseeds the secure random number generator with the supplied seed.

Will create and initialize if null.

Parameters:
seed - the seed value to use

reSeed

public void reSeed()
Deprecated. 
Reseeds the random number generator with System.currentTimeMillis() + System.identityHashCode(this)).


setSecureAlgorithm

public void setSecureAlgorithm(String algorithm,
                               String provider)
                        throws NoSuchAlgorithmException,
                               NoSuchProviderException
Deprecated. 
Sets the PRNG algorithm for the underlying SecureRandom instance using the Security Provider API. The Security Provider API is defined in Java Cryptography Architecture API Specification & Reference.

USAGE NOTE: This method carries significant overhead and may take several seconds to execute.

Parameters:
algorithm - the name of the PRNG algorithm
provider - the name of the provider
Throws:
NoSuchAlgorithmException - if the specified algorithm is not available
NoSuchProviderException - if the specified provider is not installed

nextPermutation

public int[] nextPermutation(int n,
                             int k)
                      throws NotStrictlyPositiveException,
                             NumberIsTooLargeException
Deprecated. 
Generates an integer array of length k whose entries are selected randomly, without repetition, from the integers 0, ..., n - 1 (inclusive).

Generated arrays represent permutations of n taken k at a time.

Uses a 2-cycle permutation shuffle. The shuffling process is described here.

Specified by:
nextPermutation in interface RandomData
Parameters:
n - the domain of the permutation
k - the size of the permutation
Returns:
a random k-permutation of n, as an array of integers
Throws:
NotStrictlyPositiveException - if k <= 0.
NumberIsTooLargeException - if k > n.

nextSample

public Object[] nextSample(Collection<?> c,
                           int k)
                    throws NotStrictlyPositiveException,
                           NumberIsTooLargeException
Deprecated. 
Returns an array of k objects selected randomly from the Collection c.

Sampling from c is without replacement; but if c contains identical objects, the sample may include repeats. If all elements of c are distinct, the resulting object array represents a Simple Random Sample of size k from the elements of c.

Algorithm Description: Uses a 2-cycle permutation shuffle to generate a random permutation of c.size() 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 here

Specified by:
nextSample in interface RandomData
Parameters:
c - the collection to be sampled
k - the size of the sample
Returns:
a random sample of k elements from c
Throws:
NotStrictlyPositiveException - if k <= 0.
NumberIsTooLargeException - if k > c.size().

nextInversionDeviate

public double nextInversionDeviate(RealDistribution distribution)
                            throws MathIllegalArgumentException
Deprecated. use the distribution's sample() method

Generate a random deviate from the given distribution using the inversion method.

Parameters:
distribution - Continuous distribution to generate a random value from
Returns:
a random value sampled from the given distribution
Throws:
MathIllegalArgumentException - if the underlynig distribution throws one
Since:
2.2

nextInversionDeviate

public int nextInversionDeviate(IntegerDistribution distribution)
                         throws MathIllegalArgumentException
Deprecated. use the distribution's sample() method

Generate a random deviate from the given distribution using the inversion method.

Parameters:
distribution - Integer distribution to generate a random value from
Returns:
a random value sampled from the given distribution
Throws:
MathIllegalArgumentException - if the underlynig distribution throws one
Since:
2.2


Copyright © 2003-2012 The Apache Software Foundation. All Rights Reserved.