|
SSJ
3.3.1
Stochastic Simulation in Java
|
| ▼Ntutorial | |
| CAsianGBM | |
| CAsianGBMQMC | |
| CAsianNew | |
| ▼CBankEv | |
| CArrival | |
| CDeparture | |
| ▼CCallCenter | |
| CArrival | |
| CCall | |
| CCallCompletion | |
| CNextPeriod | |
| CCollision | |
| CCompareOutputs | |
| CInventory | |
| CInventoryCRN | |
| CNewTestAsianRQMC | |
| CNonuniform | |
| ▼CPreyPred | |
| CEndOfSim | |
| CPreds | |
| CPreys | |
| CPrintPoint | |
| ▼CQueueEv | |
| CArrival | |
| CCustomer | |
| CDeparture | |
| CEndOfSim | |
| CQueueLindley | |
| ▼CQueueObs | |
| CLargeWaitsCollector | |
| CObservationTrace | |
| ▼CRunClass | |
| CRunClassException | |
| 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" |
| CSnippet | |
| ▼Numontreal | |
| ▼Nssj | |
| ▶Ncharts | Charts generation |
| CAxis | Represents an axis of a chart encapsulated by an instance of XYChart |
| CBoxChart | This class provides tools to create and manage box-and-whisker plots |
| CBoxSeriesCollection | This class stores data used in a umontreal.ssj.charts.CategoryChart |
| CCategoryChart | This class provides tools to create charts from data in a simple way |
| CContinuousDistChart | This class provides tools to plot the density and the cumulative probability of a continuous probability distribution |
| CCustomHistogramDataset | A dataset that can be used for creating histograms |
| CDiscreteDistIntChart | This class provides tools to plot the mass function and the cumulative probability of a discrete probability distribution over the integers |
| CEmpiricalChart | This class provides additional tools to create and manage empirical plots |
| CEmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| CEmpiricalSeriesCollection | Stores data used in a EmpiricalChart |
| CHistogramChart | This class provides tools to create and manage histograms |
| CHistogramSeriesCollection | Stores data used in a HistogramChart |
| CMultipleDatasetChart | Provides tools to plot many datasets on the same chart |
| CPlotFormat | Provide tools to import and export data set tables to and from Gnuplot, MATLAB and Mathematica compatible formats, or customized format |
| 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 |
| CScatterChart | This class provides tools to create and manage scatter plots |
| CSSJCategorySeriesCollection | Stores data used in a CategoryChart |
| CSSJXYSeriesCollection | Stores data used in a XYChart |
| CXYChart | This class provides tools to create charts from data in a simple way |
| CXYLineChart | This class provides tools to create and manage curve plots |
| CXYListSeriesCollection | This class extends umontreal.ssj.charts.SSJXYSeriesCollection |
| CYListChart | This class extends the class umontreal.ssj.charts.XYLineChart |
| CYListSeriesCollection | This class extends umontreal.ssj.charts.XYListSeriesCollection |
| ▶Ndiscrepancy | Methods to compute various types of discrepancies for quasi-Monte Carlo point sets |
| 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 |
| CDiscrepancy | This abstract class is the base class of all discrepancy classes |
| CDiscrepancyContainer | This class is used to compute, store and display discrepancies |
| 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 |
| 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 |
| ▶Nfunctionfit | Function fit utilities |
| CBSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| CLeastSquares | This class implements different linear regression models, using the least squares method to estimate the regression coefficients |
| CPolInterp | Represents a polynomial that interpolates through a set of points |
| CSmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [42], [204] |
| ▶Nfunctions | Univariate functions as Java objects |
| CAverageMathFunction | Represents a function computing the average of several functions |
| CIdentityMathFunction | Represents the identity function \(f(x)=x\) |
| CMathFunction | This interface should be implemented by classes which represent univariate mathematical functions |
| CMathFunctionUtil | Provides utility methods for computing derivatives and integrals of functions |
| CMathFunctionWithDerivative | Represents a mathematical function whose \(n\)th derivative can be computed using derivative(double,int) |
| CMathFunctionWithFirstDerivative | Represents a mathematical function whose derivative can be computed using derivative(double) |
| CMathFunctionWithIntegral | Represents a mathematical function whose integral can be computed by the integral(double,double) method |
| CMultiFunction | This interface should be implemented by classes which represent multivariate mathematical functions |
| 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)\) |
| CSquareMathFunction | Represents a function computing \((af(x) + b)^2\) for a user-defined function \(f(x)\) |
| ▶Ngof | Goodness-of-fit test Statistics |
| 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 |
| 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 |
| COutcomeCategoriesChi2 | This class helps managing the partitions of possible outcomes into categories for applying chi-square tests |
| 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 |
| ▶Nhups | Highly Uniform Point Sets |
| ▶CAntitheticPointSet | This container class provides antithetic versions of the contained points |
| CAntitheticPointSetIterator | |
| ▶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]) |
| CBakerTransformedPointSetIterator | |
| ▶CCachedPointSet | This container class caches a point set by precomputing and storing its points locally in an array |
| CCachedPointSetIterator | 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 |
| ▶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 |
| CContainerPointSetIterator | |
| 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 |
| ▶CCycleBasedPointSet | This abstract class provides the basic structures for storing and manipulating a point set defined by a set of cycles |
| CCycleBasedPointSetIterator | |
| ▶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\) |
| CCycleBasedPointSetBase2Iterator | |
| ▶CDigitalNet | This class provides the basic structures for storing and manipulating linear digital nets in base \(b\), for an arbitrary base \(b\ge2\) |
| CDigitalNetIterator | |
| CDigitalNetIteratorNoGray | |
| ▶CDigitalNetBase2 | A special case of DigitalNet for the base \(b=2\) |
| CDigitalNetBase2Iterator | |
| CDigitalNetBase2IteratorNoGray | |
| 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 |
| ▶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 |
| CNetComparator | |
| ▶CDigitalSequence | This abstract class describes methods specific to digital sequences |
| CDigitalNetIteratorShiftGenerators | |
| CDigitalNetIteratorShiftNoGray | |
| ▶CDigitalSequenceBase2 | This abstract class describes methods specific to digital sequences in base 2 |
| CDigitalNetBase2IteratorShiftGenerators | |
| CDigitalNetBase2IteratorShiftNoGray | |
| CEmptyRandomization | This class implements an empty umontreal.ssj.hups.PointSetRandomization |
| 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)\) |
| 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)\) |
| 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 |
| 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 |
| CIndependentPointsCached | Similar to IndependentPoints, but the points are all generated and stored (cached) when the point set is randomized |
| CKorobovLattice | This class implements a Korobov lattice, which represents the same point set as in class LCGPointSet, but implemented differently |
| CKorobovLatticeSequence | |
| CLatinHypercube | Implements Latin Hypercube Sampling (LHS) with \(n\) points in the \(s\)-dimensional unit hypercube |
| 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\) |
| CLMScrambleShift | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a left matrix scrambling and adds a random digital shift |
| CNestedUniformScrambling | This class implements a PointSetRandomization that performs Owen's nested uniform scrambling [191], [195] |
| 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 |
| 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 |
| ▶CPointSet | This abstract class represents a general point set |
| CDefaultPointSetIterator | This class implements a default point set iterator |
| 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 |
| CPointSetRandomization | This interface is for a randomization that can be used to randomize a umontreal.ssj.hups.PointSet |
| CRadicalInverse | This class implements basic methods for working with radical inverses of integers in an arbitrary basis \(b\) |
| CRandomShift | This class implements a umontreal.ssj.hups.PointSetRandomization |
| CRandomStart | This class implements a umontreal.ssj.hups.PointSetRandomization that randomizes a sequence simply by taking a random starting point |
| 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 |
| ▶CRank1Lattice | This class implements point sets specified by integration lattices of rank |
| CRank1LatticeIterator | |
| CRQMCPointSet | This class is used for randomized quasi-Monte Carlo (RQMC) simulations [125], [126], [192], [193] |
| CSMScrambleShift | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a striped matrix scrambling [195] and adds a random digital shift |
| 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] |
| ▶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 |
| CSortedAndCutPointSetIterator | |
| 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 |
| CSubsetOfPointSet | This container class permits one to select a subset of a point set |
| ▶Nlatnetbuilder | Tools to search for good quasi-Monte Carlo point sets and sequences defined as integration lattices, polynomial lattices, and digital nets (and sequences) |
| ▶CDigitalNetSearch | Class for the search of good digital nets using LatNet Builder |
| CDigitalNetBase2FromLatNetBuilder | Class for the construction od digital nets |
| COrdinaryLatticeSearch | Class for the search of good rank-1 ordinary lattice rules using LatNet Builder |
| CPolynomialLatticeSearch | Class for the search of good polynomial lattice rules using LatNet Builder |
| CSearch | Abstract class for the search of highly uniform point sets with LatNet Builder |
| ▶Nmarkovchainrqmc | Tools to simulate Markov chains with the Array-RQMC method |
| CArrayOfComparableChains | 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 |
| 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 |
| ▶Nmcqmctools | Tools for Simple Monte Carlo and Quasi-Monte Carlo Experiments |
| ▶Nanova | Tools to estimate ANOVA components for Monte Carlo models |
| CAnova | This class automates the process of replicating estimators of the ANOVA variances |
| CAnovaObserver | ANOVA observer |
| CAnovaVarianceCollector | Extends ListOfTallies to collect ANOVA variances |
| CAnovaVarianceEstimator | ANOVA variance estimator |
| CBasicObservationCollector | Does nothing but counting the total number of observations |
| CCoordinateSet | Represents a set of coordinates |
| CCoordinateSetLong | Implementation of CoordinateSet using a long bit-mask internal representation |
| CIntegrator | |
| CMeanVarExperiment | |
| CMonteCarloIntegrator | |
| CMonteCarloModelDoubleRQMC | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| CMonteCarloModelRQMC | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| CMonteCarloSampler | Monte Carlo sampler |
| CObservationCollector | |
| CObservationCollectorList | |
| CPartialVariance | Represents the partial variance of a function with respect to a given coordinate set |
| CPartialVarianceEstimator | Partial variance estimator |
| CQMCSampler | QMC sampler |
| CRandomIntegrator | |
| CRandomSampler | |
| CReplicator | Replicator class |
| CReport | |
| CRQMCSampler | QMC sampler |
| CSampler | |
| CSplitStream | Implements a random stream that mixes two input streams by using a coordinate mask |
| CMonteCarloExperiment | Provides generic tools to perform simple Monte Carlo experiments with a simulation model that implements one of the interfaces MonteCarloModelDouble, MonteCarloModelDoubleArray, or MonteCarloModelCV |
| CMonteCarloModel | 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 |
| CMonteCarloModelDouble | An interface for a very simple 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 |
| CRQMCExperiment | Provides basic generic tools to perform RQMC experiments with a simulation model that implements the MonteCarloModelDouble interface |
| 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\) |
| ▶Nprobdist | Probability distributions |
| 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] ) |
| CBernoulliDist | Extends the class DiscreteDistributionInt for the Bernoulli distribution [118] with parameter \(p\), where \(0\le p\le1\) |
| 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\) |
| 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\) |
| 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) |
| CConstantDist | Represents a constant discrete distribution taking a single real value with probability 1 |
| CConstantIntDist | Represents a constant discrete distribution taking a single integer value with probability 1 |
| CContinuousDistribution | Classes implementing continuous distributions should inherit from this base class |
| CCramerVonMisesDist | Extends the class ContinuousDistribution for the Cramér-von Mises distribution (see [55], [224], [225] ) |
| CDiscreteDistribution | This class implements discrete distributions over a finite set of real numbers (also over integers as a particular case) |
| CDiscreteDistributionInt | Classes implementing discrete distributions over the integers should inherit from this class |
| CDistribution | This interface should be implemented by all classes supporting discrete and continuous distributions |
| CDistributionFactory | This class implements a string API for the package probdist |
| CEmpiricalDist | Extends DiscreteDistribution to an empirical distribution function, based on the observations \(X_{(1)},…,X_{(n)}\) (sorted by increasing order) |
| CErlangDist | Extends the class GammaDist for the special case of the Erlang distribution with shape parameter \(k > 0\) and scale parameter \(\lambda> 0\) |
| 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\) |
| 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\) |
| CGeometricDist | Extends the class DiscreteDistributionInt for the geometric distribution [118] (page 322) with parameter \(p\), where \(0 < p < 1\) |
| 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\) |
| 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 |
| 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\) |
| 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)) |
| 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\) |
| 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)) |
| CLogarithmicDist | Extends the class DiscreteDistributionInt for the logarithmic distribution |
| 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\) |
| 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\) |
| 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) |
| 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\) |
| 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)) |
| CPoissonDist | Extends the class DiscreteDistributionInt for the Poisson distribution [118] (page 325) with mean \(\lambda\ge0\) |
| 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]\) |
| CUniformIntDist | Extends the class DiscreteDistributionInt for the discrete uniform distribution over the range \([i,j]\) |
| 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\) |
| ▶Nprobdistmulti | Multivariate Probability Distributions |
| ▶Nnorta | This package implements the correlation matching algorithms proposed in [13] for the situation where one wants to use the NORTA method to fit a multivariate distribution with discrete marginals |
| 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 |
| CNortaInitDisc | This abstract class defines the algorithms used for NORTA initialization when the marginal distributions are discrete |
| 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) |
| CContinuousDistribution2Dim | Classes implementing 2-dimensional continuous distributions should inherit from this class |
| CContinuousDistributionMulti | Classes implementing continuous multi-dimensional distributions should inherit from this class |
| CDirichletDist | Implements the abstract class ContinuousDistributionMulti for the Dirichlet distribution with parameters ( \(\alpha_1\),…, \(\alpha_d\)), \(\alpha_i > 0\) |
| 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\)) |
| CMultiNormalDist | Implements the abstract class ContinuousDistributionMulti for the multinormal distribution with mean vector \(\boldsymbol{\mu}\) and covariance matrix \(\boldsymbol{\Sigma}\) |
| 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\) |
| ▶Nrandvar | Generating Non-Uniform Random Numbers |
| CBernoulliGen | This class implements random variate generators for the Bernoulli distribution (see class umontreal.ssj.probdist.BernoulliDist ) |
| 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] |
| CBetaSymmetricalBestGen | This class implements symmetrical beta random variate generators using Devroye’s one-liner method |
| CBetaSymmetricalGen | This class implements random variate generators with the symmetrical beta distribution with shape parameters \(\alpha= \beta\), over the interval \((0,1)\) |
| CBetaSymmetricalPolarGen | This class implements symmetrical beta random variate generators using Ulrich’s polar method [232] |
| CBinomialConvolutionGen | Implements binomial random variate generators using the convolution method |
| CBinomialGen | This class implements random variate generators for the binomial distribution |
| 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 |
| CChiSquareNoncentralGamGen | This class implements noncentral chi square random variate generators using the additive property of the noncentral chi square distribution [115] |
| CChiSquareNoncentralGen | This class implements random variate generators for the noncentral chi square distribution with \(\nu> 0\) degrees of freedom and noncentrality parameter \(\lambda> 0\) |
| 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 |
| CErlangConvolutionGen | This class implements Erlang random variate generators using the convolution method |
| CErlangGen | This class implements random variate generators for the Erlang distribution with parameters \(k > 0\) and \(\lambda> 0\) |
| 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\) |
| CGammaAcceptanceRejectionGen | This class implements gamma random variate generators using a method that combines acceptance-rejection with acceptance-complement, and proposed in [2], [4] |
| CGammaGen | This class implements random variate generators for the gamma distribution |
| CGammaRejectionLoglogisticGen | This class implements gamma random variate generators using a rejection method with loglogistic envelopes, from [33] |
| CGeometricGen | This class implements a random variate generator for the geometric distribution |
| 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\) |
| CHypergeometricGen | This class implements random variate generators for the hypergeometric distribution |
| 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] |
| 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 |
| CJohnsonSystemG | This class contains common parameters and methods for the random variate generators associated with the Johnson system of distributions [101], [99] |
| 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 |
| CLogarithmicGen | This class implements random variate generators for the (discrete) logarithmic 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 |
| CNegativeBinomialGen | This class implements random variate generators having the negative binomial distribution |
| 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] |
| CNormalGen | This class implements methods for generating random variates from the normal distribution \(N(\mu, \sigma)\) |
| CNormalInverseFromDensityGen | This class implements normal random variate generators using numerical inversion of the normal density as described in [44] |
| 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] |
| 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] |
| CParetoGen | This class implements random variate generators for one of the Pareto distributions, with parameters \(\alpha>0\) and \(\beta>0\) |
| CPascalConvolutionGen | Implements Pascal random variate generators by the convolution method (see [118] ) |
| CPascalGen | Implements Pascal random variate generators, which is a special case of the negative binomial generator with parameter \(\gamma\) equal to a positive integer |
| 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\) |
| CPoissonGen | This class implements random variate generators having the Poisson distribution |
| CPoissonTIACGen | This class implements random variate generators having the Poisson distribution (see PoissonGen ) |
| CPowerGen | This class implements random variate generators for the power distribution with shape parameter \(c > 0\), over the interval \([a,b]\) |
| CRandomVariateGen | This is the base class for all random variate generators over the real line |
| CRandomVariateGenInt | This is the base class for all generators of discrete random variates over the set of integers |
| CRandomVariateGenWithCache | This class represents a random variate generator whose values are cached for more efficiency when using common random numbers |
| CRandUnuran | This internal class provides the access point to the C package UNURAN |
| 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 |
| CStudentNoncentralGen | This class implements random variate generators for the noncentral Student-t distribution with \(n>0\) degrees of freedom and noncentrality parameter \(\delta\) |
| CStudentPolarGen | This class implements Student random variate generators using the polar method of [14] |
| 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\) |
| CUniformIntGen | This class implements a random variate generator for the uniform distribution over integers, over the interval \([i,j]\) |
| CUnuranContinuous | This class permits one to create continuous univariate generators using UNURAN via its string API |
| CUnuranDiscreteInt | This class permits one to create a discrete univariate generator 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 |
| CUnuranException | This type of unchecked exception is thrown when an error occurs inside the UNURAN package |
| CWeibullGen | This class implements random variate generators for the Weibull distribution |
| ▶Nrandvarmulti | Generating Random Vectors |
| CDirichletGen | Extends RandomMultivariateGen for a Dirichlet [98] distribution |
| CIIDMultivariateGen | Extends RandomMultivariateGen for a vector of independent identically distributed (i.i.d.) random variables |
| CMultinormalCholeskyGen | Extends MultinormalGen for a multivariate normal distribution [98] , generated via a Cholesky decomposition of the covariance matrix |
| CMultinormalGen | Extends RandomMultivariateGen for a multivariate normal (or multinormal) distribution [98] |
| CMultinormalPCAGen | Extends MultinormalGen for a multivariate normal distribution [98] , generated via the method of principal components analysis (PCA) of the covariance matrix |
| CRandomMultivariateGen | This class is the multivariate counterpart of umontreal.ssj.randvar.RandomVariateGen |
| ▶Nrng | Random Number Generators |
| 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 |
| CBasicRandomStreamFactory | Represents a basic random stream factory that can constructs new instances of a given RandomStream implementation via the newInstance method |
| CCloneableRandomStream | CloneableRandomStream extends RandomStream and Cloneable |
| 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 |
| ▶CF2wPoly | |
| ▶CF2w | |
| CF2wElem | |
| CF2wPolyElem | |
| 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 |
| CRandMrg | USE MRG32k3a INSTEAD of this class |
| 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 |
| CRandomStreamBase | This class provides a convenient foundation on which RNGs can be built |
| 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 |
| 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 |
| CRandomStreamManager | Manages a list of random streams for more convenient synchronization |
| CRandomStreamWithCache | This class represents a random stream whose uniforms are cached for more efficiency when using common random numbers |
| CRandRijndael | Implements a RNG using the Rijndael block cipher algorithm (AES) with key and block lengths of 128 bits |
| 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 |
| 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 |
| CWELL1024 | Implements the RandomStream interface via inheritance from RandomStreamBase |
| CWELL512 | This class implements the RandomStream interface via inheritance from RandomStreamBase |
| CWELL607 | This class implements the RandomStream interface via inheritance from RandomStreamBase |
| CWELL607base | |
| ▶Nsimevents | Simulation Clock and Event List Management |
| ▶Neventlist | This package provides different kinds of event list implementations |
| CBinaryTree | An implementation of EventList using a binary search tree |
| CDoublyLinked | An implementation of EventList using a doubly linked linear list |
| CEventList | An interface for implementations of event lists |
| 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] |
| CAccumulate | A subclass of umontreal.ssj.stat.StatProbe, for collecting statistics on a variable that evolves in simulation time, with a piecewise-constant trajectory |
| CContinuous | Represents a variable in a continuous-time simulation |
| ▶CContinuousState | Represents the portion of the simulator’s state associated with continuous-time simulation |
| CIntegMethod | |
| CEvent | This abstract class provides event scheduling tools |
| CLinkedListStat | This class extends ListWithStat, and uses a linked list as the internal data structure |
| ▶CListWithStat | 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 |
| CNode | Represents a node that can be part of a list with statistical collecting |
| CSim | This static class contains the executive of a discrete-event simulation |
| CSimulator | Represents the executive of a discrete-event simulator |
| ▶Nsimexp | Tools for Simulation Experiments |
| 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 |
| CSimExp | Represents a framework for performing experiments using simulation |
| ▶Nstat | Tools for Collecting Statistics and computing some estimators |
| ▶Ndensity | Univariate density estimation |
| CDEDerivativeGaussian | This class implements a density derivative estimator (DDE) with a Gaussian ( i.e., standard normal) kernel function |
| 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 |
| CDensityEstimator | This abstract class represents a univariate density estimator (DE) |
| ▶Nlist | |
| ▶Nlincv | |
| CFunctionOfMultipleMeansTallyWithCV | Represents a function of multiple means tally for an estimator with linear control variables |
| CListOfTalliesWithCV | Represents a list of tallies with control variables that inherits the functionalities of a list of tallies, and accepts vectors of length \(p+q\) |
| CArrayOfObservationListener | Represents an object that can listen to observations broadcast by lists of statistical probes |
| CListOfFunctionOfMultipleMeansTallies | Represents a list of tally statistical collectors for a vector of functions of multiple means |
| CListOfStatProbes | Represents a list of statistical probes that can be managed simultaneously |
| CListOfTallies | Represents a list of tally statistical collectors |
| CListOfTalliesWithCovariance | Extends ListOfTallies to add support for the computation of the sample covariance between each pair of elements in a list, without storing all observations |
| ▶Nmatrix | |
| CMatrixOfFunctionOfMultipleMeansTallies | Represents a matrix of statistical collectors for functions of multiple means |
| CMatrixOfObservationListener | Represents an object that can listen to observations broadcast by matrices of statistical probes |
| CMatrixOfStatProbes | Represents a matrix of statistical probes that can be managed simultaneously |
| CMatrixOfTallies | Represents a matrix of tally statistical collectors |
| CFunctionOfMultipleMeansTally | Represents a statistical collector for estimating a function of multiple means with a confidence interval based on the delta theorem [214] |
| CHistogramChartToLatex | |
| CHistogramOnly | This class is similar to TallyHistogram, except that it does not maintain the min, max, average, and variance of the observations |
| CObservationListener | Represents an object that can listen to observations broadcast by statistical probes |
| 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 |
| 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 |
| CStatProbe | The objects of this class are statistical probes or collectors, which are elementary devices for collecting statistics |
| CTally | A subclass of StatProbe |
| CTallyHistogram | This class extends Tally |
| CTallyStore | This class is a variant of Tally for which the individual observations are stored in a list implemented as a DoubleArrayList |
| ▶Nstochprocess | Stochastic Processes |
| 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] ) |
| 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 |
| 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 |
| 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 |
| 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 |
| CInverseGaussianProcessBridge | Samples the path by bridge sampling: first finding the process value at the final time and then the middle time, etc |
| ▶CInverseGaussianProcessMSH | Uses a faster generating method (MSH) [180] than the simple inversion of the distribution function used by InverseGaussianProcess |
| CNonRandomStream | NonRandomStream: Given a double array, this class will return those values as if it where a random stream |
| CInverseGaussianProcessPCA | Approximates a principal component analysis (PCA) decomposition of the InverseGaussianProcess |
| 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 |
| CMultivariateStochasticProcess | This class is a multivariate version of StochasticProcess where the process evolves in the \(c\)-dimensional real space |
| 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 |
| 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\) |
| 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 |
| ▶Nutil | General basic utilities |
| ▶Nio | This package provides tools for exporting data to text and binary files, as well as for importing data from files |
| CAbstractDataReader | This abstract class implements shared functionality for data readers |
| CAbstractDataWriter | This abstract class implements shared functionality for data writers |
| CBinaryDataReader | Binary data reader |
| 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 |
| CDataField | This class represents a data field from a file read by an instance of a class implementing DataReader |
| CDataReader | Data reader interface |
| CDataWriter | Data writer interface |
| ▶CTextDataWriter | Text data writer |
| CFormat | Output format: organize fields as columns or as rows |
| ▶Nsort | This package contains classes for sorting, in particular to sort multi-dimensional points |
| CBatchSort | 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 |
| 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 |
| CHilbertCurveBatchSort | 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 |
| CHilbertCurveMap | This class implements the mapping of a Hilbert curve in the \(d\)-dimensional unit hypercube \([0,1)^d\) |
| ▶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 |
| CLongIndexComparator2 | The comparator class used by sortIndexOfLong2 |
| CMultiDim01 | This interface represents a point or array of \(d\) dimensions in a unit hypercube \([0, 1)^d\) |
| CMultiDimComparable | This interface is an extension (or variant) of the Comparable interface in Java |
| CMultiDimComparator | 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 |
| CMultiDimSort | This interface is meant to be implemented by certain multivariate sorting algorithms that sort objects based on different fields (or dimensions) |
| CMultiDimSort01 | This interface extends MultiDimSort<T> to implement multivariate sorting algorithms that sort points of \(d\) dimensions in the unit hypercube \([0, 1)^d\) |
| CMultiDimSortComparable | This interface extends MultiDimSort<T> to implement multivariate sorting algorithms that sort objects that are pairwise comparable |
| COneDimSort | This class implements a MultiDimSortComparable that simply sorts the objects according to a given sorting coordinate \(j \ge0\) specified in the constructor |
| CSplitSort | Implements a MultiDimSortComparable that performs a split sort on a MultiDimComparable<T> array based on its first \(d\) dimensions |
| 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 |
| CArithmeticMod | This class provides facilities to compute multiplications of scalars, of vectors and of matrices modulo m |
| ▶CBitMatrix | This class implements matrices of bits of arbitrary dimensions |
| CIncompatibleDimensionException | Runtime exception raised when the dimensions of the BitMatrix are not appropriate for the operation |
| CBitVector | This class implements vectors of bits and the operations needed to use them |
| 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 |
| CClassFinder | Utility class used to convert a simple class name to a fully qualified class object |
| CDMatrix | This class implements a few methods for matrix calculations with double numbers |
| CGlobalCPUTimeChrono | Extends the AbstractChrono class to compute the global CPU time used by the Java Virtual Machine |
| CIntrospection | Provides utility methods for introspection using Java Reflection API |
| CJDBCManager | This class provides some facilities to connect to a SQL database and to retrieve data stored in it |
| CMisc | This class provides miscellaneous functions that are hard to classify |
| CMultivariateFunction | Represents a function of multiple variables |
| CNameConflictException | This exception is thrown by a ClassFinder when two or more fully qualified class names can be associated with a simple class name |
| CNativeUtils | A simple library class which helps with loading dynamic libraries stored in the JAR archive |
| CNum | This class provides a few constants and some methods to compute numerical quantities such as factorials, combinations, gamma functions, and so on |
| CPrintfFormat | This class acts like a StringBuffer which defines new types of append methods |
| CRatioFunction | Represents a function computing a ratio of two values |
| CRootFinder | This class provides methods to solve non-linear equations |
| CSysteme | This class provides a few tools related to the system or the computer |
| CSystemTimeChrono | Extends the AbstractChrono class to compute the total system time using Java’s builtin System.nanoTime |
| 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 |
| CThreadCPUTimeChrono | Extends the AbstractChrono class to compute the CPU time for a single thread |
| CTimeUnit | Represents a time unit for conversion of time durations |
| CTransformingList | Represents a list that dynamically transforms the elements of another list |
1.8.14