| ▶CAbstractChrono | AbstractChrono is a class that acts as an interface to the system clock and calculates the CPU or system time consumed by parts of a program |
| CChrono | The Chrono class extends the umontreal.ssj.util.AbstractChrono class and computes the CPU time for the current thread only |
| CChronoSingleThread | This class is deprecated but kept for compatibility with older versions of SSJ |
| CGlobalCPUTimeChrono | Extends the AbstractChrono class to compute the global CPU time used by the Java Virtual Machine |
| CSystemTimeChrono | Extends the AbstractChrono class to compute the total system time using Java’s builtin System.nanoTime |
| CThreadCPUTimeChrono | Extends the AbstractChrono class to compute the CPU time for a single thread |
| CAnova | This class automates the process of replicating estimators of the ANOVA variances |
| CAnovaObserver | ANOVA observer |
| ▶CAppendable | |
| CPrintfFormat | This class acts like a StringBuffer which defines new types of append methods |
| CArithmeticMod | This class provides facilities to compute multiplications of scalars, of vectors and of matrices modulo m |
| ▶CArrayOfComparableChains< T extends MarkovChainComparable > | This class provides tools to simulate an array of MarkovChainComparable objects with the array-RQMC method of [139], [141] |
| CArrayOfDoubleChains | Similar to ArrayOfComparableChains, except that instead of working with \(n\) clones of a MarkovChain, we use a single MarkovChainDouble object for all the chains |
| CArrayOfObservationListener | Represents an object that can listen to observations broadcast by lists of statistical probes |
| ▶CAsianGBM | |
| CAsianGBMQMC | |
| CNewTestAsianRQMC | |
| CAxis | Represents an axis of a chart encapsulated by an instance of XYChart |
| CBankEv | |
| CCallCenter.Call | |
| CCallCenter | |
| ▶CCategoryChart | This class provides tools to create charts from data in a simple way |
| CBoxChart | This class provides tools to create and manage box-and-whisker plots |
| ▶CCharSequence | |
| CPrintfFormat | This class acts like a StringBuffer which defines new types of append methods |
| ▶CCloneable | |
| CCustomHistogramDataset | A dataset that can be used for creating histograms |
| CEmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| ▶CPolynomial | Represents a polynomial of degree \(n\) in power form |
| CPolInterp | Represents a polynomial that interpolates through a set of points |
| ▶CMarkovChain | This class defines a generic Markov chain and provides basic tools to simulate it for a given number of steps or until it stops, and to recover the performance measure |
| ▶CMarkovChainComparable | A subclass of MarkovChain for which there is a total ordering between the states, induced by the implementation of the umontreal.ssj.util.MultiDimComparable interface |
| CMarkovChainDouble | A special kind of Markov chain whose state space is a subset of the real numbers |
| ▶CCloneableRandomStream | CloneableRandomStream extends RandomStream and Cloneable |
| CRandMrg | USE MRG32k3a INSTEAD of this class |
| ▶CRandomStreamBase | This class provides a convenient foundation on which RNGs can be built |
| CSplitStream | Implements a random stream that mixes two input streams by using a coordinate mask |
| CGenF2w32 | Implements the RandomStream interface via inheritance from RandomStreamBase |
| CLFSR113 | Extends RandomStreamBase using a composite linear feedback shift register (LFSR) (or Tausworthe) RNG as defined in [147], [229] |
| CLFSR258 | Extends RandomStreamBase using a 64-bit composite linear feedback shift register (LFSR) (or Tausworthe) RNG as defined in [147], [229] |
| CMRG31k3p | Extends the abstract class RandomStreamBase, thus implementing the RandomStream interface indirectly |
| CMRG32k3a | Extends the abstract class RandomStreamBase by using as a backbone (or main) generator the combined multiple recursive generator (CMRG) MRG32k3a proposed by L’Ecuyer [148] , implemented in 64-bit floating-point arithmetic |
| CMRG32k3aL | The same generator as MRG32k3a, except here it is implemented with type long instead of double |
| CMT19937 | Implements the RandomStream interface via inheritance from RandomStreamBase |
| CRandRijndael | Implements a RNG using the Rijndael block cipher algorithm (AES) with key and block lengths of 128 bits |
| CWELL1024 | Implements the RandomStream interface via inheritance from RandomStreamBase |
| CWELL512 | This class implements the RandomStream interface via inheritance from RandomStreamBase |
| ▶CWELL607base | |
| CF2NL607 | Implements the RandomStream interface by using as a backbone generator the combination of the WELL607 proposed in [199], [198] (and implemented in WELL607 ) with a nonlinear generator |
| CWELL607 | This class implements the RandomStream interface via inheritance from RandomStreamBase |
| CAccumulate | A subclass of umontreal.ssj.stat.StatProbe, for collecting statistics on a variable that evolves in simulation time, with a piecewise-constant trajectory |
| ▶CFunctionOfMultipleMeansTally | Represents a statistical collector for estimating a function of multiple means with a confidence interval based on the delta theorem [214] |
| CFunctionOfMultipleMeansTallyWithCV | Represents a function of multiple means tally for an estimator with linear control variables |
| CHistogramOnly | This class is similar to TallyHistogram, except that it does not maintain the min, max, average, and variance of the observations |
| CListOfStatProbes< E extends StatProbe > | Represents a list of statistical probes that can be managed simultaneously |
| CMatrixOfStatProbes< E extends StatProbe > | Represents a matrix of statistical probes that can be managed simultaneously |
| ▶CTally | A subclass of StatProbe |
| CPartialVariance | Represents the partial variance of a function with respect to a given coordinate set |
| ▶CTallyHistogram | This class extends Tally |
| CHistogramOnly | This class is similar to TallyHistogram, except that it does not maintain the min, max, average, and variance of the observations |
| CTallyStore | This class is a variant of Tally for which the individual observations are stored in a list implemented as a DoubleArrayList |
| CBitMatrix | This class implements matrices of bits of arbitrary dimensions |
| CBitVector | This class implements vectors of bits and the operations needed to use them |
| CClassFinder | Utility class used to convert a simple class name to a fully qualified class object |
| CCollision | |
| ▶CComparable | |
| CPartialVariance | Represents the partial variance of a function with respect to a given coordinate set |
| ▶CEvent | This abstract class provides event scheduling tools |
| CBankEv.Arrival | |
| CBankEv.Departure | |
| CCallCenter.Arrival | |
| CCallCenter.CallCompletion | |
| CCallCenter.NextPeriod | |
| CPreyPred.EndOfSim | |
| CPreyPred.PrintPoint | |
| CQueueEv.Arrival | |
| CQueueEv.Departure | |
| CQueueEv.EndOfSim | |
| CCompareOutputs | |
| ▶CContinuous | Represents a variable in a continuous-time simulation |
| CPreyPred.Preds | |
| CPreyPred.Preys | |
| CContinuousDistChart | This class provides tools to plot the density and the cumulative probability of a continuous probability distribution |
| ▶CContinuousDistributionMulti | Classes implementing continuous multi-dimensional distributions should inherit from this class |
| ▶CContinuousDistribution2Dim | Classes implementing 2-dimensional continuous distributions should inherit from this class |
| ▶CBiNormalDist | Extends the class ContinuousDistribution2Dim for the bivariate normal distribution [98] (page 84) |
| CBiNormalDonnellyDist | Extends the class BiNormalDist for the bivariate normal distribution [98] (page 84) using a translation of Donnelly’s Fortran code in [53] |
| CBiNormalGenzDist | Extends the class BiNormalDist for the bivariate normal distribution [98] (page 84) using Genz’s algorithm as described in [67] |
| CBiStudentDist | Extends the class ContinuousDistribution2Dim for the standard bivariate Student’s \(t\) distribution [98] (page 132) |
| CDirichletDist | Implements the abstract class ContinuousDistributionMulti for the Dirichlet distribution with parameters ( \(\alpha_1\),…, \(\alpha_d\)), \(\alpha_i > 0\) |
| CMultiNormalDist | Implements the abstract class ContinuousDistributionMulti for the multinormal distribution with mean vector \(\boldsymbol{\mu}\) and covariance matrix \(\boldsymbol{\Sigma}\) |
| CContinuousState | Represents the portion of the simulator’s state associated with continuous-time simulation |
| ▶CCoordinateSet | Represents a set of coordinates |
| CCoordinateSetLong | Implementation of CoordinateSet using a long bit-mask internal representation |
| CQueueEv.Customer | |
| CDataField | This class represents a data field from a file read by an instance of a class implementing DataReader |
| ▶CDataReader | Data reader interface |
| ▶CAbstractDataReader | This abstract class implements shared functionality for data readers |
| CBinaryDataReader | Binary data reader |
| ▶CDataWriter | Data writer interface |
| ▶CAbstractDataWriter | This abstract class implements shared functionality for data writers |
| CBinaryDataWriter | Binary data writer |
| ▶CCachedDataWriter | This abstract class implements shared functionality for data writers that store all fields in memory before outputing them with umontreal.ssj.util.io.DataWriter.close |
| CTextDataWriter | Text data writer |
| ▶CDefaultPointSetIterator | |
| ▶CContainerPointSet.ContainerPointSetIterator | |
| CAntitheticPointSet.AntitheticPointSetIterator | |
| CBakerTransformedPointSet.BakerTransformedPointSetIterator | |
| ▶CCycleBasedPointSet.CycleBasedPointSetIterator | |
| CCycleBasedPointSetBase2.CycleBasedPointSetBase2Iterator | |
| ▶CDensityEstimator | This abstract class represents a univariate density estimator (DE) |
| CDEHistogram | Histogram density estimator for a univariate density |
| CDEKernelDensity | This class provides methods to construct a kernel density estimator (KDE) for univariate densities from a set of \(n\) individual observations \(x_0,\dots, x_{n-1}\), and to evaluate it at a single point or at a set of selected evaluation points |
| ▶CDensityDerivativeEstimator | This class implements a density derivative estimator (DDE) based on a kernel density estimator (KDE) with a sufficiently smooth kernel function \(k\), see umontreal.ssj.stat.density.DEKernelDensity |
| CDEDerivativeGaussian | This class implements a density derivative estimator (DDE) with a Gaussian ( i.e., standard normal) kernel function |
| ▶CDigitalNetBase2Iterator | |
| CDigitalSequenceBase2.DigitalNetBase2IteratorShiftGenerators | |
| CDigitalSequenceBase2.DigitalNetBase2IteratorShiftNoGray | |
| ▶CDigitalNetIterator | |
| ▶CDigitalNetBase2.DigitalNetBase2Iterator | |
| CDigitalNetBase2.DigitalNetBase2IteratorNoGray | |
| CDigitalSequence.DigitalNetIteratorShiftGenerators | |
| CDigitalSequence.DigitalNetIteratorShiftNoGray | |
| ▶CDiscrepancy | This abstract class is the base class of all discrepancy classes |
| ▶CBigDiscrepancy | This abstract class is the base class of all discrepancy classes programmed with floating-point numbers with multi-precision |
| ▶CBigDiscShiftBaker1 | This class computes the same discrepancy as in umontreal.ssj.discrepancy.DiscShiftBaker1 [see eq |
| CBigDiscShiftBaker1Lattice | This class computes the same discrepancy as in umontreal.ssj.discrepancy.DiscShiftBaker1Lattice [see eq |
| CDiscL2Hickernell | This class computes the Hickernell \(\mathcal{L}_2\)-star discrepancy in [81] (eq |
| CDiscL2Star | This class computes the traditional \(\mathcal{L}_2\)-star discrepancy \(\mathcal{D}_2^*(\mathcal{P})\) for a set of \(n\) points \(\mathcal{P}\) [236], [237], [83] |
| CDiscL2Symmetric | COMPLÉTER LA DOC ICI |
| CDiscL2Unanchored | A discrepancy is said to be reflection-invariant if it has the same value when the points are reflected through any plane \(x_j= 1/2\), passing through the center of the unit hypercube, i.e |
| ▶CDiscShift1 | This class computes the discrepancy for randomly shifted points of a set \(\mathcal{P}\) [84] (eq |
| CDiscShift1Lattice | This class computes the same discrepancy for randomly shifted points of a set \(\mathcal{L}\) as given in eq |
| ▶CDiscShift2 | This class computes the discrepancy in [84] (eq |
| CDiscShift2Lattice | This class computes the same discrepancy for randomly shifted points of a set \(\mathcal{L}\) as given in eq |
| ▶CDiscShiftBaker1 | This class computes the discrepancy for randomly shifted, then baker folded points of a set \(\mathcal{P}\) |
| CDiscShiftBaker1Lattice | This class computes the same discrepancy in [84] (eq |
| CPalpha | Extends the class Discrepancy and implements the methods required to compute the \(P_{\alpha}\) figure of merit for a lattice point set \(\Psi_s\) which is the intersection of a lattice \(L\) and the unit hypercube \([0, 1)^s\) in \(s\) dimensions |
| CDiscrepancyContainer | This class is used to compute, store and display discrepancies |
| CDiscreteDistIntChart | This class provides tools to plot the mass function and the cumulative probability of a discrete probability distribution over the integers |
| ▶CDiscreteDistributionIntMulti | Classes implementing multi-dimensional discrete distributions over the integers should inherit from this class |
| CMultinomialDist | Implements the abstract class DiscreteDistributionIntMulti for the multinomial distribution with parameters \(n\) and ( \(p_1\), …, \(p_d\)) |
| CNegativeMultinomialDist | Implements the class DiscreteDistributionIntMulti for the negative multinomial distribution with parameters \(n > 0\) and ( \(p_1, …, p_d\)) such that all \(0<p_i<1\) and \(\sum_{i=1}^d p_i < 1\) |
| ▶CDistribution | This interface should be implemented by all classes supporting discrete and continuous distributions |
| ▶CContinuousDistribution | Classes implementing continuous distributions should inherit from this base class |
| ▶CAndersonDarlingDist | Extends the class ContinuousDistribution for the Anderson–Darling distribution (see [6], [165], [173], [225] ) |
| CAndersonDarlingDistQuick | Extends the class AndersonDarlingDist for the Anderson–Darling distribution (see [6], [165], [225] ) |
| ▶CBetaDist | Extends the class ContinuousDistribution for the beta distribution [100] (page 210) with shape parameters \(\alpha> 0\) and \(\beta> 0\), over the interval \([a,b]\), where \(a < b\) |
| CBetaSymmetricalDist | Specializes the class BetaDist to the case of a symmetrical beta distribution over the interval \([0,1]\), with shape parameters \(\alpha= \beta\) |
| CCauchyDist | Extends the class ContinuousDistribution for the Cauchy distribution [99] (page 299) with location parameter \(\alpha\) and scale parameter \(\beta> 0\) |
| CChiDist | Extends the class ContinuousDistribution for the chi distribution [99] (page 417) with shape parameter \(\nu > 0\), where the number of degrees of freedom \(\nu\) is a positive integer |
| ▶CChiSquareDist | Extends the class ContinuousDistribution for the chi-square distribution with \(n\) degrees of freedom, where \(n\) is a positive integer [99] (page 416) |
| CChiSquareDistQuick | Provides a variant of ChiSquareDist with faster but less accurate methods |
| CChiSquareNoncentralDist | Extends the class ContinuousDistribution for the noncentral chi-square distribution with \(\nu\) degrees of freedom and noncentrality parameter \(\lambda\), where \(\nu> 0\) and \(\lambda> 0\) [100] (page 436) |
| CCramerVonMisesDist | Extends the class ContinuousDistribution for the Cramér-von Mises distribution (see [55], [224], [225] ) |
| ▶CExponentialDist | Extends the class ContinuousDistribution for the exponential distribution [99] (page 494) with mean \(1/\lambda\) where \(\lambda> 0\) |
| CExponentialDistFromMean | Extends the ExponentialDist class with a constructor accepting as argument the mean \(1/\lambda\) instead of the rate \(\lambda\) |
| CExtremeValueDist | This class has been replaced by GumbelDist |
| CFatigueLifeDist | Extends the class ContinuousDistribution for the fatigue life distribution [20] with location parameter \(\mu\), scale parameter \(\beta\) and shape parameter \(\gamma\) |
| CFisherFDist | Extends the class ContinuousDistribution for the Fisher F distribution with \(n_1\) and \(n_2\) degrees of freedom, where \(n_1\) and \(n_2\) are positive integers |
| CFoldedNormalDist | Extends the class ContinuousDistribution for the folded normal distribution with parameters \(\mu\ge0\) and \(\sigma> 0\) |
| CFrechetDist | Extends the class ContinuousDistribution for the Fréchet distribution [100] (page 3), with location parameter \(\delta\), scale parameter \(\beta> 0\), and shape parameter \(\alpha> 0\), where we use the notation \(z = (x-\delta)/\beta\) |
| ▶CGammaDist | Extends the class ContinuousDistribution for the gamma distribution [99] (page 337) with shape parameter \(\alpha> 0\) and scale parameter \(\lambda> 0\) |
| CErlangDist | Extends the class GammaDist for the special case of the Erlang distribution with shape parameter \(k > 0\) and scale parameter \(\lambda> 0\) |
| CGammaDistFromMoments | Extends the GammaDist distribution with constructors accepting the mean \(\mu\) and variance \(\sigma^2\) as arguments instead of a shape parameter \(\alpha\) and a scale parameter \(\lambda\) |
| CGumbelDist | Extends the class ContinuousDistribution for the Gumbel distribution [100] (page 2), with location parameter \(\delta\) and scale parameter \(\beta\neq0\) |
| CHalfNormalDist | Extends the class ContinuousDistribution for the half-normal distribution with parameters \(\mu\) and \(\sigma> 0\) |
| CHyperbolicSecantDist | Extends the class ContinuousDistribution for the hyperbolic secant distribution with location parameter \(\mu\) and scale parameter \(\sigma> 0\) |
| ▶CHypoExponentialDist | This class implements the hypoexponential distribution, also called the generalized Erlang distribution |
| CHypoExponentialDistEqual | This class implements the hypoexponential distribution for the case of equidistant \(\lambda_i = (n+1-i)h\) |
| CHypoExponentialDistQuick | This class is a subclass of HypoExponentialDist and also implements the hypoexponential distribution |
| CInverseDistFromDensity | Implements a method for computing the inverse of an arbitrary continuous distribution function when only the probability density is known [43] |
| CInverseGammaDist | Extends the class ContinuousDistribution for the inverse gamma distribution with shape parameter \(\alpha> 0\) and scale parameter \(\beta> 0\), also known as the Pearson type V distribution |
| CInverseGaussianDist | Extends the class ContinuousDistribution for the inverse Gaussian distribution with location parameter \(\mu> 0\) and scale parameter \(\lambda> 0\) |
| ▶CJohnsonSystem | This class contains common parameters and methods for the Johnson system of distributions [101], [99] with shape parameters \(\gamma\) and \(\delta> 0\), location parameter \(\xi\), and scale parameter \(\lambda>0\) |
| CJohnsonSBDist | Extends the class ContinuousDistribution for the Johnson \(S_B\) distribution [101], [118], [63] with shape parameters \(\gamma\) and \(\delta> 0\), location parameter \(\xi\), and scale parameter \(\lambda>0\) |
| CJohnsonSLDist | Extends the class ContinuousDistribution for the Johnson \(S_L\) distribution (see [101], [99] ) |
| CJohnsonSUDist | Extends the class ContinuousDistribution for the Johnson \(S_U\) distribution (see [118] (page 316)) |
| ▶CKolmogorovSmirnovDist | Extends the class ContinuousDistribution for the Kolmogorov-Smirnov distribution with parameter \(n\) [55] |
| CKolmogorovSmirnovDistQuick | Extends the class KolmogorovSmirnovDist for the Kolmogorov–Smirnov distribution |
| CKolmogorovSmirnovPlusDist | Extends the class ContinuousDistribution for the Kolmogorov–Smirnov+ distribution (see [40], [55], [27] ) |
| CLaplaceDist | Extends the class ContinuousDistribution for the Laplace distribution (see, e.g., [100] (page 165)) |
| CLogisticDist | Extends the class ContinuousDistribution for the logistic distribution (e.g., [100] (page 115)) |
| CLoglogisticDist | Extends the class ContinuousDistribution for the Log-Logistic distribution with shape parameter \(\alpha> 0\) and scale parameter \(\beta> 0\) |
| ▶CLognormalDist | Extends the class ContinuousDistribution for the lognormal distribution [99] |
| CLognormalDistFromMoments | Extends the LognormalDist class with a constructor accepting the mean \(m\) and the variance \(v\) of the distribution as arguments |
| CNakagamiDist | Extends the class ContinuousDistribution for the Nakagami distribution with location parameter \(a\), scale parameter \(\lambda> 0\) and shape parameter \(c > 0\) |
| ▶CNormalDist | Extends the class ContinuousDistribution for the normal distribution (e.g., [99] (page 80)) |
| CNormalDistQuick | A variant of the class NormalDist (for the normal distribution with mean \(\mu\) and variance \(\sigma^2\)) |
| CNormalInverseGaussianDist | Extends the class ContinuousDistribution for the normal inverse gaussian distribution with location parameter \(\mu\), scale parameter \(\delta> 0\), tail heavyness \(\alpha> 0\), and asymmetry parameter \(\beta\) such that \(0 \le|\beta| < \alpha\) |
| CParetoDist | Extends the class ContinuousDistribution for a distribution from the Pareto family, with shape parameter \(\alpha> 0\) and location parameter \(\beta> 0\) [99] (page 574) |
| CPearson5Dist | THIS CLASS HAS BEEN RENAMED InverseGammaDist |
| CPearson6Dist | Extends the class ContinuousDistribution for the Pearson type VI distribution with shape parameters \(\alpha_1 > 0\) and \(\alpha_2 > 0\), and scale parameter \(\beta> 0\) |
| CPiecewiseLinearEmpiricalDist | Extends the class ContinuousDistribution for a piecewise-linear approximation of the empirical distribution function, based on the observations \(X_{(1)},…,X_{(n)}\) (sorted by increasing order), and defined as follows (e.g., [118] (page 318)) |
| CPowerDist | Extends the class ContinuousDistribution for the power distribution [57] (page 161) with shape parameter \(c > 0\), over the interval \([a,b]\), where \(a < b\) |
| CRayleighDist | This class extends the class ContinuousDistribution for the Rayleigh distribution [57] with location parameter \(a\), and scale parameter \(\beta> 0\) |
| ▶CStudentDist | Extends the class ContinuousDistribution for the Student \(t\)-distribution [100] (page 362) with \(n\) degrees of freedom, where \(n\) is a positive integer |
| CStudentDistQuick | Extends the class StudentDist for the Student \(t\)-distribution |
| CTriangularDist | Extends the class ContinuousDistribution for the triangular distribution (see [100] (page 297) and [118] (page 317)) with domain \([a,b]\) and mode (or shape parameter) \(m\), where \(a\le m\le b\) |
| CTruncatedDist | This container class takes an arbitrary continuous distribution and truncates it to an interval \([a,b]\), where \(a\) and \(b\) can be finite or infinite |
| CUniformDist | Extends the class ContinuousDistribution for the uniform distribution [100] (page 276) over the interval \([a,b]\) |
| CWatsonGDist | Extends the class ContinuousDistribution for the Watson \(G\) distribution (see [41], [238] ) |
| CWatsonUDist | Extends the class ContinuousDistribution for the Watson U distribution (see [55], [224], [225] ) |
| CWeibullDist | This class extends the class ContinuousDistribution for the Weibull distribution [99] (page 628) with shape parameter \(\alpha> 0\), location parameter \(\delta\), and scale parameter \(\lambda> 0\) |
| ▶CDiscreteDistribution | This class implements discrete distributions over a finite set of real numbers (also over integers as a particular case) |
| CConstantDist | Represents a constant discrete distribution taking a single real value with probability 1 |
| CEmpiricalDist | Extends DiscreteDistribution to an empirical distribution function, based on the observations \(X_{(1)},…,X_{(n)}\) (sorted by increasing order) |
| ▶CDiscreteDistributionInt | Classes implementing discrete distributions over the integers should inherit from this class |
| CBernoulliDist | Extends the class DiscreteDistributionInt for the Bernoulli distribution [118] with parameter \(p\), where \(0\le p\le1\) |
| CBinomialDist | Extends the class DiscreteDistributionInt for the binomial distribution [118] (page 321) with parameters \(n\) and \(p\), where \(n\) is a positive integer and \(0\le p\le1\) |
| CGeometricDist | Extends the class DiscreteDistributionInt for the geometric distribution [118] (page 322) with parameter \(p\), where \(0 < p < 1\) |
| CHypergeometricDist | Extends the class DiscreteDistributionInt for the hypergeometric distribution [66] (page 101) with \(k\) elements chosen among \(l\), \(m\) being of one type, and \(l-m\) of the other |
| CLogarithmicDist | Extends the class DiscreteDistributionInt for the logarithmic distribution |
| ▶CNegativeBinomialDist | Extends the class DiscreteDistributionInt for the negative binomial distribution [118] (page 324) with real parameters \(n\) and \(p\), where \(n > 0\) and \(0\le p\le1\) |
| CPascalDist | The Pascal distribution is a special case of the negative binomial distribution [118] (page 324) with parameters \(n\) and \(p\), where \(n\) is a positive integer and \(0\le p\le1\) |
| CPoissonDist | Extends the class DiscreteDistributionInt for the Poisson distribution [118] (page 325) with mean \(\lambda\ge0\) |
| ▶CUniformIntDist | Extends the class DiscreteDistributionInt for the discrete uniform distribution over the range \([i,j]\) |
| CConstantIntDist | Represents a constant discrete distribution taking a single integer value with probability 1 |
| CDistributionFactory | This class implements a string API for the package probdist |
| CDMatrix | This class implements a few methods for matrix calculations with double numbers |
| ▶CException | |
| CRunClass.RunClassException | |
| CNameConflictException | This exception is thrown by a ClassFinder when two or more fully qualified class names can be associated with a simple class name |
| CF2wPoly.F2w | |
| CF2wPoly.F2w.F2wElem | |
| CF2wPoly | |
| CF2wPoly.F2wPolyElem | |
| CF2wStructure | This class implements methods and fields needed by the classes umontreal.ssj.hups.F2wNetLFSR, umontreal.ssj.hups.F2wNetPolyLCG, umontreal.ssj.hups.F2wCycleBasedLFSR and umontreal.ssj.hups.F2wCycleBasedPolyLCG |
| CFBar | This class is similar to FDist, except that it provides static methods to compute or approximate the complementary distribution function of \(X\), which we define as \(\bar{F} (x) = P[X\ge x]\), instead of \(F (x)=P[X\le x]\) |
| CFDist | This class provides methods to compute (or approximate) the distribution functions of special types of goodness-of-fit test statistics |
| CTextDataWriter.Format | Output format: organize fields as columns or as rows |
| CGofFormat | This class contains methods used to format results of GOF test statistics, or to apply a series of tests simultaneously and format the results |
| CGofStat | This class provides methods to compute several types of EDF goodness-of-fit test statistics and to apply certain transformations to a set of observations |
| CHilbertCurveMap | This class implements the mapping of a Hilbert curve in the \(d\)-dimensional unit hypercube \([0,1)^d\) |
| CHistogramChartToLatex | |
| CContinuousState.IntegMethod | |
| ▶CIntegrator | |
| ▶CRandomIntegrator | |
| CMonteCarloIntegrator | |
| CReplicator | Replicator class |
| CIntrospection | Provides utility methods for introspection using Java Reflection API |
| ▶CInventory | |
| CInventoryCRN | |
| ▶CIterable | |
| ▶CEventList | An interface for implementations of event lists |
| CBinaryTree | An implementation of EventList using a binary search tree |
| CDoublyLinked | An implementation of EventList using a doubly linked linear list |
| CHenriksen | An implementation of EventList using the doubly-linked indexed list of Henriksen [108] (see also [62] (p |
| CRedblackTree | An implementation of EventList using a red black tree, which is similar to a binary search tree except that every node is colored red or black |
| CSplayTree | An implementation of EventList using a splay tree [218] |
| CMatrixOfStatProbes< E extends StatProbe > | Represents a matrix of statistical probes that can be managed simultaneously |
| CJDBCManager | This class provides some facilities to connect to a SQL database and to retrieve data stored in it |
| CKernelDensity | This static class provides methods to compute a kernel density estimator from a set of \(n\) individual observations \(x_0, …, x_{n-1}\), which define an empirical distribution |
| CLeastSquares | This class implements different linear regression models, using the least squares method to estimate the regression coefficients |
| ▶CListOfStatProbes< E > | |
| CListOfFunctionOfMultipleMeansTallies< E extends FunctionOfMultipleMeansTally > | Represents a list of tally statistical collectors for a vector of functions of multiple means |
| ▶CListOfTallies< E extends Tally > | Represents a list of tally statistical collectors |
| CAnovaVarianceCollector | Extends ListOfTallies to collect ANOVA variances |
| ▶CListOfTallies< E > | |
| ▶CListOfTalliesWithCovariance< E extends Tally > | Extends ListOfTallies to add support for the computation of the sample covariance between each pair of elements in a list, without storing all observations |
| CListOfTalliesWithCV< E extends Tally > | Represents a list of tallies with control variables that inherits the functionalities of a list of tallies, and accepts vectors of length \(p+q\) |
| CListOfTallies< PartialVariance > | |
| CListOfTallies< umontreal.ssj.stat.Tally > | |
| CListOfTalliesWithCovariance< E > | |
| CListOfTalliesWithCovariance< umontreal.ssj.stat.Tally > | |
| ▶CMathFunction | This interface should be implemented by classes which represent univariate mathematical functions |
| CBSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| CSmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [42], [204] |
| CAverageMathFunction | Represents a function computing the average of several functions |
| CIdentityMathFunction | Represents the identity function \(f(x)=x\) |
| ▶CMathFunctionWithDerivative | Represents a mathematical function whose \(n\)th derivative can be computed using derivative(double,int) |
| CBSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| CSmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [42], [204] |
| CAverageMathFunction | Represents a function computing the average of several functions |
| CIdentityMathFunction | Represents the identity function \(f(x)=x\) |
| CPolynomial | Represents a polynomial of degree \(n\) in power form |
| CShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| ▶CMathFunctionWithFirstDerivative | Represents a mathematical function whose derivative can be computed using derivative(double) |
| CBSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| CSmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [42], [204] |
| CAverageMathFunction | Represents a function computing the average of several functions |
| CIdentityMathFunction | Represents the identity function \(f(x)=x\) |
| CPolynomial | Represents a polynomial of degree \(n\) in power form |
| CPowerMathFunction | Represents a function computing \((af(x) + b)^p\) for a user-defined function \(f(x)\) and power \(p\) |
| CShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| CSquareMathFunction | Represents a function computing \((af(x) + b)^2\) for a user-defined function \(f(x)\) |
| ▶CMathFunctionWithIntegral | Represents a mathematical function whose integral can be computed by the integral(double,double) method |
| CBSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| CSmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [42], [204] |
| CAverageMathFunction | Represents a function computing the average of several functions |
| CIdentityMathFunction | Represents the identity function \(f(x)=x\) |
| CPolynomial | Represents a polynomial of degree \(n\) in power form |
| CShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| CPiecewiseConstantFunction | Represents a piecewise-constant function |
| CPolynomial | Represents a polynomial of degree \(n\) in power form |
| CPowerMathFunction | Represents a function computing \((af(x) + b)^p\) for a user-defined function \(f(x)\) and power \(p\) |
| CShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| CSqrtMathFunction | Represents a function computing the square root of another function \(f(x)\) |
| CMathFunctionUtil | Provides utility methods for computing derivatives and integrals of functions |
| CMatrixOfObservationListener | Represents an object that can listen to observations broadcast by matrices of statistical probes |
| ▶CMatrixOfStatProbes< E > | |
| CMatrixOfFunctionOfMultipleMeansTallies< E extends FunctionOfMultipleMeansTally > | Represents a matrix of statistical collectors for functions of multiple means |
| CMatrixOfTallies< E extends Tally > | Represents a matrix of tally statistical collectors |
| CMeanVarExperiment | |
| CMisc | This class provides miscellaneous functions that are hard to classify |
| ▶CMonteCarloExperiment | Provides generic tools to perform simple Monte Carlo experiments with a simulation model that implements one of the interfaces MonteCarloModelDouble, MonteCarloModelDoubleArray, or MonteCarloModelCV |
| CRQMCExperiment | Provides basic generic tools to perform RQMC experiments with a simulation model that implements the MonteCarloModelDouble interface |
| ▶CMonteCarloModel< E > | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| CAnovaVarianceEstimator | ANOVA variance estimator |
| CMonteCarloModelRQMC< E > | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| CPartialVarianceEstimator | Partial variance estimator |
| CMonteCarloModel< double[]> | |
| ▶CMonteCarloModelDouble | An interface for a very simple simulation model for which Monte Carlo (MC) and RQMC experiments are to be performed |
| CAsianNew | |
| CNewTestAsianRQMC | |
| CSan13Dist | This class simulates a specific stochastic activity network with 9 nodes and 13 links, taken from Elmaghraby (1977) and used again in L'Ecuyer and Lemieux (2000), "Variance Reduction via Lattice Rules" |
| CMonteCarloModelDoubleRQMC | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| CMonteCarloModelCV | An extension of MonteCarloModelDouble that also implements a vector of control variates |
| CMonteCarloModelDensityKnown | An interface for a simulation model for which Monte Carlo (MC) and RQMC experiments are to be performed |
| CMonteCarloModelDoubleArray | Similar to MonteCarloModelDouble except that the returned performance is an array of real numbers |
| CMultiDim01 | This interface represents a point or array of \(d\) dimensions in a unit hypercube \([0, 1)^d\) |
| ▶CMultiDimComparable< T > | This interface is an extension (or variant) of the Comparable interface in Java |
| CMarkovChainComparable | A subclass of MarkovChain for which there is a total ordering between the states, induced by the implementation of the umontreal.ssj.util.MultiDimComparable interface |
| CMultiDimComparable< MarkovChainComparable > | |
| ▶CMultiDimSort< T > | This interface is meant to be implemented by certain multivariate sorting algorithms that sort objects based on different fields (or dimensions) |
| CMultiDimSort01< T extends MultiDim01 > | This interface extends MultiDimSort<T> to implement multivariate sorting algorithms that sort points of \(d\) dimensions in the unit hypercube \([0, 1)^d\) |
| CMultiDimSortComparable< T extends MultiDimComparable<? super T > | This interface extends MultiDimSort<T> to implement multivariate sorting algorithms that sort objects that are pairwise comparable |
| ▶CMultiDimSort01< MultiDim01 > | |
| CHilbertCurveSort | This class implements a MultiDimSort01<T extends MultiDim01> that can sort an array of points in the \(d\)-dimensional unit hypercube \([0,1)^d\), by following a Hilbert curve, and using (at most) the first \(m\) bits of each point |
| ▶CMultiDimSortComparable< T > | |
| ▶CBatchSort< T extends MultiDimComparable<? super T > | This class implements a MultiDimSortComparable that performs a batch sort on multivariate arrays |
| CBatchSortPow2 | This is a subclass of BatchSort for which the batch numbers \(n_j\) are always powers of 2 |
| CHilbertCurveBatchSort< T extends MultiDimComparable<? super T > | This sort is similar to BatchSortPow2, except that after applying the batch sort, the objects are given labels that map them to the \(d\)-dimensional unit hypercube \([0,1)^d\) as explained below, and then re-ordered by following a Hilbert curve as in the HilbertCurveSort |
| COneDimSort< T extends MultiDimComparable<? super T > | This class implements a MultiDimSortComparable that simply sorts the objects according to a given sorting coordinate \(j \ge0\) specified in the constructor |
| CSplitSort< T extends MultiDimComparable<? super T > | Implements a MultiDimSortComparable that performs a split sort on a MultiDimComparable<T> array based on its first \(d\) dimensions |
| CMultiFunction | This interface should be implemented by classes which represent multivariate mathematical functions |
| CMultipleDatasetChart | Provides tools to plot many datasets on the same chart |
| ▶CMultivariateFunction | Represents a function of multiple variables |
| CRatioFunction | Represents a function computing a ratio of two values |
| CNativeUtils | A simple library class which helps with loading dynamic libraries stored in the JAR archive |
| CListWithStat< E >.Node< E > | Represents a node that can be part of a list with statistical collecting |
| CNonuniform | |
| ▶CNortaInitDisc | This abstract class defines the algorithms used for NORTA initialization when the marginal distributions are discrete |
| CNI1 | Extends the class NortaInitDisc and implements the algorithm NI1 |
| CNI2a | Extends the class NortaInitDisc and implements the algorithm NI2a |
| CNI2b | Extends the class NortaInitDisc and implements the algorithm NI2b |
| CNI3 | Extends the class NortaInitDisc and implements the algorithm NI3 |
| CNum | This class provides a few constants and some methods to compute numerical quantities such as factorials, combinations, gamma functions, and so on |
| ▶CObservationCollector< E > | |
| CBasicObservationCollector< E > | Does nothing but counting the total number of observations |
| CObservationCollectorList< E > | |
| ▶CObservationListener | Represents an object that can listen to observations broadcast by statistical probes |
| CQueueObs.LargeWaitsCollector | |
| CQueueObs.ObservationTrace | |
| CGofStat.OutcomeCategoriesChi2 | This class helps managing the partitions of possible outcomes into categories for applying chi-square tests |
| CPgfDataTable | Represents a data table which has a name, a number of observations (rows), a number of fields (columns), an array that contains the names (identifiers) of the fields, and a two-dimensional array that contains the data |
| CPlotFormat | Provide tools to import and export data set tables to and from Gnuplot, MATLAB and Mathematica compatible formats, or customized format |
| ▶CPointSet | This abstract class represents a general point set |
| ▶CCachedPointSet | This container class caches a point set by precomputing and storing its points locally in an array |
| CIndependentPointsCached | Similar to IndependentPoints, but the points are all generated and stored (cached) when the point set is randomized |
| CLatinHypercube | Implements Latin Hypercube Sampling (LHS) with \(n\) points in the \(s\)-dimensional unit hypercube |
| CSortedAndCutPointSet | This class is useful for the Array-RQMC method, in the situation where the Markov chain has a multidimensional state, the RQMC points are sorted once for all, based on their first \(\ell\) coordinates, then these coordinates are removed and only the remaining coordinates are kept and randomized at each step |
| CStratifiedUnitCube | This class implements a stratification of the unit cube in rectangular boxes of same size and orientation |
| CStratifiedUnitCubeAnti | This class implements a stratification of the unit cube in rectangular boxes of same size and orientation, similar to StratifiedUnitCube |
| ▶CContainerPointSet | This acts as a generic base class for all container classes that contain a point set and apply a specific kind of transformation to the coordinates \(u_{i,j}\) when the points are generated by the iterator |
| CAntitheticPointSet | This container class provides antithetic versions of the contained points |
| CBakerTransformedPointSet | This container class embodies a point set to which a baker's transformation (also called a tent transform) is applied (see, e.g., [49], [84], [156]) |
| CRandShiftedMod1PointSet | This container class embodies an arbitrary point set and its iterator adds a random shift modulo 1 to all the points, when producing the coordinates |
| ▶CCycleBasedPointSet | This abstract class provides the basic structures for storing and manipulating a point set defined by a set of cycles |
| ▶CCycleBasedPointSetBase2 | Similar to CycleBasedPointSet, except that the successive values in the cycles are stored as integers in the range \(\{0,\dots,2^k-1\}\), where \(1\le k \le31\) |
| CCycleBasedLFSR | Linear feedback shift register (LFSR) random number generators [147], [124], [187], produce numbers by generating a sequence of bits from a linear recurrence modulo 2, and forming fractional numbers by taking blocks of successive bits |
| CF2wCycleBasedLFSR | This class creates a point set based upon a linear feedback shift register sequence |
| CF2wCycleBasedPolyLCG | This class creates a point set based upon a linear congruential sequence in the finite field \(\mathbb F_{2^w}[z]/P(z)\) |
| CLCGPointSet | Implements a recurrence-based point set defined via a linear congruential recurrence of the form \(x_i = a x_{i-1} \mod n\) and \(u_i = x_i / n\) |
| ▶CDigitalNet | This class provides the basic structures for storing and manipulating linear digital nets in base \(b\), for an arbitrary base \(b\ge2\) |
| ▶CDigitalNetBase2 | A special case of DigitalNet for the base \(b=2\) |
| CDigitalNetBase2FromFile | This class permits one to read the parameters that define a digital net in base 2 either from a file, or from a URL address |
| ▶CDigitalSequenceBase2 | This abstract class describes methods specific to digital sequences in base 2 |
| CNiedSequenceBase2 | This class implements digital sequences constructed from the Niederreiter sequence in base 2 |
| CNiedXingSequenceBase2 | This class implements digital sequences based on the Niederreiter-Xing sequence in base 2 |
| CSobolSequence | This class implements digital nets and digital sequences in base 2 formed by the first \(n = 2^k\) points of a Sobol’ sequence [221], [222] |
| CF2wNetLFSR | This class implements a digital net in base 2 starting from a linear feedback shift register generator |
| CF2wNetPolyLCG | This class implements a digital net in base 2 starting from a polynomial LCG in \(\mathbb F_{2^w}[z]/P(z)\) |
| CDigitalNetSearch.DigitalNetBase2FromLatNetBuilder | Class for the construction od digital nets |
| CDigitalNetFromFile | This class allows us to read the parameters defining a digital net either from a file, or from a URL address on the World Wide Web |
| ▶CDigitalSequence | This abstract class describes methods specific to digital sequences |
| CFaureSequence | This class implements digital nets or digital sequences formed by the first \(n = b^k\) points of the Faure sequence in base \(b\) |
| CHaltonSequence | This class implements the sequence of Halton [76] , which is essentially a modification of Hammersley nets for producing an infinite sequence of points having low discrepancy |
| CHammersleyPointSet | This class implements Hammersley point sets, which are defined as follows |
| CPaddedPointSet | This container class realizes padded point sets, constructed by taking some coordinates from a point set \(P_1\), other coordinates from a point set \(P_2\), and so on |
| ▶CRank1Lattice | This class implements point sets specified by integration lattices of rank |
| ▶CKorobovLattice | This class implements a Korobov lattice, which represents the same point set as in class LCGPointSet, but implemented differently |
| CKorobovLatticeSequence | |
| CSubsetOfPointSet | This container class permits one to select a subset of a point set |
| ▶CPointSetRandomization | This interface is for a randomization that can be used to randomize a umontreal.ssj.hups.PointSet |
| CEmptyRandomization | This class implements an empty umontreal.ssj.hups.PointSetRandomization |
| CNestedUniformScrambling | This class implements a PointSetRandomization that performs Owen's nested uniform scrambling [191], [195] |
| ▶CRandomShift | This class implements a umontreal.ssj.hups.PointSetRandomization |
| CLMScrambleShift | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a left matrix scrambling and adds a random digital shift |
| CSMScrambleShift | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a striped matrix scrambling [195] and adds a random digital shift |
| CRandomStart | This class implements a umontreal.ssj.hups.PointSetRandomization that randomizes a sequence simply by taking a random starting point |
| CPreyPred | |
| CQueueEv | |
| CQueueLindley | |
| CQueueObs | |
| CRadicalInverse | This class implements basic methods for working with radical inverses of integers in an arbitrary basis \(b\) |
| ▶CRandomMultivariateGen | This class is the multivariate counterpart of umontreal.ssj.randvar.RandomVariateGen |
| CDirichletGen | Extends RandomMultivariateGen for a Dirichlet [98] distribution |
| CIIDMultivariateGen | Extends RandomMultivariateGen for a vector of independent identically distributed (i.i.d.) random variables |
| ▶CMultinormalGen | Extends RandomMultivariateGen for a multivariate normal (or multinormal) distribution [98] |
| CMultinormalCholeskyGen | Extends MultinormalGen for a multivariate normal distribution [98] , generated via a Cholesky decomposition of the covariance matrix |
| CMultinormalPCAGen | Extends MultinormalGen for a multivariate normal distribution [98] , generated via the method of principal components analysis (PCA) of the covariance matrix |
| CRandomPermutation | Provides methods to randomly shuffle arrays or lists using a random stream |
| ▶CRandomStream | This interface defines the basic structures to handle multiple streams of uniform (pseudo)random numbers and convenient tools to move around within and across these streams |
| ▶CPointSetIterator | This is the interface for iterators that permit one to go through the points of a #PointSet and the successive coordinates of these points |
| ▶CPointSet.DefaultPointSetIterator | This class implements a default point set iterator |
| CCachedPointSet.CachedPointSetIterator | This class implements a CachedPointSet iterator which takes the value directly in the array x in which the points are cached, rather than calling getCoordinate inherited from CachedPointSet |
| ▶CDigitalNet.DigitalNetIterator | |
| CDigitalNet.DigitalNetIteratorNoGray | |
| CRank1Lattice.Rank1LatticeIterator | |
| CSortedAndCutPointSet.SortedAndCutPointSetIterator | |
| CAntitheticStream | This container class allows the user to force any RandomStream to return antithetic variates |
| CBakerTransformedStream | This container class permits one to apply the baker’s transformation to the output of any RandomStream |
| CCloneableRandomStream | CloneableRandomStream extends RandomStream and Cloneable |
| CRandomStreamWithCache | This class represents a random stream whose uniforms are cached for more efficiency when using common random numbers |
| CTruncatedRandomStream | Represents a container random stream generating numbers in an interval \((a,b)\) instead of in \((0,1)\), where \(0\le a < b \le1\), by using the contained stream |
| CInverseGaussianProcessMSH.NonRandomStream | NonRandomStream:
Given a double array, this class will return those values as if it where a random stream |
| ▶CRandomStreamFactory | Represents a random stream factory capable of constructing instances of a given type of random stream by invoking the newInstance method each time a new random stream is needed, instead of invoking directly the specific constructor of the desired type |
| CBasicRandomStreamFactory | Represents a basic random stream factory that can constructs new instances of a given RandomStream implementation via the newInstance method |
| CRandomStreamManager | Manages a list of random streams for more convenient synchronization |
| ▶CRandomVariateGen | This is the base class for all random variate generators over the real line |
| ▶CBetaGen | This class implements random variate generators with the beta distribution with shape parameters \(\alpha> 0\) and \(\beta> 0\), over the interval \((a,b)\), where \(a < b\) |
| CBetaRejectionLoglogisticGen | Implements Beta random variate generators using the rejection method with log-logistic envelopes from [34] |
| CBetaStratifiedRejectionGen | This class implements Beta random variate generators using the stratified rejection/patchwork rejection method from [210], [223] |
| ▶CBetaSymmetricalGen | This class implements random variate generators with the symmetrical beta distribution with shape parameters \(\alpha= \beta\), over the interval \((0,1)\) |
| CBetaSymmetricalBestGen | This class implements symmetrical beta random variate generators using Devroye’s one-liner method |
| CBetaSymmetricalPolarGen | This class implements symmetrical beta random variate generators using Ulrich’s polar method [232] |
| CCauchyGen | This class implements random variate generators for the Cauchy distribution |
| ▶CChiGen | This class implements random variate generators for the chi distribution |
| CChiRatioOfUniformsGen | This class implements Chi random variate generators using the ratio of uniforms method with shift |
| CChiSquareGen | This class implements random variate generators with the chi square distribution with \(n>0\) degrees of freedom |
| ▶CChiSquareNoncentralGen | This class implements random variate generators for the noncentral chi square distribution with \(\nu> 0\) degrees of freedom and noncentrality parameter \(\lambda> 0\) |
| CChiSquareNoncentralGamGen | This class implements noncentral chi square random variate generators using the additive property of the noncentral chi square distribution [115] |
| CChiSquareNoncentralPoisGen | This class implements noncentral chi square random variate generators using Poisson and central chi square generators |
| CConstantGen | This class implements a random variate generator that returns a constant value |
| ▶CExponentialGen | This class implements random variate generators for the exponential distribution |
| CExponentialInverseFromDensityGen | This class implements exponential random variate generators using numerical inversion of the exponential density as described in [44] |
| CExtremeValueGen | This class has been replaced by GumbelGen |
| CFatigueLifeGen | This class implements random variate generators for the fatigue life distribution [20] with location parameter \(\mu\), scale parameter \(\beta\) and shape parameter \(\gamma\) |
| CFisherFGen | This class implements random variate generators for the Fisher F distribution with \(n\) and \(m\) degrees of freedom, where \(n\) and \(m\) are positive integers |
| CFNoncentralGen | This class implements random variate generators for the noncentral F-distribution |
| CFoldedNormalGen | This class implements methods for generating random variates from the folded normal distribution with parameters \(\mu\ge0\) and \(\sigma> 0\) |
| CFrechetGen | This class implements methods for generating random variates from the Fréchet distribution, with location parameter \(\delta\), scale parameter \(\beta> 0\), and shape parameter \(\alpha> 0\), where we use the notation \(z = (x-\delta)/\beta\) |
| ▶CGammaGen | This class implements random variate generators for the gamma distribution |
| ▶CErlangGen | This class implements random variate generators for the Erlang distribution with parameters \(k > 0\) and \(\lambda> 0\) |
| CErlangConvolutionGen | This class implements Erlang random variate generators using the convolution method |
| CGammaAcceptanceRejectionGen | This class implements gamma random variate generators using a method that combines acceptance-rejection with acceptance-complement, and proposed in [2], [4] |
| CGammaRejectionLoglogisticGen | This class implements gamma random variate generators using a rejection method with loglogistic envelopes, from [33] |
| CGumbelGen | This class implements methods for generating random variates from the Gumbel distribution |
| CHalfNormalGen | This class implements methods for generating random variates from the half-normal distribution with parameters \(\mu\) and \(\sigma> 0\) |
| CHyperbolicSecantGen | This class implements random variate generators for the hyperbolic secant distribution with location parameter \(\mu\) and scale parameter \(\sigma\) |
| CHypoExponentialGen | This class implements random variate generators for the hypoexponential distribution (see classes umontreal.ssj.probdist.HypoExponentialDist and umontreal.ssj.probdist.HypoExponentialDistQuick in package probdist for the definition) |
| CInverseFromDensityGen | Implements a method for generating random variates by numerical inversion of an arbitrary continuous distribution when only the probability density is known [44] |
| CInverseGammaGen | This class implements random variate generators for the inverse gamma distribution with shape parameter \(\alpha> 0\) and scale parameter \(\beta> 0\) |
| ▶CInverseGaussianGen | This class implements random variate generators for the inverse Gaussian distribution with location parameter \(\mu> 0\) and scale parameter \(\lambda> 0\) |
| CInverseGaussianMSHGen | This class implements inverse gaussian random variate generators using the many-to-one transformation method of Michael, Schucany and Haas (MHS) [180], [48] |
| ▶CJohnsonSystemG | This class contains common parameters and methods for the random variate generators associated with the Johnson system of distributions [101], [99] |
| CJohnsonSBGen | This class implements random variate generators for the Johnson \(S_B\) distribution |
| CJohnsonSLGen | This class implements random variate generators for the Johnson \(S_L\) distribution |
| CJohnsonSUGen | This class implements random variate generators for the Johnson \(S_U\) distribution |
| ▶CKernelDensityGen | This class implements random variate generators for distributions obtained via kernel density estimation methods from a set of \(n\) individual observations \(x_1,…,x_n\) [45], [46], [89], [90], [215] |
| CKernelDensityVarCorrectGen | This class is a variant of KernelDensityGen, but with a rescaling of the empirical distribution so that the variance of the density used to generate the random variates is equal to the empirical variance, as suggested by [215] |
| CLaplaceGen | This class implements methods for generating random variates from the Laplace distribution |
| CLogisticGen | This class implements random variate generators for the logistic distribution |
| CLoglogisticGen | This class implements random variate generators for the log-logistic distribution with shape parameter \(\alpha> 0\) and scale parameter \(\beta> 0\) |
| CLognormalGen | This class implements methods for generating random variates from the lognormal distribution |
| CLognormalSpecialGen | Implements methods for generating random variates from the lognormal distribution using an arbitrary normal random variate generator |
| CMixtureGen | This class implements random variate generators for a mixture distribution |
| CNakagamiGen | This class implements random variate generators for the Nakagami distribution |
| ▶CNormalGen | This class implements methods for generating random variates from the normal distribution \(N(\mu, \sigma)\) |
| CNormalACRGen | This class implements normal random variate generators using the acceptance-complement ratio method [87] |
| CNormalBoxMullerGen | This class implements normal random variate generators using the Box-Muller method from [23] |
| CNormalInverseFromDensityGen | This class implements normal random variate generators using numerical inversion of the normal density as described in [44] |
| CNormalKindermannRamageGen | This class implements normal random variate generators using the Kindermann-Ramage method [106] |
| CNormalPolarGen | This class implements normal random variate generators using the polar method with rejection [176] |
| ▶CNormalInverseGaussianGen | This class implements random variate generators for the normal inverse gaussian ( \(\mathcal{NIG}\)) distribution |
| CNormalInverseGaussianIGGen | This class implements a normal inverse gaussian ( \({NIG}\)) random variate generator by using a normal generator ( \(N\)) and an inverse gaussian generator ( \(IG\)), as described in the following [239], [103] |
| CParetoGen | This class implements random variate generators for one of the Pareto distributions, with parameters \(\alpha>0\) and \(\beta>0\) |
| CPearson5Gen | THIS CLASS HAS BEEN RENAMED InverseGammaGen |
| CPearson6Gen | This class implements random variate generators for the Pearson type VI distribution with shape parameters \(\alpha_1 > 0\) and \(\alpha_2 > 0\), and scale parameter \(\beta> 0\) |
| CPowerGen | This class implements random variate generators for the power distribution with shape parameter \(c > 0\), over the interval \([a,b]\) |
| ▶CRandomVariateGenInt | This is the base class for all generators of discrete random variates over the set of integers |
| CBernoulliGen | This class implements random variate generators for the Bernoulli distribution (see class umontreal.ssj.probdist.BernoulliDist ) |
| ▶CBinomialGen | This class implements random variate generators for the binomial distribution |
| CBinomialConvolutionGen | Implements binomial random variate generators using the convolution method |
| CGeometricGen | This class implements a random variate generator for the geometric distribution |
| CHypergeometricGen | This class implements random variate generators for the hypergeometric distribution |
| CLogarithmicGen | This class implements random variate generators for the (discrete) logarithmic distribution |
| CNegativeBinomialGen | This class implements random variate generators having the negative binomial distribution |
| ▶CPascalGen | Implements Pascal random variate generators, which is a special case of the negative binomial generator with parameter \(\gamma\) equal to a positive integer |
| CPascalConvolutionGen | Implements Pascal random variate generators by the convolution method (see [118] ) |
| ▶CPoissonGen | This class implements random variate generators having the Poisson distribution |
| CPoissonTIACGen | This class implements random variate generators having the Poisson distribution (see PoissonGen ) |
| CUniformIntGen | This class implements a random variate generator for the uniform distribution over integers, over the interval \([i,j]\) |
| CUnuranDiscreteInt | This class permits one to create a discrete univariate generator using UNURAN via its string API |
| CRandomVariateGenWithCache | This class represents a random variate generator whose values are cached for more efficiency when using common random numbers |
| CRayleighGen | This class implements random variate generators for the Rayleigh distribution |
| ▶CStudentGen | This class implements methods for generating random variates from the Student distribution with \(n>0\) degrees of freedom |
| CStudentPolarGen | This class implements Student random variate generators using the polar method of [14] |
| CStudentNoncentralGen | This class implements random variate generators for the noncentral Student-t distribution with \(n>0\) degrees of freedom and noncentrality parameter \(\delta\) |
| CTriangularGen | This class implements random variate generators for the triangular distribution |
| CUniformGen | This class implements random variate generators for the (continuous) uniform distribution over the interval \((a,b)\), where \(a\) and \(b\) are real numbers with \(a < b\) |
| CUnuranContinuous | This class permits one to create continuous univariate generators using UNURAN via its string API |
| CUnuranEmpirical | This class permits one to create generators for empirical and quasi-empirical univariate distributions using UNURAN via its string interface |
| CWeibullGen | This class implements random variate generators for the Weibull distribution |
| CRandUnuran | This internal class provides the access point to the C package UNURAN |
| CReport | |
| CRijndael_Algorithm | Rijndael –pronounced Reindaal– is a variable block-size (128-, 192- and 256-bit), variable key-size (128-, 192- and 256-bit) symmetric cipher |
| CRijndael_Properties | This class acts as a central repository for an algorithm specific properties |
| CRootFinder | This class provides methods to solve non-linear equations |
| CRQMCExperimentSeries | This class offers facilities to perform experiments on the convergence of the variance when estimating a mean (expectation) with a series of RQMC point sets usually of the same type, but different sizes \(n\) |
| CRQMCPointSet | This class is used for randomized quasi-Monte Carlo (RQMC) simulations [125], [126], [192], [193] |
| CRunClass | |
| ▶CRuntimeException | |
| CUnuranException | This type of unchecked exception is thrown when an error occurs inside the UNURAN package |
| CRandomStreamInstantiationException | This exception is thrown when a random stream factory cannot instantiate a stream on a call to its umontreal.ssj.rng.RandomStreamFactory.newInstance method |
| CBitMatrix.IncompatibleDimensionException | Runtime exception raised when the dimensions of the BitMatrix are not appropriate for the operation |
| ▶CSampler | |
| CQMCSampler | QMC sampler |
| ▶CRandomSampler | |
| ▶CMonteCarloSampler | Monte Carlo sampler |
| CMonteCarloIntegrator | |
| CRQMCSampler | QMC sampler |
| CScaledHistogram | This class provides histograms for which the bin counts (heights of rectangles) are replaced by real-valued frequencies (in double) and can be rescaled |
| ▶CSearch | Abstract class for the search of highly uniform point sets with LatNet Builder |
| ▶CDigitalNetSearch | Class for the search of good digital nets using LatNet Builder |
| CPolynomialLatticeSearch | Class for the search of good polynomial lattice rules using LatNet Builder |
| COrdinaryLatticeSearch | Class for the search of good rank-1 ordinary lattice rules using LatNet Builder |
| ▶CSearcher | This class implements methods to search for the best lattices of rank 1, defined as follows [219] |
| CSearcherCBC | This class implements searches to find the best rank-1 lattices with respect to a given discrepancy, using component-by-component (CBC) searches, random or exhaustive for each component |
| CSearcherKorobov | This class implements searches to find the best Korobov lattices with respect to a given discrepancy |
| ▶CSerializable | |
| CClassFinder | Utility class used to convert a simple class name to a fully qualified class object |
| CSim | This static class contains the executive of a discrete-event simulation |
| ▶CSimExp | Represents a framework for performing experiments using simulation |
| CBatchMeansSim | Performs a simulation experiment on an infinite horizon, for estimating steady-state performance measures, using batch means |
| CRepSim | Performs a simulation experiment on a finite horizon, using a certain number of independent runs or replications |
| CSimulator | Represents the executive of a discrete-event simulator |
| CSnippet | |
| ▶CSSJCategorySeriesCollection | Stores data used in a CategoryChart |
| CBoxSeriesCollection | This class stores data used in a umontreal.ssj.charts.CategoryChart |
| ▶CSSJXYSeriesCollection | Stores data used in a XYChart |
| CEmpiricalSeriesCollection | Stores data used in a EmpiricalChart |
| CHistogramSeriesCollection | Stores data used in a HistogramChart |
| ▶CXYListSeriesCollection | This class extends umontreal.ssj.charts.SSJXYSeriesCollection |
| CYListSeriesCollection | This class extends umontreal.ssj.charts.XYListSeriesCollection |
| ▶CStatProbe | The objects of this class are statistical probes or collectors, which are elementary devices for collecting statistics |
| CAccumulate | A subclass of umontreal.ssj.stat.StatProbe, for collecting statistics on a variable that evolves in simulation time, with a piecewise-constant trajectory |
| CFunctionOfMultipleMeansTally | Represents a statistical collector for estimating a function of multiple means with a confidence interval based on the delta theorem [214] |
| CTally | A subclass of StatProbe |
| ▶CStochasticProcess | Abstract base class for a stochastic process \(\{X(t) : t \geq 0 \}\) sampled (or observed) at a finite number of time points, \(0 = t_0 < t_1 < \cdots< t_d\) |
| ▶CBrownianMotion | This class represents a Brownian motion process \(\{X(t) : t \geq0 \}\), sampled at times \(0 = t_0 < t_1 < \cdots< t_d\) |
| CBrownianMotionBridge | Represents a Brownian motion process \(\{X(t) : t \geq0 \}\) sampled using the bridge sampling technique (see for example [69] ) |
| CBrownianMotionPCA | A Brownian motion process \(\{X(t) : t \geq0 \}\) sampled using the principal component decomposition (PCA) [69], [95], [153] |
| CBrownianMotionPCAEqualSteps | Same as BrownianMotionPCA, but uses a trick to speed up the calculation when the time steps are equidistant |
| CCIRProcess | This class represents a CIR (Cox, Ingersoll, Ross) process [36] \(\{X(t) : t \geq0 \}\), sampled at times \(0 = t_0 < t_1 < \cdots< t_d\) |
| CCIRProcessEuler | This class represents a CIR process as in CIRProcess, but the process is generated using the simple Euler scheme |
| ▶CGammaProcess | This class represents a gamma process [171] (page 82) \(\{ S(t) = G(t; \mu, \nu) : t \geq0 \}\) with mean parameter \(\mu\) and variance parameter \(\nu\) |
| ▶CGammaProcessBridge | This class represents a gamma process \(\{ S(t) = G(t; \mu, \nu) : t \geq0 \}\) with mean parameter \(\mu\) and variance parameter \(\nu\), sampled using the gamma bridge method (see for example [208], [11] ) |
| CGammaProcessSymmetricalBridge | This class differs from GammaProcessBridge only in that it requires the number of interval of the path to be a power of 2 and of equal size |
| ▶CGammaProcessPCA | Represents a gamma process sampled using the principal component analysis (PCA) |
| ▶CGammaProcessPCABridge | Same as GammaProcessPCA, but the generated uniforms correspond to a bridge transformation of the BrownianMotionPCA instead of a sequential transformation |
| CGammaProcessPCASymmetricalBridge | Same as GammaProcessPCABridge, but uses the fast inversion method for the symmetrical beta distribution, proposed by L’Ecuyer and Simard [134] , to accelerate the generation of the beta random variables |
| CGeometricBrownianMotion | Represents a geometric Brownian motion (GBM) process \(\{S(t), t\ge0\}\), which evolves according to the stochastic differential equation |
| ▶CGeometricLevyProcess | Abstract class used as a parent class for the exponentiation of a Lévy process \(X(t)\):
\[ S(t) = S(0) \exp\left(X(t) + (r - \omega_{RN}) t\right). \]
The interest rate is denoted \(r\) and is referred to as muGeom in the class below |
| CGeometricNormalInverseGaussianProcess | The geometric normal inverse gaussian (GNIG) process is the exponentiation of a NormalInverseGaussianProcess :
\[ S(t) = S_0 \exp\left[ (r-\omega_{RN})t + \mbox{NIG}(t;\alpha,\beta,\mu,\delta) \right], \]
where \(r\) is the interest rate |
| CGeometricVarianceGammaProcess | This class represents a geometric variance gamma process \(S(t)\) (see [171] (page 86)) |
| ▶CInverseGaussianProcess | The inverse Gaussian process is a non-decreasing process where the increments are additive and are given by the inverse gaussian distribution, umontreal.ssj.probdist.InverseGaussianDist |
| ▶CInverseGaussianProcessMSH | Uses a faster generating method (MSH) [180] than the simple inversion of the distribution function used by InverseGaussianProcess |
| CInverseGaussianProcessBridge | Samples the path by bridge sampling: first finding the process value at the final time and then the middle time, etc |
| CInverseGaussianProcessPCA | Approximates a principal component analysis (PCA) decomposition of the InverseGaussianProcess |
| ▶CMultivariateStochasticProcess | This class is a multivariate version of StochasticProcess where the process evolves in the \(c\)-dimensional real space |
| ▶CMultivariateBrownianMotion | This class represents a multivariate Brownian motion process \(\{\mathbf{X}(t) = (X_1(t),…, X_c(t)), t \geq0 \}\), sampled at times \(0 = t_0 < t_1 < \cdots< t_d\) |
| CMultivariateBrownianMotionBridge | A multivariate Brownian motion process \(\{\mathbf{X}(t) : t \geq0 \}\) sampled via bridge sampling |
| CMultivariateBrownianMotionPCA | A multivariate Brownian motion process \(\{\mathbf{X}(t) : t \geq0 \}\) sampled entirely using the principal component decomposition (PCA), as explained in [69] , page 92 |
| CMultivariateBrownianMotionPCABigSigma | A multivariate Brownian motion process \(\{\mathbf{X}(t) : t \geq0 \}\) sampled entirely using the principal component decomposition (PCA) |
| CMultivariateGeometricBrownianMotion | This class is a multivariate version of GeometricBrownianMotion |
| CNormalInverseGaussianProcess | This class represents a normal inverse gaussian process (NIG) |
| ▶COrnsteinUhlenbeckProcess | This class represents an Ornstein-Uhlenbeck process \(\{X(t) : t \geq0 \}\), sampled at times \(0 = t_0 < t_1 < \cdots< t_d\) |
| COrnsteinUhlenbeckProcessEuler | This class represents an Ornstein-Uhlenbeck process as in OrnsteinUhlenbeckProcess, but the process is generated using the simple Euler scheme |
| ▶CVarianceGammaProcess | This class represents a variance gamma (VG) process \(\{S(t) = X(t; \theta, \sigma, \nu) : t \geq0\}\) |
| CVarianceGammaProcessAlternate | This is a VarianceGammaProcess for which the successive random numbers are used in a different order to generate the sample path |
| ▶CVarianceGammaProcessDiff | This class represents a variance gamma (VG) process \(\{S(t) = X(t; \theta, \sigma, \nu) : t \geq0\}\) |
| ▶CVarianceGammaProcessDiffPCA | Same as VarianceGammaProcessDiff, but the two inner GammaProcess ’es are of PCA type |
| CVarianceGammaProcessDiffPCABridge | Same as VarianceGammaProcessDiff, but the two inner GammaProcess ’es are of the type PCABridge |
| CVarianceGammaProcessDiffPCASymmetricalBridge | Same as VarianceGammaProcessDiff, but the two inner GammaProcess ’es are of the PCASymmetricalBridge type |
| CSysteme | This class provides a few tools related to the system or the computer |
| CTableFormat | This class provides methods to format arrays and matrices into String s in different styles |
| CTextDataReader | Provides static methods to read data from text files |
| CTimeUnit | Represents a time unit for conversion of time durations |
| CTransformingList< E, ListWithStat.Node< E > > | |
| ▶CXYChart | This class provides tools to create charts from data in a simple way |
| CEmpiricalChart | This class provides additional tools to create and manage empirical plots |
| CHistogramChart | This class provides tools to create and manage histograms |
| CScatterChart | This class provides tools to create and manage scatter plots |
| ▶CXYLineChart | This class provides tools to create and manage curve plots |
| CPPPlot | This class implements PP-plot (or probability-probability plot) objects that compare two probability distributions |
| CQQPlot | This class implements QQ-plot (or quantile-quantile plot) objects that compare two probability distributions |
| CYListChart | This class extends the class umontreal.ssj.charts.XYLineChart |
| ▶CAbstractIntervalXYDataset | |
| CCustomHistogramDataset | A dataset that can be used for creating histograms |
| ▶CAbstractList | |
| ▶CTransformingList< OE, IE > | Represents a list that dynamically transforms the elements of another list |
| ▶CListWithStat< E > | Implements a list with integrated statistical probes to provide automatic collection of statistics on the sojourn times of objects in the list and on the size of the list as a function of time given by a simulator |
| CLinkedListStat< E > | This class extends ListWithStat, and uses a linked list as the internal data structure |
| ▶CArrayList | |
| CObservationCollectorList< E > | |
| ▶CComparator | |
| CDigitalNetFromFile.NetComparator | |
| CDoubleArrayComparator | This provides an implementation of Comparator in which arrays of double in \(d\) dimensions are compared by comparing their coordinate \(j\) in the natural order of real numbers, where \(j \in\{0,…,d-1\}\) is given in the constructor |
| CHilbertCurveSort.LongIndexComparator2 | The comparator class used by sortIndexOfLong2 |
| CMultiDimComparator< T extends MultiDimComparable<? super T > | This class is useful if one wishes to perform an ordinary one-dimensional sort on MultiDimComparable<T> objects based on a single coordinate \(j\), which is specified in the constructor |
| ▶CIntervalXYDataset | |
| CCustomHistogramDataset | A dataset that can be used for creating histograms |
| ▶CList | |
| CListOfStatProbes< E extends StatProbe > | Represents a list of statistical probes that can be managed simultaneously |
| ▶CPublicCloneable | |
| CCustomHistogramDataset | A dataset that can be used for creating histograms |
| CEmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| ▶CRandomAccess | |
| CListOfStatProbes< E extends StatProbe > | Represents a list of statistical probes that can be managed simultaneously |
| ▶CSerializable | |
| CPolInterp | Represents a polynomial that interpolates through a set of points |
| CPolynomial | Represents a polynomial of degree \(n\) in power form |
| CRandMrg | USE MRG32k3a INSTEAD of this class |
| CRandomStreamBase | This class provides a convenient foundation on which RNGs can be built |
| CBitMatrix | This class implements matrices of bits of arbitrary dimensions |
| CBitVector | This class implements vectors of bits and the operations needed to use them |
| ▶CXYItemRenderer | |
| CEmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| ▶CXYLineAndShapeRenderer | |
| CEmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
