Random (JMSL Numerical Library)

Overview

Package

Class

Tree

Index

Help

JMSL^TM Numerical Library 5.0.1

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.imsl.stat
Class Random

java.lang.Object
  java.util.Random
      com.imsl.stat.Random

All Implemented Interfaces:: Serializable, Cloneable

public class Random
extends Random
implements Serializable, Cloneable
extends Random
implements Serializable, Cloneable

Generate uniform and non-uniform random number distributions.

The non-uniform distributions are generated from a uniform distribution. By default, this class uses the uniform distribution generated by the base class Random. If the multiplier is set in this class then a multiplicative congruential method is used. The form of the generator is

$x_i equiv c x_{i-1} {rm mod} (2^{31}-1)$

Each

is then scaled into the unit interval (0,1). If the multiplier, c, is a primitive root modulo $2^{31}-1$ (which is a prime), then the generator will have a maximal period of $2^{31}-2$ . There are several other considerations, however. See Knuth (1981) for a good general discussion. Possible values for c are 16807, 397204094, and 950706376. The selection is made by the method setMultiplier. Evidence suggests that the performance of 950706376 is best among these three choices (Fishman and Moore 1982).

Alternatively, one can select a 32-bit or 64-bit Mersenne Twister generator by first instantiating MersenneTwister or MersenneTwister64. These generators have a period of $2^{19937}-1$ and a 623-dimensional equidistribution property. See Matsumoto et al. 1998 for details.

The generation of uniform (0,1) numbers is done by the method nextDouble.

Nonuniform random numbers are generated using a variety of transformation procedures. All of the transformations used are exact (mathematically). The most straightforward transformation is the inverse CDF technique, but it is often less efficient than others involving acceptance/rejection and mixtures. See Kennedy and Gentle(1980) for discussion of these and other techniques.

Many of the nonuniform generators use different algorithms depending on the values of the parameters of the distributions. This is particularly true of the generators for discrete distributions. Schmeiser (1983) gives an overview of techniques for generating deviates from discrete distributions.

Extensive empirical tests of some of the uniform random number generators available in the Random class are reported by Fishman and Moore (1982 and 1986). Results of tests on the generator using the multiplier 16807 are reported by Learmonth and Lewis (1973). If the user wishes to perform additional tests, the routines in Chapter 17, Tests of Goodness of Fit, may be of use. Often in Monte Carlo applications, it is appropriate to construct an ad hoc test that is sensitive to departures that are important in the given application. For example, in using Monte Carlo methods to evaluate a one-dimensional integral, autocorrelations of order one may not be harmful, but they may be disastrous in evaluating a two-dimensional integral. Although generally the routines in this chapter for generating random deviates from nonuniform distributions use exact methods, and, hence, their quality depends almost solely on the quality of the underlying uniform generator, it is often advisable to employ an ad hoc test of goodness of fit for the transformations that are to be applied to the deviates from the nonuniform generator.

See Also:: Example, Serialized Form

Nested Class Summary
`static interface`	`Random.BaseGenerator` Base pseudorandom number.

Constructor Summary
`Random()` Constructor for the Random number generator class.
`Random(long seed)` Constructor for the Random number generator class with supplied seed.
`Random(Random.BaseGenerator baseGenerator)` Constructor for the Random number generator class with an alternate basic number generator.

Method Summary
`protected int`	`next(int bits)` Generates the next pseudorandom number.
`double`	`nextBeta(double p, double q)` Generate a pseudorandom number from a beta distribution.
`int`	`nextBinomial(int n, double p)` Generate a pseudorandom number from a binomial distribution.
`double`	`nextCauchy()` Generates a pseudorandom number from a Cauchy distribution.
`double`	`nextChiSquared(double df)` Generates a pseudorandom number from a Chi-squared distribution.
`double`	`nextExponential()` Generates a pseudorandom number from a standard exponential distribution.
`double`	`nextExponentialMix(double theta1, double theta2, double p)` Generate a pseudorandom number from a mixture of two exponential distributions.
`double`	`nextExtremeValue(double mu, double beta)` Generate a pseudorandom number from an extreme value distribution.
`double`	`nextF(double dfn, double dfd)` Generate a pseudorandom number from the F distribution.
`double`	`nextGamma(double a)` Generates a pseudorandom number from a standard gamma distribution.
`int`	`nextGeometric(double p)` Generate a pseudorandom number from a geometric distribution.
`int`	`nextHypergeometric(int n, int m, int l)` Generate a pseudorandom number from a hypergeometric distribution.
`int`	`nextLogarithmic(double a)` Generate a pseudorandom number from a logarithmic distribution.
`double`	`nextLogNormal(double mean, double stdev)` Generate a pseudorandom number from a lognormal distribution.
`double[]`	`nextMultivariateNormal(int k, Cholesky matrix)` Generate pseudorandom numbers from a multivariate normal distribution.
`int`	`nextNegativeBinomial(double rk, double p)` Generate a pseudorandom number from a negative binomial distribution.
`double`	`nextNormal()` Generate a pseudorandom number from a standard normal distribution using an inverse CDF method.
`double`	`nextNormalAR()` Generate a pseudorandom number from a standard normal distribution using an acceptance/rejection method.
`int`	`nextPoisson(double theta)` Generate a pseudorandom number from a Poisson distribution.
`double`	`nextRayleigh(double alpha)` Generate a pseudorandom number from a Rayleigh distribution.
`double`	`nextStudentsT(double df)` Generate a pseudorandom number from a Student's t distribution.
`double`	`nextTriangular()` Generate a pseudorandom number from a triangular distribution on the interval (0,1).
`double`	`nextVonMises(double c)` Generate a pseudorandom number from a von Mises distribution.
`double`	`nextWeibull(double a)` Generate a pseudorandom number from a Weibull distribution.
`void`	`setMultiplier(int multiplier)` Sets the multiplier for a linear congruential random number generator.
`void`	`setSeed(long seed)` Sets the seed.
`void`	`skip(int n)` Resets the seed to skip ahead in the base linear congruential generator.

Methods inherited from class java.util.Random
`nextBoolean, nextBytes, nextDouble, nextFloat, nextGaussian, nextInt, nextInt, nextLong`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

Random

public Random()

Constructor for the Random number generator class.

Random

public Random(long seed)

Constructor for the Random number generator class with supplied seed.

Parameters:: seed - a long which represents the random number generator seed

Random

public Random(Random.BaseGenerator baseGenerator)

Constructor for the Random number generator class with an alternate basic number generator.

Parameters:: baseGenerator - is used to override the method next.

Method Detail

protected int next(int bits)

Generates the next pseudorandom number. If an alternate base generator was set in the constructor, its next method is used. If the multiplier is set then the multiplicative congruential method is used. Otherwise, super.next(bits) is used.

Overrides:: next in class Random

Parameters:: bits - is the number of random bits required.
Returns:: the next pseudorandom value from this random number generator's sequence.

nextBeta

public double nextBeta(double p,
                       double q)

Generate a pseudorandom number from a beta distribution.

Method nextBeta generates pseudorandom numbers from a beta distribution with parameters p and q, both of which must be positive. The probability density function is

$fleft( x right) = frac{{Gamma left( {p + q} right)}}{{Gamma left( p right)Gamma left( q right)}}x^{p - 1} left( {1 - x} right)^{q - 1,,,,} ,, for,0 le x le 1$

where is the gamma function.

The algorithm used depends on the values of p and q. Except for the trivial cases of p = 1 or q = 1, in which the inverse CDF method is used, all of the methods use acceptance/rejection. If p and q are both less than 1, the method of Johnk (1964) is used; if either p or q is less than 1 and the other is greater than 1, the method of Atkinson (1979) is used; if both p and q are greater than 1, algorithm BB of Cheng (1978), which requires very little setup time, is used.

The value returned is less than 1.0 and greater than , where is the smallest positive number such that is less than 1.0.

Parameters:: p - a double, the first beta distribution parameter, p > 0; q - a double, the second beta distribution parameter, q > 0
Returns:: a double, a pseudorandom number from a beta distribution
See Also:: Example

nextBinomial

public int nextBinomial(int n,
                        double p)

Generate a pseudorandom number from a binomial distribution.

nextBinomial generates pseudorandom numbers from a binomial distribution with parameters n and p. n and p must be positive, and p must be less than 1. The probability function (with n = n and p = p) is

$fleft( x right) = left( {_x^n } right)p^x left( {1 - p} right)^{n - x}$

for .

The algorithm used depends on the values of n and p. If or if p is less than a machine epsilon, the inverse CDF technique is used; otherwise, the BTPE algorithm of Kachitvichyanukul and Schmeiser (see Kachitvichyanukul 1982) is used. This is an acceptance/rejection method using a composition of four regions. (TPE equals Triangle, Parallelogram, Exponential, left and right.)

Parameters:: n - an int, the number of Bernoulli trials.; p - a double, the probability of success on each trial, .
Returns:: an int, the pseudorandom number from a binomial distribution.
See Also:: Example

nextCauchy

public double nextCauchy()

Generates a pseudorandom number from a Cauchy distribution. The probability density function is

$fleft( x right) = frac{1}{pi (1 + x^2 )}$

Use of the inverse CDF technique would yield a Cauchy deviate from a uniform (0, 1) deviate, u, as . Rather than evaluating a tangent directly, however, nextCauchy generates two uniform (-1, 1) deviates, and . These values can be thought of as sine and cosine values. If

is less than or equal to 1, then is delivered as the Cauchy deviate; otherwise, and are rejected and two new uniform (-1, 1) deviates are generated. This method is also equivalent to taking the ratio of two independent normal deviates.

Deviates from the Cauchy distribution with median t and first quartile t - s, that is, with density

$fleft( x right) = frac{s}{{pi left[ {s^2 + left( {x - t} right)^2 } right]}}$

can be obtained by scaling the output from nextCauchy. To do this, first scale the output from nextCauchy by S and then add T to the result.

Returns:: a double, a pseudorandom number from a Cauchy distribution
See Also:: Example

nextChiSquared

public double nextChiSquared(double df)

Generates a pseudorandom number from a Chi-squared distribution.

nextChiSquared generates pseudorandom numbers from a chi-squared distribution with df degrees of freedom. If df is an even integer less than 17, the chi-squared deviate r is generated as

$r = - 2ln left( {mathop Pi limits_{i = 1}^n } u_i right)$

where and the are independent random deviates from a uniform (0, 1) distribution. If df is an odd integer less than 17, the chi-squared deviate is generated in the same way, except the square of a normal deviate is added to the expression above. If df is greater than 16 or is not an integer, and if it is not too large to cause overflow in the gamma random number generator, the chi-squared deviate is generated as a special case of a gamma deviate, using nextGamma. If overflow would occur in nextGamma, the chi-squared deviate is generated in the manner described above, using the logarithm of the product of uniforms, but scaling the quantities to prevent underflow and overflow.

Parameters:: df - a double which specifies the number of degrees of freedom. It must be positive.
Returns:: a double, a pseudorandom number from a Chi-squared distribution.
See Also:: Example

nextExponential

public double nextExponential()

Generates a pseudorandom number from a standard exponential distribution. The probability density function is $f(x) = e^{-x}$ ; for

nextExponential uses an antithetic inverse CDF technique; that is, a uniform random deviate U is generated and the inverse of the exponential cumulative distribution function is evaluated at 1.0 - U to yield the exponential deviate.

Deviates from the exponential distribution with mean can be generated by using nextExponential and then multiplying the result by .

Returns:: a double which specifies a pseudorandom number from a standard exponential distribution
See Also:: Example

nextExponentialMix

public double nextExponentialMix(double theta1,
                                 double theta2,
                                 double p)

Generate a pseudorandom number from a mixture of two exponential distributions. The probability density function is

$fleft( x right) = frac{p}{theta }e^{ - x/theta _1 } + frac{{1 - p}}{{theta _2 }}e^{ - x/theta _2 } ,,, for,x > 0$

where , , and .

In the case of a convex mixture, that is, the case , the mixing parameter p is interpretable as a probability; and nextExponentialMix with probability p generates an exponential deviate with mean , and with probability 1 - p generates an exponential with mean . When p is greater than 1, but less than , then either an exponential deviate with mean or the sum of two exponentials with means and is generated. The probabilities are and 1 - q, respectively, for the single exponential and the sum of the two exponentials.

Parameters:: theta1 - a double which specifies the mean of the exponential distribution that has the larger mean.; theta2 - a double which specifies the mean of the exponential distribution that has the smaller mean. theta2 must be positive and less than or equal to theta1.; p - a double which specifies the mixing parameter. It must satisfy .
Returns:: a double, a pseudorandom number from a mixture of the two exponential distributions.
See Also:: Example

nextExtremeValue

public double nextExtremeValue(double mu,
                               double beta)

Generate a pseudorandom number from an extreme value distribution.

Parameters:: mu - a double scalar value representing the location parameter.; beta - a double scalar value representing the scale parameter.
Returns:: a double pseudorandom number from an extreme value distribution
See Also:: Example

nextF

public double nextF(double dfn,
                    double dfd)

Generate a pseudorandom number from the F distribution.

Parameters:: dfn - a double, the numerator degrees of freedom. It must be positive.; dfd - a double, the denominator degrees of freedom. It must be positive.
Returns:: a double, a pseudorandom number from an F distribution
See Also:: Example

nextGamma

public double nextGamma(double a)

Generates a pseudorandom number from a standard gamma distribution.

Method nextGamma generates pseudorandom numbers from a gamma distribution with shape parameter a. The probability density function is

$P = frac{1}{{Gamma left( a right)}}int_o^x {e^{ - t} } t^{a - 1} dt$

Various computational algorithms are used depending on the value of the shape parameter a. For the special case of a = 0.5, squared and halved normal deviates are used; and for the special case of a = 1.0, exponential deviates (from method nextExponential) are used. Otherwise, if a is less than 1.0, an acceptance-rejection method due to Ahrens, described in Ahrens and Dieter (1974), is used; if a is greater than 1.0, a ten-region rejection procedure developed by Schmeiser and Lal (1980) is used.

The Erlang distribution is a standard gamma distribution with the shape parameter having a value equal to a positive integer; hence, nextGamma generates pseudorandom deviates from an Erlang distribution with no modifications required.

Parameters:: a - a double, the shape parameter of the gamma distribution. It must be positive.
Returns:: a double, a pseudorandom number from a standard gamma distribution
See Also:: Example

nextGeometric

public int nextGeometric(double p)

Generate a pseudorandom number from a geometric distribution.

nextGeometric generates pseudorandom numbers from a geometric distribution with parameter p, where P =p is the probability of getting a success on any trial. A geometric deviate can be interpreted as the number of trials until the first success (including the trial in which the first success is obtained). The probability function is

$f(x) = P(1 - P)^{x - 1}$

for and

The geometric distribution as defined above has mean 1/P.

The i-th geometric deviate is generated as the smallest integer not less than , where the are independent uniform (0, 1) random numbers (see Knuth, 1981).

The geometric distribution is often defined on 0, 1, 2, ..., with mean (1 - P)/P. Such deviates can be obtained by subtracting 1 from each element returned value.

Parameters:: p - a double, the probability of success on each trial, .
Returns:: an int, a pseudorandom number from a geometric distribution.
See Also:: Example

nextHypergeometric

public int nextHypergeometric(int n,
                              int m,
                              int l)

Generate a pseudorandom number from a hypergeometric distribution.

Method nextHypergeometric generates pseudorandom numbers from a hypergeometric distribution with parameters n, m, and l. The hypergeometric random variable x can be thought of as the number of items of a given type in a random sample of size n that is drawn without replacement from a population of size l containing m items of this type. The probability function is

$fleft( x right) = frac{{left( {_x^m } right)left( {_{n - x}^{l - m} } right)}}{{left( {_n^l } right)}}$

for .

If the hypergeometric probability function with parameters n, m, and l evaluated at n - l + m (or at 0 if this is negative) is greater than the machine epsilon, and less than 1.0 minus the machine epsilon, then nextHypergeometric uses the inverse CDF technique. The method recursively computes the hypergeometric probabilities, starting at and using the ratio f (x = x + 1)/f(x = x) (see Fishman 1978, page 457).

If the hypergeometric probability function is too small or too close to 1.0, then nextHypergeometric generates integer deviates uniformly in the interval , for ; and at the I-th step, if the generated deviate is less than or equal to the number of special items remaining in the lot, the occurrence of one special item is tallied and the number of remaining special items is decreased by one. This process continues until the sample size or the number of special items in the lot is reached, whichever comes first. This method can be much slower than the inverse CDF technique. The timing depends on n. If n is more than half of l (which in practical examples is rarely the case), the user may wish to modify the problem, replacing n by l - n, and to consider the deviates to be the number of special items not included in the sample.

Parameters:: n - an int which specifies the number of items in the sample, n > 0; m - an int which specifies the number of special items in the population, or lot, m > 0; l - an int which specifies the number of items in the lot, l > max(n,m)
Returns:: an int which specifies the number of special items in a sample of size n drawn without replacement from a population of size l that contains m such special items.
See Also:: Example

nextLogarithmic

public int nextLogarithmic(double a)

Generate a pseudorandom number from a logarithmic distribution.

Method nextLogarithmic generates pseudorandom numbers from a logarithmic distribution with parameter a. The probability function is

$fleft( x right) = - frac{{a^x }}{{xln left( {1 - a} right)}}$

for , and .

The methods used are described by Kemp (1981) and depend on the value of a. If a is less than 0.95, Kemp's algorithm LS, which is a "chop-down" variant of an inverse CDF technique, is used. Otherwise, Kemp's algorithm LK, which gives special treatment to the highly probable values of 1 and 2, is used.

Parameters:: a - a double which specifies the parameter of the logarithmic distribution, .
Returns:: an int, a pseudorandom number from a logarithmic distribution.
See Also:: Example

nextLogNormal

public double nextLogNormal(double mean,
                            double stdev)

Generate a pseudorandom number from a lognormal distribution.

Method nextLogNormal generates pseudorandom numbers from a lognormal distribution with parameters mean and stdev. The scale parameter in the underlying normal distribution, stdev, must be positive. The method is to generate normal deviates with mean mean and standard deviation stdev and then to exponentiate the normal deviates.

With and , the probability density function for the lognormal distribution is

$fleft( x right) = frac{1}{{sigma xsqrt {2pi } }}exp left[ { - frac{1}{{2sigma ^2 }}left( {ln x - mu } right)^2 } right],,for,x > 0$

The mean and variance of the lognormal distribution are and , respectively.

Parameters:: mean - a double which specifies the mean of the underlying normal distribution; stdev - a double which specifies the standard deviation of the underlying normal distribution. It must be positive.
Returns:: a double, a pseudorandom number from a lognormal distribution
See Also:: Example

nextMultivariateNormal

public double[] nextMultivariateNormal(int k,
                                       Cholesky matrix)

Generate pseudorandom numbers from a multivariate normal distribution.

nextMultivariateNormal generates pseudorandom numbers from a multivariate normal distribution with mean vector consisting of all zeroes and variance-covariance matrix whose Cholesky factor (or "square root") is matrix; that is, matrix is an upper triangular matrix such that the transpose of matrix times matrix is the variance-covariance matrix. First, independent random normal deviates with mean 0 and variance 1 are generated, and then the matrix containing these deviates is post-multiplied by matrix.

Deviates from a multivariate normal distribution with means other than zero can be generated by using nextMultivariateNormal and then by adding the means to the deviates.

Parameters:: k - an int which specifies the length of the multivariate normal vectors; matrix - is the Cholesky factorization of the variance-covariance matrix of order k
Returns:: a double array which contains the pseudorandom numbers from a multivariate normal distribution
See Also:: Example

nextNegativeBinomial

public int nextNegativeBinomial(double rk,
                                double p)

Generate a pseudorandom number from a negative binomial distribution.

Method nextNegativeBinomial generates pseudorandom numbers from a negative binomial distribution with parameters and . and must be positive and p must be less than 1. The probability function with ( and ) is

$fleft( x right) = left( begin{array}{c} r + x - 1 \ x \ end{array} right)left( {1 - p} right)^r p^x$

for .

If r is an integer, the distribution is often called the Pascal distribution and can be thought of as modeling the length of a sequence of Bernoulli trials until r successes are obtained, where p is the probability of getting a success on any trial. In this form, the random variable takes values r, r + 1, and can be obtained from the negative binomial random variable defined above by adding r to the negative binomial variable. This latter form is also equivalent to the sum of r geometric random variables defined as taking values .

If rp/(1 - p) is less than 100 and is greater than the machine epsilon, nextNegativeBinomial uses the inverse CDF technique; otherwise, for each negative binomial deviate, nextNegativeBinomial generates a gamma (r, p/(1 - p)) deviate y and then generates a Poisson deviate with parameter y.

Parameters:: rk - a double which specifies the negative binomial parameter, rk > 0; p - a double which specifies the probability of success on each trial. It must be greater than machine precision and less than one.
Returns:: an int which specifies the pseudorandom number from a negative binomial distribution. If rk is an integer, the deviate can be thought of as the number of failures in a sequence of Bernoulli trials before rk successes occur.
See Also:: Example

nextNormal

public double nextNormal()

Generate a pseudorandom number from a standard normal distribution using an inverse CDF method. In this method, a uniform (0,1) random deviate is generated, then the inverse of the normal distribution function is evaluated at that point using inverseNormal. This method is slower than the acceptance/rejection technique used in the nextNormalAR to generate standard normal deviates. Deviates from the normal distribution with mean

and standard deviation $x_{std}$ can be obtained by scaling the output from nextNormal. To do this first scale the output of nextNormal by $x_{std}$ and then add

to the result.

Returns:: a double which represents a pseudorandom number from a standard normal distribution
See Also:: Example

nextNormalAR

public double nextNormalAR()

Generate a pseudorandom number from a standard normal distribution using an acceptance/rejection method.

nextNormalAR generates pseudorandom numbers from a standard normal (Gaussian) distribution using an acceptance/rejection technique due to Kinderman and Ramage (1976). In this method, the normal density is represented as a mixture of densities over which a variety of acceptance/rejection methods due to Marsaglia (1964), Marsaglia and Bray (1964), and Marsaglia, MacLaren, and Bray (1964) are applied. This method is faster than the inverse CDF technique used in nextNormal to generate standard normal deviates.

Deviates from the normal distribution with mean and standard deviation $x_{std}$ can be obtained by scaling the output from nextNormalAR. To do this first scale the output of nextNormalAR by $x_{std}$ and then add to the result.

Returns:: a double which represents a pseudorandom number from a standard normal distribution
See Also:: Example

nextPoisson

public int nextPoisson(double theta)

Generate a pseudorandom number from a Poisson distribution.

Method nextPoisson generates pseudorandom numbers from a Poisson distribution with parameter theta. theta, which is the mean of the Poisson random variable, must be positive. The probability function (with ) is

$f(x) = e^{ - {rm{theta}}} , {rm{theta}}^{x} /x !$

for

If theta is less than 15, nextPoisson uses an inverse CDF method; otherwise the PTPE method of Schmeiser and Kachitvichyanukul (1981) (see also Schmeiser 1983) is used.

The PTPE method uses a composition of four regions, a triangle, a parallelogram, and two negative exponentials. In each region except the triangle, acceptance/rejection is used. The execution time of the method is essentially insensitive to the mean of the Poisson.

Parameters:: theta - a double which specifies the mean of the Poisson distribution, theta > 0
Returns:: an int, a pseudorandom number from a Poisson distribution
See Also:: Example

nextRayleigh

public double nextRayleigh(double alpha)

Generate a pseudorandom number from a Rayleigh distribution.

Method nextRayleigh generates pseudorandom numbers from a Rayleigh distribution with scale parameter alpha.

Parameters:: alpha - a double which specifies the scale parameter of the Rayleigh distribution
Returns:: a double, a pseudorandom number from a Rayleigh distribution
See Also:: Example

nextStudentsT

public double nextStudentsT(double df)

Generate a pseudorandom number from a Student's t distribution.

nextStudentsT generates pseudo-random numbers from a Student's t distribution with df degrees of freedom, using a method suggested by Kinderman, Monahan, and Ramage (1977). The method ("TMX" in the reference) involves a representation of the t density as the sum of a triangular density over (-2, 2) and the difference of this and the t density. The mixing probabilities depend on the degrees of freedom of the t distribution. If the triangular density is chosen, the variate is generated as the sum of two uniforms; otherwise, an acceptance/rejection method is used to generate a variate from the difference density.

For degrees of freedom less than 100, nextStudentsT requires approximately twice the execution time as nextNormalAR, which generates pseudorandom normal deviates. The execution time of nextStudentsT increases very slowly as the degrees of freedom increase. Since for very large degrees of freedom the normal distribution and the t distribution are very similar, the user may find that the difference in the normal and the t does not warrant the additional generation time required to use nextStudentsT instead of nextNormalAR.

Parameters:: df - a double which specifies the number of degrees of freedom. It must be positive.
Returns:: a double, a pseudorandom number from a Student's t distribution
See Also:: Example

nextTriangular

public double nextTriangular()

Generate a pseudorandom number from a triangular distribution on the interval (0,1). The probability density function is

, for

, and

, for

. nextTriangular uses an inverse CDF technique.

Returns:: a double, a pseudorandom number from a triangular distribution on the interval (0,1)
See Also:: Example

nextVonMises

public double nextVonMises(double c)

Generate a pseudorandom number from a von Mises distribution.

Method nextVonMises generates pseudorandom numbers from a von Mises distribution with parameter c, which must be positive. With c = C, the probability density function is

$fleft( x right) = frac{1}{{2pi I_0 left( c right)}}exp left[ {c,cos left( x right)} right],for, - pi lt x lt pi$

where is the modified Bessel function of the first kind of order 0. The probability density equals 0 outside the interval .

The algorithm is an acceptance/rejection method using a wrapped Cauchy distribution as the majorizing distribution. It is due to Best and Fisher (1979).

Parameters:: c - a double which specifies the parameter of the von Mises distribution, $c gt 7.4 times 10^{-9}$ .
Returns:: a double, a pseudorandom number from a von Mises distribution
See Also:: Example

nextWeibull

public double nextWeibull(double a)

Generate a pseudorandom number from a Weibull distribution.

Method nextWeibull generates pseudorandom numbers from a Weibull distribution with shape parameter a. The probability density function is

$fleft( x right) = Ax^{A - 1} e^{ - x^A } ,for,x ge 0$

nextWeibull uses an antithetic inverse CDF technique to generate a Weibull variate; that is, a uniform random deviate U is generated and the inverse of the Weibull cumulative distribution function is evaluated at 1.0 - u to yield the Weibull deviate.

Deviates from the two-parameter Weibull distribution, with shape parameter a and scale parameter b, can be generated by using nextWeibull and then multiplying the result by b.

The Rayleigh distribution with probability density function,

$rleft( x right) = frac{1}{{alpha ^2 }}x, e^{left( { - x^2 /2alpha ^2 } right)} ,,for,x ge 0$

is the same as a Weibull distribution with shape parameter a equal to 2 and scale parameter b equal to

hence, nextWeibull and simple multiplication can be used to generate Rayleigh deviates.

Parameters:: a - a double which specifies the shape parameter of the Weibull distribution, a > 0
Returns:: a double, a pseudorandom number from a Weibull distribution
See Also:: Example

setMultiplier

public void setMultiplier(int multiplier)

Sets the multiplier for a linear congruential random number generator. If a multiplier is set then the linear congruential generator, defined in the base class java.util.Random, is replaced by the generator
seed = (multiplier*seed) mod $(2^{31}-1)$
See Donald Knuth, The Art of Computer Programming, Volume 2, for guidelines in choosing a multiplier. Some possible values are 16807, 397204094, 950706376.

Parameters:: multiplier - an int which represents the random number generator multiplier

setSeed

public void setSeed(long seed)

Sets the seed.

Overrides:: setSeed in class Random

Parameters:: seed - a long which represents the random number generator seed

skip

public void skip(int n)

Resets the seed to skip ahead in the base linear congruential generator. This method can be used only if a linear congruential multiplier is explicitly defined by a call to setMultiplier. The method skips ahead in the deviates returned by the protected method next. The public methods use next(int) as their source of uniform random deviates. Some methods call it more than once. For instance, each call to nextDouble calls it twice.

Parameters:: n - is the number of random deviates to skip.

Overview

Package

Class

Tree

Index

Help

JMSL^TM Numerical Library 5.0.1

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.imsl.stat Class Random

Random

Random

Random

next

nextBeta

nextBinomial

nextCauchy

nextChiSquared

nextExponential

nextExponentialMix

nextExtremeValue

nextF

nextGamma

nextGeometric

nextHypergeometric

nextLogarithmic

nextLogNormal

nextMultivariateNormal

nextNegativeBinomial

nextNormal

nextNormalAR

nextPoisson

nextRayleigh

nextStudentsT

nextTriangular

nextVonMises

nextWeibull

setMultiplier

setSeed

skip

com.imsl.stat
Class Random