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

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

    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

    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

    Object[] nextSample(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`.