SSJ
V. labo.

Package umontreal.iro.lecuyer.randvar

This package provides a collection of classes for non-uniform random variate generation, primarily from standard distributions.

See:
          Description

Class Summary
BernoulliGen This class implements random variate generators for the Bernoulli distribution (see class BernoulliDist).
BetaGen BetaGen
BetaRejectionLoglogisticGen Implements Beta random variate generators using the rejection method with log-logistic envelopes.
BetaStratifiedRejectionGen BetaStratifiedRejectionGen
BetaSymmetricalBestGen This class implements symmetrical beta random variate generators using Devroye's one-liner method.
BetaSymmetricalGen BetaSymmetricalGen
BetaSymmetricalPolarGen BetaSymmetricalPolarGen
BinomialConvolutionGen BinomialConvolutionGen
BinomialGen This class implements random variate generators for the binomial distribution.
CauchyGen This class implements random variate generators for the Cauchy distribution.
ChiGen ChiGen
ChiRatioOfUniformsGen ChiRatioOfUniformsGen
ChiSquareGen ChiSquareGen
ChiSquareNoncentralGamGen ChiSquareNoncentralGamGen
ChiSquareNoncentralGen ChiSquareNoncentralGen
ChiSquareNoncentralPoisGen This class implements noncentral chi square random variate generators using Poisson and central chi square generators.
ConstantGen ConstantGen
ErlangConvolutionGen This class implements Erlang random variate generators using the convolution method.
ErlangGen This class implements random variate generators for the Erlang distribution with parameters k > 0 and λ > 0.
ExponentialGen This class implements random variate generators for the exponential distribution.
ExponentialInverseFromDensityGen ExponentialInverseFromDensityGen
ExtremeValueGen Deprecated.
FatigueLifeGen This class implements random variate generators for the fatigue life distribution with location parameter μ, scale parameter β and shape parameter γ.
FisherFGen FisherFGen
FNoncentralGen FNoncentralGen
FoldedNormalGen This class implements methods for generating random variates from the folded normal distribution with parameters μ >=  0 and σ > 0.
FrechetGen FrechetGen
GammaAcceptanceRejectionGen This class implements gamma random variate generators using a method that combines acceptance-rejection with acceptance-complement.
GammaGen This class implements random variate generators for the gamma distribution.
GammaRejectionLoglogisticGen This class implements gamma random variate generators using a rejection method with loglogistic envelopes,.
GeometricGen GeometricGen
GumbelGen This class implements methods for generating random variates from the Gumbel distribution.
HalfNormalGen HalfNormalGen
HyperbolicSecantGen This class implements random variate generators for the hyperbolic secant distribution with location parameter μ and scale parameter σ.
HypergeometricGen HypergeometricGen
HypoExponentialGen HypoExponentialGen
InverseFromDensityGen InverseFromDensityGen
InverseGammaGen This class implements random variate generators for the inverse gamma distribution with shape parameter α > 0 and scale parameter β > 0.
InverseGaussianGen InverseGaussianGen
InverseGaussianMSHGen This class implements inverse gaussian random variate generators using the many-to-one transformation method of Michael, Schucany and Haas (MHS).
JohnsonSBGen This class implements random variate generators for the Johnson SB distribution.
JohnsonSLGen This class implements random variate generators for the Johnson SL distribution.
JohnsonSUGen This class implements random variate generators for the Johnson SU distribution.
KernelDensityGen This class implements random variate generators for distributions obtained via kernel density estimation methods from a set of n individual observations x1,..., xn.
KernelDensityVarCorrectGen KernelDensityVarCorrectGen
LaplaceGen This class implements methods for generating random variates from the Laplace distribution.
LogarithmicGen This class implements random variate generators for the (discrete) logarithmic distribution.
LogisticGen LogisticGen
LoglogisticGen This class implements random variate generators for the log-logistic distribution with shape parameter α > 0 and scale parameter β > 0.
LognormalGen This class implements methods for generating random variates from the lognormal distribution.
LognormalSpecialGen LognormalSpecialGen
NakagamiGen NakagamiGen
NegativeBinomialGen This class implements random variate generators having the negative binomial distribution.
NormalACRGen This class implements normal random variate generators using the acceptance-complement ratio method.
NormalBoxMullerGen NormalBoxMullerGen
NormalGen This class implements methods for generating random variates from the normal distribution N(μ, σ).
NormalInverseFromDensityGen NormalInverseFromDensityGen
NormalInverseGaussianGen NormalInverseGaussianGen
NormalInverseGaussianIGGen .
NormalKindermannRamageGen This class implements normal random variate generators using the Kindermann-Ramage method.
NormalPolarGen This class implements normal random variate generators using the polar method with rejection.
ParetoGen ParetoGen
PascalConvolutionGen Implements Pascal random variate generators by the convolution method.
PascalGen PascalGen
Pearson5Gen Deprecated.
Pearson6Gen This class implements random variate generators for the Pearson type VI distribution with shape parameters α1 > 0 and α2 > 0, and scale parameter β > 0.
PoissonGen This class implements random variate generators having the Poisson distribution.
PoissonTIACGen This class implements random variate generators having the Poisson distribution (see PoissonGen).
PowerGen PowerGen
RandomVariateGen This is the base class for all random variate generators over the real line.
RandomVariateGenInt RandomVariateGenInt
RandomVariateGenWithCache This class represents a random variate generator whose values are cached for more efficiency when using common random numbers.
RayleighGen This class implements random variate generators for the Rayleigh distribution.
StudentGen This class implements methods for generating random variates from the Student distribution with n > 0 degrees of freedom.
StudentNoncentralGen This class implements random variate generators for the noncentral Student-t distribution with n > 0 degrees of freedom and noncentrality parameter δ.
StudentPolarGen This class implements Student random variate generators using the polar method of.
TriangularGen This class implements random variate generators for the triangular distribution.
UniformGen UniformGen
UniformIntGen This class implements a random variate generator for the uniform distribution over integers, over the interval [i, j].
UnuranContinuous This class permits one to create continuous univariate generators using UNURAN via its string API.
UnuranDiscreteInt This class permits one to create a discrete univariate generator using UNURAN via its string API.
UnuranEmpirical This class permits one to create generators for empirical and quasi-empirical univariate distributions using UNURAN via its string interface.
WeibullGen This class implements random variate generators for the Weibull distribution.
 

Exception Summary
UnuranException This type of unchecked exception is thrown when an error occurs inside the UNURAN package.
 

Package umontreal.iro.lecuyer.randvar Description

This package provides a collection of classes for non-uniform random variate generation, primarily from standard distributions.

Each non-uniform random variate generator requires at least one umontreal.iro.lecuyer.rngRandomStream object (from package umontreal.iro.lecuyerrng), used to generate the underlying uniform random numbers.

The generic classes umontreal.iro.lecuyer.randvarRandomVariateGen and umontreal.iro.lecuyer.randvarRandomVariateGenInt permit one to construct a random variate generator from a random stream and an arbitrary distribution (see interface umontreal.iro.lecuyer.probdistDistribution). To generate random variates by inversion from an arbitrary distribution over the real numbers using a given random stream, it suffices to construct a umontreal.iro.lecuyer.randvarRandomVariateGen object with the desired (previously created) umontreal.iro.lecuyer.probdistDistribution and umontreal.iro.lecuyer.rngRandomStream objects, and then call its umontreal.iro.lecuyer.randvarRandomVariateGennextDouble method as many times as needed. For discrete distributions over the integers, one can construct a umontreal.iro.lecuyer.randvarRandomVariateGenInt object containing the desired umontreal.iro.lecuyer.probdistDiscreteDistributionInt and umontreal.iro.lecuyer.rngRandomStream, and call its umontreal.iro.lecuyer.randvarRandomVariateGenIntnextInt method. By default, these generators simply call the umontreal.iro.lecuyer.probdistContinuousDistributioninverseF method from the specified distribution object. These two classes suffice as long as we are willing to use inversion. Here is a simple example in which we create three parallel streams of normal random variates using inversion.

[label=lst:normaltest,caption=Using three parallel streams of random normal variates,lineskip=-2pt,emph=genere,main ]exam/normaltest.java

To generate random variates by other methods than inversion, one can use specialized classes that extend umontreal.iro.lecuyer.randvarRandomVariateGen or umontreal.iro.lecuyer.randvarRandomVariateGenInt. Such classes are provided for a variety of standard discrete and continuous distributions. For example, five different subclasses implement normal random variate generators, using five different methods. One of them, the class umontreal.iro.lecuyer.randvarNormalGen, extends umontreal.iro.lecuyer.randvarRandomVariateGen directly and provides normal random variate generators based on inversion, so it does the same thing as using umontreal.iro.lecuyer.randvarRandomVariateGen with the normal distribution. The others are subclasses of umontreal.iro.lecuyer.randvarNormalGen; they implement various non-inversion normal variate generation methods. To generate random variates with a specific method, it suffices to construct an object of the appropriate subclass and then call its nextDouble method.

Après avoir examiné le code, je me rends compte que l'utilisation de use...Method n'est pas la bonne approche, car cela amène plein de case dans l'implantation, ce qui rend le code plus laid, plus compliqué et plus inefficace. Il serait probablement préférable d'utiliser des sous-classes à la place, du moins pour les méthodes non statiques. Une sous-classe pour chaque type de méthode de génération.

In most cases, the specialized classes maintain local copies of the distribution parameters and use them for variate generation. If the parameters of the contained distribution objects are later modified, this may lead to inconsistencies: the variate generator object will keep using the old values. In fact, the constructors of the specialized classes often precompute constants and tables based on these parameter values, which would have to be recomputed if the parameters are changed. On the other hand, the generic classes umontreal.iro.lecuyer.randvarRandomVariateGen and umontreal.iro.lecuyer.randvarRandomVariateGenInt call directly the inverseF method of the contained distribution object, so they will always use the new parameter values whenever the parameters in the distribution object are changed. We must make the nextInt() and nextDouble() methods as quick as possible. For example, it is better to avoid calling methods to access the parameters of the distribution object. We can store local copies of the parameters instead. We must decide exactly what we do with this and explain it clearly in the guide. If we leave it like this, it must be made clear in the documentation of each subclass and method, which parameter values are used.It seems to me that in the future, only the constructors of umontreal.iro.lecuyer.randvarRandomVariateGen and umontreal.iro.lecuyer.randvarRandomVariateGenInt should require a distribution object. In the subclasses, we should directly pass the required parameters and there would not necessarily be a distribution object created. We should examine the implications of such a change.

With some variate generation methods (e.g., the rejection method), the number of uniforms required to get a single non-uniform variate varies from one call to the next. In that case, an auxiliary stream is often used to preserve the synchronization between random variates when implementing variance-reduction methods[#!sLAW00a!#]. The main random number stream is called a fixed number of times per non-uniform variate generation. If more uniform random numbers are needed, they are obtained from the auxiliary stream. For these types of generators, two umontreal.iro.lecuyer.rngRandomStream objects should be passed to the constructor. Otherwise, by default, the same stream will be used for all uniforms.

Static methods in the specialized classes allow the generation of random variates from specific distributions without constructing a umontreal.iro.lecuyer.randvarRandomVariateGen object.

This package also provides an interface to the UNURAN (Universal Non-Uniform RANdom number generators) package, a rich library of C functions designed and implemented by the ARVAG (Automatic Random VAriate Generation) project group in Vienna[#!iLEY02a!#]. This interface can be used to access distributions or generation methods not available directly in SSJ. To get a UNURAN generator, it suffices to instantiate one of the UNURAN interface classes: umontreal.iro.lecuyer.randvarUnuranDiscreteInt for discrete random variates, umontreal.iro.lecuyer.randvarUnuranContinuous for continuous ones (in one dimension), and umontreal.iro.lecuyer.randvarUnuranEmpirical for quasi-empirical distributions based on experimental data. The type of distribution and its parameters are specified to UNURAN via its String API (see the UNURAN documentation). Only univariate distributions are supported because the UNURAN String API does not support the multivariate ones yet.

In the UNURAN interface classes, umontreal.iro.lecuyer.randvarRandomVariateGennextDouble and umontreal.iro.lecuyer.randvarRandomVariateGenIntnextInt can be invoked as usual to generate variates, but these methods are slowed down significantly by the overhead in the interactions between code on the native side and on the Java side. When several random variates are needed, it is much more efficient to generate them in a single call, via the methods umontreal.iro.lecuyer.randvarRandomVariateGennextArrayOfDouble and umontreal.iro.lecuyer.randvarRandomVariateGenIntnextArrayOfInt.


SSJ
V. labo.

To submit a bug or ask questions, send an e-mail to Pierre L'Ecuyer.