Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

Ptutorial
CAsianGBM
CAsianGBM2
CAsianGBMRQMC
CAsianGBMRQMC2
CBankEv
CArrival
CDeparture
CCallCenter
CCall
CNextPeriod
CArrival
CCallCompletion
CCallEv
CCall
CNextPeriod
CArrival
CCallCompletion
CCollision
CCompareOutputs
CInventory
CInventoryCRN
CNonuniform
CPreyPred
CPreys
CPreds
CPrintPoint
CEndOfSim
CQueueEv
CCustomer
CArrival
CDeparture
CEndOfSim
CQueueLindley
CQueueObs
CObservationTrace
CLargeWaitsCollector
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
CTestAsianRQMCSeries
Pumontreal
Pssj
Pcharts	Charts generation
CAxis	Represents an axis of a chart encapsulated by an instance of XYChart
CBoxChart	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	Provides tools to create and manage empirical plots, which are used to plot empirical distributions
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	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	Provides PP-plot (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	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	Provides tools to create and manage curve plots
CYListChart	Extends XYLineChart; each YListChart object is associated with a YListSeriesCollection data set
CYListSeriesCollection	This class extends umontreal.ssj.charts.XYListSeriesCollection
Pdiscrepancy	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 DiscShiftBaker1 [see eq
CBigDiscShiftBaker1Lattice	This class computes the same discrepancy as in DiscShiftBaker1Lattice [see eq
CDiscL2Hickernell	This class computes the Hickernell \(\mathcal{L}_2\)-star discrepancy in [78]  (eq
CDiscL2Star	Computes the traditional \(\mathcal{L}_2\)-star discrepancy \(\mathcal{D}_2^*(\mathcal{P})\) for a set of \(n\) points \(\mathcal{P}\) [226], [227],
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}\) [81]  (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 [81]  (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 [81]  (eq
CPalpha	Extends the class Discrepancy and implements the methods required to compute the \(P_{\alpha}\) figure of merit for a lattice point set
CSearcher	This class implements methods to search for the best lattices of rank 1, defined as follows [212]
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
Pfunctionfit	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 [41],
Pfunctions	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
CSquareMathFunction	Represents a function computing \((af(x) + b)^2\) for a user-defined function \(f(x)\)
Pgof	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
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
Phups	Quasi-Monte Carlo 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., [47], [81], [152])
CBakerTransformedPointSetIterator
CCachedPointSet	This container class caches a point set by precomputing and storing all the points locally in an array
CCachedPointSetIterator	This class implements a CachedPointSet iterator which takes the values directly in the array x in which the points are cached, rather than calling CachedPointSet.getCoordinate
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 [144], [119], [181], 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
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
CDigitalNetBase2IteratorShiftGenerators
CDigitalNetBase2IteratorShiftNoGray
CEmptyRandomization	This class implements an empty
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
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 [73] , 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
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\)
CLMScramble	This class implements a umontreal.ssj.hups.PointSetRandomization that performs a left matrix scrambling
CLMScrambleShift	This class implements a umontreal.ssj.hups.PointSetRandomization that performs a left matrix scrambling and adds a random digital shift
CNestedUniformScrambling	This PointSetRandomization class provides the nested uniform scrambling (NUS) randomization proposed by Owen ([185], [189]) for digital nets
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
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 1
CRank1LatticeIterator
CRQMCPointSet	This class is used for randomized quasi-Monte Carlo (RQMC) simulations
CSMScrambleShift	This class implements a umontreal.ssj.hups.PointSetRandomization that performs a striped matrix scrambling [189] 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 [213], [rSOB76b]
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
Platnetbuilder	Provides an interface to the LatNet Builder software to search for good quasi-Monte Carlo point sets and sequences defined as integration lattices, polynomial lattices, and digital nets and sequences
Pweights	This package implements weights that can be used in the search of good quasi-Monte Carlo Point sets with search tools such as LatNet Builder
CGeometricWeights	Class implementing a special case of OrderDependentWeights, \(\Gamma_{k} = c \rho^{k-1} \) , where each weight is given by a baseWeight \(\rho\) raised to \(k-1\), i.e., the power of the order of the projection it is assigned to - 1
COrderDependentWeights	Class implementing order dependent weights
CPODWeights	This class implements so-called product- and order dependent weights (POD weights)
CProductWeights	Class implementing product weights
CProjectionDependentWeights	Class implementing projection dependent weights
CSingletonWeight	Implements a single instance of a weight for search-algorithms for quasi-Monte Carlo point sets as, e.g., those implemented in LatNet Builder
CSingletonWeightComparable	Implements single instances of weights
CWeights	This abstract class implements generic weights that can be used to search for good quasi-Monte Carlo point sets such as Rank1Lattice, DigitalNet, etc
CWeightsComparable	Implements comparable Weights
CDigitalNetSearch	Class for the search of good digital nets using LatNet Builder
CDigitalNetBase2FromLatNetBuilder	Class for the construction of 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
Pmarkovchainrqmc	Tools to simulate Markov chains with the Array-RQMC method
CArrayOfComparableChains	This class provides tools to simulate an array of
CArrayOfDoubleChains	Similar to ArrayOfComparableChains, except that instead of working with \(n\) clones of a MarkovChain, we use a single
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
CMarkovChainDouble	A special kind of Markov chain whose state space is a subset of the real numbers
Pmcqmctools	Functions to help make simple Monte Carlo and quasi-Monte Carlo experiments
Panova	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\)
Pprobdist	Probability distributions
CAndersonDarlingDist	Extends the class ContinuousDistribution for the Anderson–Darling distribution (see [6], [161], [169],
CAndersonDarlingDistQuick	Extends the class AndersonDarlingDist for the Anderson–Darling distribution (see [6], [161], [216] )
CBernoulliDist	Extends the class DiscreteDistributionInt for the Bernoulli distribution [114]  with parameter \(p\), where
CBetaDist	Extends the class ContinuousDistribution for the beta distribution
CBetaSymmetricalDist	Specializes the class BetaDist to the case of a symmetrical beta distribution over the interval \([0,1]\), with shape parameters
CBinomialDist	Extends the class DiscreteDistributionInt for the binomial distribution [114]  (page 321) with parameters \(n\) and
CCauchyDist	Extends the class ContinuousDistribution for the Cauchy distribution [95]  (page 299) with location parameter
CChiDist	Extends the class ContinuousDistribution for the chi distribution
CChiSquareDist	Extends the class ContinuousDistribution for the chi-square distribution with \(n\) degrees of freedom, where \(n\) is a positive integer [95]  (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
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 [54], [215], [216] )
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
CExponentialDist	Extends the class ContinuousDistribution for the exponential distribution [95]  (page 494) with mean \(1/\lambda\) where \(\lambda> 0\) is the rate parameter
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 [19]  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
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 [96]  (page 3), with location parameter
CGammaDist	Extends the class ContinuousDistribution for the gamma distribution [95]  (page 337) with shape parameter
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 rate parameter \(\lambda\)
CGeometricDist	Extends the class DiscreteDistributionInt for the geometric distribution [114]  (page 322) with parameter \(p\), where \(0 < p < 1\)
CGumbelDist	Extends the class ContinuousDistribution for the Gumbel distribution [96]  (page 2), with location parameter
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
CHypergeometricDist	Extends the class DiscreteDistributionInt for the hypergeometric distribution [64]  (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
CInverseGammaDist	Extends the class ContinuousDistribution for the inverse gamma distribution with shape parameter \(\alpha> 0\) and scale parameter
CInverseGaussianDist	Extends the class ContinuousDistribution for the inverse Gaussian distribution with location parameter \(\mu> 0\) and scale parameter
CJohnsonSBDist	Extends the class ContinuousDistribution for the Johnson
CJohnsonSLDist	Extends the class ContinuousDistribution for the Johnson
CJohnsonSUDist	Extends the class ContinuousDistribution for the Johnson
CJohnsonSystem	This class contains common parameters and methods for the Johnson system of distributions [97], [95]  with shape parameters \(\gamma\) and \(\delta> 0\), location parameter
CKolmogorovSmirnovDist	Extends the class ContinuousDistribution for the Kolmogorov-Smirnov distribution with parameter \(n\)
CKolmogorovSmirnovDistQuick	Extends the class KolmogorovSmirnovDist for the Kolmogorov–Smirnov distribution
CKolmogorovSmirnovPlusDist	Extends the class ContinuousDistribution for the Kolmogorov–Smirnov+ distribution (see [39], [54],
CLaplaceDist	Extends the class ContinuousDistribution for the Laplace distribution (see, e.g., [96]  (page 165))
CLogarithmicDist	Extends the class DiscreteDistributionInt for the logarithmic distribution
CLogisticDist	Extends the class ContinuousDistribution for the logistic distribution (e.g., [96]  (page 115))
CLoglogisticDist	Extends the class ContinuousDistribution for the Log-Logistic distribution with shape parameter \(\alpha> 0\) and scale parameter
CLognormalDist	Extends the class ContinuousDistribution for the lognormal distribution [95]
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 [114]  (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., [95]  (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
CParetoDist	Extends the class ContinuousDistribution for a distribution from the Pareto family, with shape parameter \(\alpha> 0\) and location parameter \(\beta> 0\) [95]  (page 574)
CPascalDist	The Pascal distribution is a special case of the negative binomial distribution [114]  (page 324) with parameters \(n\) and
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., [114]  (page 318))
CPoissonDist	Extends the class DiscreteDistributionInt for the Poisson distribution [114]  (page 325) with mean
CPowerDist	Extends the class ContinuousDistribution for the power distribution [56]  (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 [56]  with location parameter
CStudentDist	Extends the class ContinuousDistribution for the Student
CStudentDistQuick	Extends the class StudentDist for the Student
CTriangularDist	Extends the class ContinuousDistribution for the triangular distribution (see [96]  (page 297) and
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 [96]  (page 276) over the interval
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 [40], [228] )
CWatsonUDist	Extends the class ContinuousDistribution for the Watson U distribution (see [54], [215], [216] )
CWeibullDist	This class extends the class ContinuousDistribution for the Weibull distribution [95]  (page 628) with shape parameter \(\alpha> 0\), location parameter \(\delta\), and scale parameter \(\lambda> 0\)
Pprobdistmulti	Multivariate Probability Distributions
Pnorta	This package implements the correlation matching algorithms proposed in [12]  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 [94]  (page 84)
CBiNormalDonnellyDist	Extends the class BiNormalDist for the bivariate normal distribution [94]  (page 84) using a translation of Donnelly’s Fortran code in [52]
CBiNormalGenzDist	Extends the class BiNormalDist for the bivariate normal distribution [94]  (page 84) using Genz’s algorithm as described in [65]
CBiStudentDist	Extends the class ContinuousDistribution2Dim for the standard bivariate Student’s \(t\) distribution [94]  (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\)
Prandvar	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 [33]
CBetaStratifiedRejectionGen	This class implements Beta random variate generators using the stratified rejection/patchwork rejection method from [202],
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 [223]
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
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
CExtremeValueGen	This class has been replaced by GumbelGen
CFatigueLifeGen	This class implements random variate generators for the fatigue life distribution [19]  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
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 [32]
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 [43]
CInverseGammaGen	This class implements random variate generators for the inverse gamma distribution with shape parameter \(\alpha> 0\) and scale parameter
CInverseGaussianGen	This class implements random variate generators for the inverse Gaussian distribution with location parameter \(\mu> 0\) and scale parameter
CInverseGaussianMSHGen	This class implements inverse gaussian random variate generators using the many-to-one transformation method of Michael, Schucany and Haas (MHS)
CJohnsonSBGen	This class implements random variate generators for the Johnson
CJohnsonSLGen	This class implements random variate generators for the Johnson
CJohnsonSUGen	This class implements random variate generators for the Johnson
CJohnsonSystemG	This class contains common parameters and methods for the random variate generators associated with the Johnson system of distributions
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\) [44], [45], [85],
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 [207]
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
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 [83]
CNormalBoxMullerGen	This class implements normal random variate generators using the Box-Muller method from [22]
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 [43]
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
CNormalKindermannRamageGen	This class implements normal random variate generators using the Kindermann-Ramage method [102]
CNormalPolarGen	This class implements normal random variate generators using the polar method with rejection [172]
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 [114] )
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
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 [13]
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
CUniformIntGen	This class implements a random variate generator for the uniform distribution over integers, over the interval \([i,j]\)
CWeibullGen	This class implements random variate generators for the Weibull distribution
Prandvarmulti	Generating Random Vectors
CDirichletGen	Extends RandomMultivariateGen for a Dirichlet
CIIDMultivariateGen	Extends RandomMultivariateGen for a vector of independent identically distributed (i.i.d.) random variables
CMultinormalCholeskyGen	Extends MultinormalGen for a multivariate normal distribution
CMultinormalGen	Extends RandomMultivariateGen for a multivariate normal (or multinormal) distribution [94]
CMultinormalPCAGen	Extends MultinormalGen for a multivariate normal distribution
CRandomMultivariateGen	This class is the multivariate counterpart of
Prng	Streams of independent uniform random numbers
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
CLFSR113	Extends RandomStreamBase using a composite linear feedback shift register (LFSR) (or Tausworthe) RNG as defined in [144],
CLFSR258	Extends RandomStreamBase using a 64-bit composite linear feedback shift register (LFSR) (or Tausworthe) RNG as defined in [144],
CMRG31k3p	Extends the abstract class RandomStreamBase, thus implementing the
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 [145] , implemented in 64-bit floating-point arithmetic
CMRG32k3aL	The same generator as MRG32k3a, except here it is implemented with type long instead of double
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
CTruncatedRandomStream	Represents a container random stream generating numbers in an interval
CWELL512	This class implements the RandomStream interface via inheritance from RandomStreamBase
Psimevents	Simulation Clock and Event List Management
Peventlist	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 [104]  (see also [61]  (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
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
Psimexp	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
Pstat	Tools for Collecting Statistics and computing estimators and confidence intervals
Pdensity	Tools for univariate density estimation
CConditionalDensityEstimator	This is an abstract class that implements an DensityEstimatorDoubleArray
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)
CDensityEstimatorDoubleArray	Same as DensityEstimator but here the observations of the underlying model are \(t\)-dimensional
Plist	Provides support for lists of statistical probes
Plincv	Managing estimators with control variates
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
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
Pmatrix	Provides facilities to construct and manage rectangular 2D arrays of statistical probes
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
CListType
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
CCIType
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
CCIType
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
Pstochprocess	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
CBrownianMotionPCA	A Brownian motion process \(\{X(t) : t \geq0 \}\) sampled using the principal component decomposition (PCA) [67], [91],
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
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 [167]  (page 82) \(\{ S(t) = G(t; \mu, \nu) : t \geq0 \}\) with mean parameter
CGammaProcessBridge	This class represents a gamma process \(\{ S(t) = G(t; \mu, \nu) : t \geq0 \}\) with mean parameter \(\mu\) and variance parameter
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
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)\):
CGeometricNormalInverseGaussianProcess	The geometric normal inverse gaussian (GNIG) process is the exponentiation of a NormalInverseGaussianProcess :
CGeometricVarianceGammaProcess	This class represents a geometric variance gamma process \(S(t)\) (see
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) [175]  than the simple inversion of the distribution function used by
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
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 [67] , 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
COrnsteinUhlenbeckWithIntegratedProcess	This class is custom-made for the CallableBond example
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
CVarianceGammaProcessDiffPCABridge	Same as VarianceGammaProcessDiff, but the two inner
CVarianceGammaProcessDiffPCASymmetricalBridge	Same as VarianceGammaProcessDiff, but the two inner
Putil	This package provides various kinds of general basic utilities used in SSJ and also in the simulation laboratory at DIRO, Université de Montréal
Pio	This subpackage 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
Pmultidimsort	This subpackage contains classes for sorting 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
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
CHilbertCurveMap	This class implements the mapping of a Hilbert curve in the
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
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 the base class for timer (stopwatch) objects that can measure the CPU time or wall clock time elapsed when executing 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	Extends the AbstractChrono class to compute the CPU time for a single thread
CChronoWall	Extends the AbstractChrono class to compute the wall-clock time using Java's builtin System.nanoTime
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 when the matrix entries are in double
CIntrospection	Provides utility methods for introspection using the 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 various constants and 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 numerical methods to solve non-linear equations
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	Represents a list that dynamically transforms the elements of another list