## org.apache.commons.math3.random
Interface RandomData

All Known Implementing Classes:
  RandomDataGenerator, RandomDataImpl

Deprecated. to be removed in 4.0. Use `RandomDataGenerator` directly

    public interface RandomData

Random data generation utilities.

Version:
  $Id: RandomData.java 1416643 2012-12-03 19:37:14Z tn $

Method Summary
`double` `nextExponential(double mean)` Deprecated. Generates a random value from the exponential distribution with specified mean.
`double` `nextGaussian(double mu, double sigma)` Deprecated. Generates a random value from the Normal (or Gaussian) distribution with specified mean and standard deviation.
`java.lang.String` `nextHexString(int len)` Deprecated. Generates a random string of hex characters of length `len`.
`int` `nextInt(int lower, int upper)` Deprecated. Generates a uniformly distributed random integer between `lower` and `upper` (endpoints included).
`long` `nextLong(long lower, long upper)` Deprecated. Generates a uniformly distributed random long integer between `lower` and `upper` (endpoints included).
`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.
`java.lang.Object[]` `nextSample(java.util.Collection<?> c, int k)` Deprecated. Returns an array of `k` objects selected randomly from the Collection `c`.
`java.lang.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` `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)`.

Method Detail

### nextHexString

    java.lang.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 `nextSecureHexString(int)`.

  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`

### nextInt

    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 `nextSecureInt(int, int)`.

  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

    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 `nextSecureLong(long, long)`.

  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

    java.lang.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 `nextHexString(int)`.

  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

    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, `nextInt(int, int)` should be used instead of this method.

  Definition: Secure Random Sequence

  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

    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, `nextLong(long, long)` should be used instead of this method.

  Definition: Secure Random Sequence

  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

    long nextPoisson(double mean)
                     throws NotStrictlyPositiveException

  Deprecated.
  Generates a random value from the Poisson distribution with the given mean.

  Definition: Poisson Distribution

  Parameters:
    `mean` - the mean of the Poisson distribution
  Returns:
    a random value following the specified Poisson distribution
  Throws:
    `NotStrictlyPositiveException` - if `mean <= 0`.

### nextGaussian

    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

  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

    double nextExponential(double mean)
                           throws NotStrictlyPositiveException

  Deprecated.
  Generates a random value from the exponential distribution with specified mean.

  Definition: Exponential Distribution

  Parameters:
    `mean` - the mean of the distribution
  Returns:
    a random value following the specified exponential distribution
  Throws:
    `NotStrictlyPositiveException` - if `mean <= 0`.

### nextUniform

    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.

  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

    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.

  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

### nextPermutation

    int[] nextPermutation(int n,
                          int k)
                          throws NumberIsTooLargeException,
                                 NotStrictlyPositiveException

  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.

  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:
    `NumberIsTooLargeException` - if `k > n`.
    `NotStrictlyPositiveException` - if `k <= 0`.

### nextSample

    java.lang.Object[] nextSample(java.util.Collection<?> c,
                                  int k)
                                  throws NumberIsTooLargeException,
                                         NotStrictlyPositiveException

  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`.

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

Copyright (c) 2003-2013 Apache Software Foundation