Random (JMSL Numerical Library)

Overview

Package

Class

Tree

Index

Help

JMSL^TM Numerical Library 6.0

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.

Three methods are associated with copulas. A copula is a multivariate cumulative probability distribution (CDF) whose arguments are random variables uniformly distributed on the interval [0,1] corresponding to the probabilities (variates) associated with arbitrarily distributed marginal deviates. The copula structure allows the multivariate CDF to be partitioned into the copula, which has associated with it information characterizing the dependence among the marginal variables, and the set of separate marginal deviates, each of which has its own distribution structure.

Two methods, nextGaussianCopula and nextStudentsTCopula, allow the user to specify a correlation structure (in the form of a Cholesky matrix) which can be used to imprint correlation information on a sequence of multivariate random vectors. Each call to one of these methods returns a random vector whose elements (variates) are each uniformly distributed on the interval [0,1] and correlated according to a user-specified Cholesky matrix. These variate vector sequences may then be inverted to marginal deviate sequences whose distributions and imprinted correlations are user-specified. Method nextGaussianCopula generates a random Gaussian copula sequence by inverting uniform [0,1] random numbers to N(0,1) deviates vectors, imprinting each vector with the correlation information by multiplying it with the Cholesky matrix, and then using the N(0,1) CDF to map the imprinted deviates back to uniform [0,1] variates. Method nextStudentsTCopula inverts a vector of uniform [0,1] random numbers to a Student's t deviate vector with mean 0 and user specified degrees of freedom df which is then imprinted with the Cholesky matrix and mapped back to uniform [0,1] variates.

The third copula method, canonicalCorrelation, extracts a correlation matrix from a sequence of multivariate deviate vectors whose component marginals are arbitrarily distributed. This is accomplished by first extracting the empirical CDF from each of the marginal deviates and then using this CDF to map the deviates to uniform [0,1] variates which are then inverted to Normal (0,1) deviates. Each element $C_{ij}$ of the correlation matrix can then be extracted by averaging the products $z_{it} z_{jt}$ of deviates i and j over the t-indexed sequence. The utility of method canonicalCorrelation is that because the correlation matrix is derived from N(0,1) deviates, the correlation is unbiased, i.e. undistorted by the arbitrary marginal distribution structures of the original deviate vector sequences. This is important in such financial applications as portfolio optimization, where correlation is used to estimate and minimize risk.

The use of these routines is illustrated with RandomEx2.java, which first uses method nextGaussianCopula to create a correlation imprinted sequence of random deviate vectors and then uses method canonicalCorrelation to extract the correlation matrix from the imprinted sequence of vectors.

See Also:: Example 1, Example 2, 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
`static double[][]`	`canonicalCorrelation(double[][] deviate)` Method `canonicalCorrelation` generates a canonical correlation matrix from an arbitrarily distributed multivariate deviate sequence with `nvar` deviate variables, `nseq` steps in the sequence, and a Gaussian Copula dependence structure.
`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.
`double[]`	`nextGaussianCopula(int k, Cholesky chol)` Generate pseudorandom numbers from a Gaussian Copula 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.
`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[]`	`nextStudentsTCopula(int k, double df, Cholesky chol)` Generate pseudorandom numbers from a Student's t Copula 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.
`double`	`nextZigguratNormalAR()` Generates pseudorandom numbers using the Ziggurat method.
`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

canonicalCorrelation

public static double[][] canonicalCorrelation(double[][] deviate)

Method canonicalCorrelation generates a canonical correlation matrix from an arbitrarily distributed multivariate deviate sequence with nvar deviate variables, nseq steps in the sequence, and a Gaussian Copula dependence structure.

Method canonicalCorrelation first maps each of the j=1..nvar input deviate sequences deviate[k=1..nseq][j] into a corresponding sequence of variates, say variate[k][j] (where variates are values of the empirical cumulative probability function, , defined as the probability that random deviate variable , and where nseq = deviate.length and nvar = deviate[0].length). The variate matrix variate[k][j] is then mapped into Normal(0,1) distributed deviates $z_{kj}$ using the method Cdf.inverseNormal(variate[k][j]) and then the standard covariance estimator

$C_{ij} ;; = ;; frac{1}{n_{seq}};sum_{k = 1}^{n_{seq}} {z_{ki} ; z_{kj}}$

is used to calculate the canonical correlation matrix correlation = canonicalCorrelation(deviate), where $C_{ij}$ = correlation[i][j] and $n_{seq}$ = nseq.

If a multivariate distribution has Gaussian marginal distributions, then the standard "empirical" correlation matrix given above is "unbiased", i.e. an accurate measure of dependence among the variables. But when the marginal distributions depart significantly from Gaussian, i.e. are skewed or flattened, then the empirical correlation may become biased. One way to remove such bias from dependence measures is to map the non-Gaussian-distributed marginal deviates to Gaussian N(0,1) deviates (by mapping the non-Gaussian marginal deviates to empirically derived marginal CDF variate values, then inverting the variates to N(0,1) deviates as described above), and calculating the standard empirical correlation matrix from these N(0,1) deviates as in the equation above. The resulting "(Gaussian) canonical correlation" matrix thereby avoids the bias that would occur if the empirical correlation matrix were extracted from the non-Gaussian marginal distributions directly.

The canonical correlation matrix may be of value in such applications as Markowitz porfolio optimization, where an unbiased measure of dependence is required to evaluate portfolio risk, defined in terms of the portfolio variance which is in turn defined in terms of the correlation among the component portfolio instruments.

The utility of the canonical correlation derives from the observation that a "copula" multivariate distribution with uniformly-distributed deviates (corresponding to the CDF probabilities associated with the marginal deviates) may be mapped to arbitrarily distributed marginals, so that an unbiased dependence estimator derived from one set of marginals (N(0,1) distributed marginals) can be used to represent the dependence associated with arbitrarily-distributed marginals. The "Gaussian Copula" (whose variate arguments are derived from N(0,1) marginal deviates) is a particularly useful structure for representing multivariate dependence.

This is demonstrated in Example 2 where method Random.nextGaussianCopula(nvar, CholeskyMtrx) (where CholeskyMtrx is a Cholesky object derived from a user-specified covariance matrix) is used to imprint correlation information on otherwise arbitrarily distributed and independent random sequences. Method Random.canonicalCorrelation is then used to extract an unbiased correlation matrix from these imprinted deviate sequences.

Parameters:: deviate - is the double nseq by nvar array of input deviate values.
See Also:: Example

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

nextGaussianCopula

public double[] nextGaussianCopula(int k,
                                   Cholesky chol)

Generate pseudorandom numbers from a Gaussian Copula distribution.

nextGaussianCopula generates pseudorandom numbers from a multivariate Gaussian Copula distribution which are uniformly distributed on the interval (0,1) representing the probabilities associated with N(0,1) deviates imprinted with correlation information from input Cholesky object chol. Cholesky matrix R is defined as the "square root" of a user-defined correlation matrix, that is R is an upper triangular matrix such that the transpose of R times R is the correlation matrix. First, a length k vector of independent random normal deviates with mean 0 and variance 1 is generated, and then this deviate vector is post-multiplied by cholesky matrix R. Finally, the Cholesky-imprinted random N(0,1) deviates are mapped to output probabilities using the N(0,1) cumulative distribution function (CDF).

Random deviates from arbitrary marginal distributions which are imprinted with the correlation information contained in Cholesky matrix R can then be generated by inverting the output probabilities using user-specified inverse CDF functions.

Parameters:: k - an int which specifies the length of the multivariate Gaussian Copula vectors.; chol - is the Cholesky object containing the Cholesky factorization of the correlation matrix of order k.
Returns:: a double array which contains the pseudorandom numbers from a multivariate Gaussian Copula distribution.
See Also:: Example 2

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

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

nextStudentsTCopula

public double[] nextStudentsTCopula(int k,
                                    double df,
                                    Cholesky chol)

Generate pseudorandom numbers from a Student's t Copula distribution.

nextStudentsTCopula generates pseudorandom numbers from a multivariate Student's t Copula distribution which are uniformly distributed on the interval (0,1) representing the probabilities associated with deviates from Student's t distributions with df degrees of freedom imprinted with correlation information from the input Cholesky object chol. Cholesky matrix R is defined as the "square root" of a user-defined correlation matrix, that is R is an upper triangular matrix such that the transpose of R times R is the correlation matrix. First, a length k vector of independent random Student's t deviates with mean 0 and df degrees of freedom is generated, and then this deviate vector is post-multiplied by Cholesky matrix R. Finally, the Cholesky-imprinted random Student's t deviates are mapped to output probabilities using the Student's t cumulative distribution function (CDF) with df degrees of freedom.

Parameters:: k - an int which specifies the length of the multivariate Student's t Copula vectors.; df - a double which specifies the degrees of freedom parameter.; chol - the Cholesky object containing the Cholesky factorization of the correlation matrix of order k.
Returns:: a double array which contains the pseudorandom numbers from a multivariate Students t Copula distribution with df degrees of freedom.

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

nextZigguratNormalAR

public double nextZigguratNormalAR()

Generates pseudorandom numbers using the Ziggurat method.

The nextZigguratNormalAR method cuts the density into many small pieces. For each random number generated, an interval is chosen at random and a random normal is generated from the choosen interval. In this implementation, the density is cut into 256 pieces, but symmetry is used so that only 128 pieces are needed by the computation. Following Doornik (2005), different uniform random deviates are used to determine which slice to use and to determine the normal deviate from the slice.

Returns:: a double containing the random normal deviate.

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 6.0

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.imsl.stat Class Random

Random

Random

Random

canonicalCorrelation

next

nextBeta

nextBinomial

nextCauchy

nextChiSquared

nextExponential

nextExponentialMix

nextExtremeValue

nextF

nextGamma

nextGaussianCopula

nextGeometric

nextHypergeometric

nextLogarithmic

nextLogNormal

nextMultivariateNormal

nextNegativeBinomial

nextNormal

nextPoisson

nextRayleigh

nextStudentsT

nextStudentsTCopula

nextTriangular

nextVonMises

nextWeibull

nextZigguratNormalAR

setMultiplier

setSeed

skip

com.imsl.stat
Class Random