| CAbstractIntervalXYDataset | |
| Cumontreal.ssj.charts.CustomHistogramDataset | A dataset that can be used for creating histograms |
| CAbstractList | |
| Cumontreal.ssj.util.TransformingList< OE, IE > | Represents a list that dynamically transforms the elements of another list |
| Cumontreal.ssj.simevents.ListWithStat< E > | Implements a list with integrated statistical probes to provide automatic collection of statistics on the sojourn times of objects in the list and on the size of the list as a function of time given by a simulator |
| Cumontreal.ssj.simevents.LinkedListStat< E > | This class extends ListWithStat, and uses a linked list as the internal data structure |
| CAppendable | |
| Cumontreal.ssj.util.PrintfFormat | This class acts like a StringBuffer which defines new types of append methods |
| CArrayList | |
| Cumontreal.ssj.mcqmctools.anova.ObservationCollectorList< E > | |
| CCharSequence | |
| Cumontreal.ssj.util.PrintfFormat | This class acts like a StringBuffer which defines new types of append methods |
| CCloneable | |
| Cumontreal.ssj.charts.CustomHistogramDataset | A dataset that can be used for creating histograms |
| Cumontreal.ssj.charts.EmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| Cumontreal.ssj.functions.Polynomial | Represents a polynomial of degree \(n\) in power form |
| Cumontreal.ssj.functionfit.PolInterp | Represents a polynomial that interpolates through a set of points |
| Cumontreal.ssj.markovchainrqmc.MarkovChain | 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 |
| Cumontreal.ssj.markovchainrqmc.MarkovChainComparable | A subclass of MarkovChain for which there is a total ordering between the states, induced by the implementation of the |
| Cumontreal.ssj.markovchainrqmc.MarkovChainDouble | A special kind of Markov chain whose state space is a subset of the real numbers |
| Cumontreal.ssj.rng.CloneableRandomStream | CloneableRandomStream extends RandomStream and Cloneable |
| Cumontreal.ssj.rng.RandomStreamBase | This class provides a convenient foundation on which RNGs can be built |
| Cumontreal.ssj.mcqmctools.anova.SplitStream | Implements a random stream that mixes two input streams by using a coordinate mask |
| Cumontreal.ssj.rng.LFSR113 | Extends RandomStreamBase using a composite linear feedback shift register (LFSR) (or Tausworthe) RNG as defined in [144], |
| Cumontreal.ssj.rng.LFSR258 | Extends RandomStreamBase using a 64-bit composite linear feedback shift register (LFSR) (or Tausworthe) RNG as defined in [144], |
| Cumontreal.ssj.rng.MRG31k3p | Extends the abstract class RandomStreamBase, thus implementing the |
| Cumontreal.ssj.rng.MRG32k3a | 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 |
| Cumontreal.ssj.rng.MRG32k3aL | The same generator as MRG32k3a, except here it is implemented with type long instead of double |
| Cumontreal.ssj.rng.WELL512 | This class implements the RandomStream interface via inheritance from RandomStreamBase |
| Cumontreal.ssj.simevents.Accumulate | A subclass of umontreal.ssj.stat.StatProbe, for collecting statistics on a variable that evolves in simulation time, with a piecewise-constant trajectory |
| Cumontreal.ssj.stat.FunctionOfMultipleMeansTally | Represents a statistical collector for estimating a function of multiple means with a confidence interval based on the delta theorem |
| Cumontreal.ssj.stat.list.lincv.FunctionOfMultipleMeansTallyWithCV | Represents a function of multiple means tally for an estimator with linear control variables |
| Cumontreal.ssj.stat.HistogramOnly | This class is similar to TallyHistogram, except that it does not maintain the min, max, average, and variance of the observations |
| Cumontreal.ssj.stat.Tally | A subclass of StatProbe |
| Cumontreal.ssj.mcqmctools.anova.PartialVariance | Represents the partial variance of a function with respect to a given coordinate set |
| Cumontreal.ssj.stat.TallyHistogram | This class extends Tally |
| Cumontreal.ssj.stat.HistogramOnly | This class is similar to TallyHistogram, except that it does not maintain the min, max, average, and variance of the observations |
| Cumontreal.ssj.stat.TallyStore | This class is a variant of Tally for which the individual observations are stored in a list implemented as a DoubleArrayList |
| Cumontreal.ssj.stat.list.ListOfStatProbes< E extends StatProbe > | Represents a list of statistical probes that can be managed simultaneously |
| Cumontreal.ssj.stat.matrix.MatrixOfStatProbes< E extends StatProbe > | Represents a matrix of statistical probes that can be managed simultaneously |
| Cumontreal.ssj.util.BitMatrix | This class implements matrices of bits of arbitrary dimensions |
| Cumontreal.ssj.util.BitVector | This class implements vectors of bits and the operations needed to use them |
| Cumontreal.ssj.util.ClassFinder | Utility class used to convert a simple class name to a fully qualified class object |
| CComparable | |
| Cumontreal.ssj.latnetbuilder.weights.SingletonWeightComparable< T extends Comparable< T > > | Implements single instances of weights |
| Cumontreal.ssj.mcqmctools.anova.PartialVariance | Represents the partial variance of a function with respect to a given coordinate set |
| Cumontreal.ssj.simevents.Event | This abstract class provides event scheduling tools |
| Ctutorial.BankEv.Arrival | |
| Ctutorial.BankEv.Departure | |
| Ctutorial.CallCenter.Arrival | |
| Ctutorial.CallCenter.CallCompletion | |
| Ctutorial.CallCenter.NextPeriod | |
| Ctutorial.CallEv.Arrival | |
| Ctutorial.CallEv.CallCompletion | |
| Ctutorial.CallEv.NextPeriod | |
| Ctutorial.PreyPred.EndOfSim | |
| Ctutorial.PreyPred.PrintPoint | |
| Ctutorial.QueueEv.Arrival | |
| Ctutorial.QueueEv.Departure | |
| Ctutorial.QueueEv.EndOfSim | |
| CComparator | |
| Cumontreal.ssj.hups.DigitalNetFromFile.NetComparator | |
| Cumontreal.ssj.util.multidimsort.DoubleArrayComparator | 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 |
| Cumontreal.ssj.util.multidimsort.HilbertCurveSort.LongIndexComparator2 | The comparator class used by sortIndexOfLong2 |
| Cumontreal.ssj.util.multidimsort.MultiDimComparator< T extends MultiDimComparable<? super T > > | This class is useful if one wishes to perform an ordinary one-dimensional sort on MultiDimComparable<T> objects based on a single coordinate |
| CException | |
| Ctutorial.RunClass.RunClassException | |
| Cumontreal.ssj.util.NameConflictException | This exception is thrown by a ClassFinder when two or more fully qualified class names can be associated with a simple class name |
| CIntervalXYDataset | |
| Cumontreal.ssj.charts.CustomHistogramDataset | A dataset that can be used for creating histograms |
| CIterable | |
| Cumontreal.ssj.simevents.eventlist.EventList | An interface for implementations of event lists |
| Cumontreal.ssj.simevents.eventlist.BinaryTree | An implementation of EventList using a binary search tree |
| Cumontreal.ssj.simevents.eventlist.DoublyLinked | An implementation of EventList using a doubly linked linear list |
| Cumontreal.ssj.simevents.eventlist.Henriksen | An implementation of EventList using the doubly-linked indexed list of Henriksen [104] (see also [61] (p |
| Cumontreal.ssj.simevents.eventlist.RedblackTree | 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 |
| Cumontreal.ssj.simevents.eventlist.SplayTree | An implementation of EventList using a splay tree |
| Cumontreal.ssj.stat.matrix.MatrixOfStatProbes< E extends StatProbe > | Represents a matrix of statistical probes that can be managed simultaneously |
| Cjava.io.Serializable | |
| Cumontreal.ssj.util.ClassFinder | Utility class used to convert a simple class name to a fully qualified class object |
| CList | |
| Cumontreal.ssj.stat.list.ListOfStatProbes< E extends StatProbe > | Represents a list of statistical probes that can be managed simultaneously |
| CPublicCloneable | |
| Cumontreal.ssj.charts.CustomHistogramDataset | A dataset that can be used for creating histograms |
| Cumontreal.ssj.charts.EmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| CRandomAccess | |
| Cumontreal.ssj.stat.list.ListOfStatProbes< E extends StatProbe > | Represents a list of statistical probes that can be managed simultaneously |
| CRuntimeException | |
| Cumontreal.ssj.rng.RandomStreamInstantiationException | This exception is thrown when a random stream factory cannot instantiate a stream on a call to its umontreal.ssj.rng.RandomStreamFactory.newInstance method |
| Cumontreal.ssj.util.BitMatrix.IncompatibleDimensionException | Runtime exception raised when the dimensions of the BitMatrix are not appropriate for the operation |
| CSerializable | |
| Cumontreal.ssj.functionfit.PolInterp | Represents a polynomial that interpolates through a set of points |
| Cumontreal.ssj.functions.Polynomial | Represents a polynomial of degree \(n\) in power form |
| Cumontreal.ssj.rng.RandomStreamBase | This class provides a convenient foundation on which RNGs can be built |
| Cumontreal.ssj.util.BitMatrix | This class implements matrices of bits of arbitrary dimensions |
| Cumontreal.ssj.util.BitVector | This class implements vectors of bits and the operations needed to use them |
| Ctutorial.AsianGBM | |
| Ctutorial.AsianGBMRQMC | |
| Ctutorial.TestAsianRQMCSeries | |
| Ctutorial.BankEv | |
| Ctutorial.CallCenter | |
| Ctutorial.CallCenter.Call | |
| Ctutorial.CallEv | |
| Ctutorial.CallEv.Call | |
| Ctutorial.Collision | |
| Ctutorial.CompareOutputs | |
| Ctutorial.Inventory | |
| Ctutorial.InventoryCRN | |
| Ctutorial.Nonuniform | |
| Ctutorial.PreyPred | |
| Ctutorial.QueueEv | |
| Ctutorial.QueueEv.Customer | |
| Ctutorial.QueueLindley | |
| Ctutorial.QueueObs | |
| Ctutorial.RunClass | |
| Ctutorial.Snippet | |
| Cumontreal.ssj.charts.Axis | Represents an axis of a chart encapsulated by an instance of XYChart |
| Cumontreal.ssj.charts.CategoryChart | This class provides tools to create charts from data in a simple way |
| Cumontreal.ssj.charts.BoxChart | Provides tools to create and manage box-and-whisker plots |
| Cumontreal.ssj.charts.ContinuousDistChart | This class provides tools to plot the density and the cumulative probability of a continuous probability distribution |
| Cumontreal.ssj.charts.DiscreteDistIntChart | This class provides tools to plot the mass function and the cumulative probability of a discrete probability distribution over the integers |
| Cumontreal.ssj.charts.MultipleDatasetChart | Provides tools to plot many datasets on the same chart |
| Cumontreal.ssj.charts.PlotFormat | Provide tools to import and export data set tables to and from Gnuplot, MATLAB and Mathematica compatible formats, or customized format |
| Cumontreal.ssj.charts.SSJCategorySeriesCollection | Stores data used in a CategoryChart |
| Cumontreal.ssj.charts.BoxSeriesCollection | This class stores data used in a umontreal.ssj.charts.CategoryChart |
| Cumontreal.ssj.charts.SSJXYSeriesCollection | Stores data used in a XYChart |
| Cumontreal.ssj.charts.EmpiricalSeriesCollection | Stores data used in a EmpiricalChart |
| Cumontreal.ssj.charts.HistogramSeriesCollection | Stores data used in a HistogramChart |
| Cumontreal.ssj.charts.XYChart | This class provides tools to create charts from data in a simple way |
| Cumontreal.ssj.charts.EmpiricalChart | Provides tools to create and manage empirical plots, which are used to plot empirical distributions |
| Cumontreal.ssj.charts.HistogramChart | Provides tools to create and manage histograms |
| Cumontreal.ssj.charts.ScatterChart | Provides tools to create and manage scatter plots |
| Cumontreal.ssj.charts.XYLineChart | Provides tools to create and manage curve plots |
| Cumontreal.ssj.charts.PPPlot | Provides PP-plot (probability-probability plot) objects that compare two probability distributions |
| Cumontreal.ssj.charts.QQPlot | This class implements QQ-plot (or quantile-quantile plot) objects that compare two probability distributions |
| Cumontreal.ssj.charts.YListChart | Extends XYLineChart; each YListChart object is associated with a YListSeriesCollection data set |
| Cumontreal.ssj.discrepancy.Discrepancy | This abstract class is the base class of all discrepancy classes |
| Cumontreal.ssj.discrepancy.BigDiscrepancy | This abstract class is the base class of all discrepancy classes programmed with floating-point numbers with multi-precision |
| Cumontreal.ssj.discrepancy.BigDiscShiftBaker1 | This class computes the same discrepancy as in DiscShiftBaker1 [see eq |
| Cumontreal.ssj.discrepancy.BigDiscShiftBaker1Lattice | This class computes the same discrepancy as in DiscShiftBaker1Lattice [see eq |
| Cumontreal.ssj.discrepancy.DiscL2Hickernell | This class computes the Hickernell \(\mathcal{L}_2\)-star discrepancy in [78] (eq |
| Cumontreal.ssj.discrepancy.DiscL2Star | Computes the traditional \(\mathcal{L}_2\)-star discrepancy \(\mathcal{D}_2^*(\mathcal{P})\) for a set of \(n\) points \(\mathcal{P}\) [226], [227], |
| Cumontreal.ssj.discrepancy.DiscL2Symmetric | COMPLÉTER LA DOC ICI |
| Cumontreal.ssj.discrepancy.DiscL2Unanchored | 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 |
| Cumontreal.ssj.discrepancy.DiscShift1 | This class computes the discrepancy for randomly shifted points of a set \(\mathcal{P}\) [81] (eq |
| Cumontreal.ssj.discrepancy.DiscShift1Lattice | This class computes the same discrepancy for randomly shifted points of a set \(\mathcal{L}\) as given in eq |
| Cumontreal.ssj.discrepancy.DiscShift2 | This class computes the discrepancy in [81] (eq |
| Cumontreal.ssj.discrepancy.DiscShift2Lattice | This class computes the same discrepancy for randomly shifted points of a set \(\mathcal{L}\) as given in eq |
| Cumontreal.ssj.discrepancy.DiscShiftBaker1 | This class computes the discrepancy for randomly shifted, then baker folded points of a set \(\mathcal{P}\) |
| Cumontreal.ssj.discrepancy.DiscShiftBaker1Lattice | This class computes the same discrepancy in [81] (eq |
| Cumontreal.ssj.discrepancy.Palpha | Extends the class Discrepancy and implements the methods required to compute the \(P_{\alpha}\) figure of merit for a lattice point set |
| Cumontreal.ssj.discrepancy.DiscrepancyContainer | This class is used to compute, store and display discrepancies |
| Cumontreal.ssj.discrepancy.Searcher | This class implements methods to search for the best lattices of rank 1, defined as follows [212] |
| Cumontreal.ssj.discrepancy.SearcherCBC | 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 |
| Cumontreal.ssj.discrepancy.SearcherKorobov | This class implements searches to find the best Korobov lattices with respect to a given discrepancy |
| Cumontreal.ssj.functionfit.LeastSquares | This class implements different linear regression models, using the least squares method to estimate the regression coefficients |
| Cumontreal.ssj.functions.MathFunction | This interface should be implemented by classes which represent univariate mathematical functions |
| Cumontreal.ssj.functionfit.BSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| Cumontreal.ssj.functionfit.SmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [41], |
| Cumontreal.ssj.functions.AverageMathFunction | Represents a function computing the average of several functions |
| Cumontreal.ssj.functions.IdentityMathFunction | Represents the identity function \(f(x)=x\) |
| Cumontreal.ssj.functions.MathFunctionWithDerivative | Represents a mathematical function whose \(n\)th derivative can be computed using derivative(double,int) |
| Cumontreal.ssj.functionfit.BSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| Cumontreal.ssj.functionfit.SmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [41], |
| Cumontreal.ssj.functions.AverageMathFunction | Represents a function computing the average of several functions |
| Cumontreal.ssj.functions.IdentityMathFunction | Represents the identity function \(f(x)=x\) |
| Cumontreal.ssj.functions.Polynomial | Represents a polynomial of degree \(n\) in power form |
| Cumontreal.ssj.functions.ShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| Cumontreal.ssj.functions.MathFunctionWithFirstDerivative | Represents a mathematical function whose derivative can be computed using derivative(double) |
| Cumontreal.ssj.functionfit.BSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| Cumontreal.ssj.functionfit.SmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [41], |
| Cumontreal.ssj.functions.AverageMathFunction | Represents a function computing the average of several functions |
| Cumontreal.ssj.functions.IdentityMathFunction | Represents the identity function \(f(x)=x\) |
| Cumontreal.ssj.functions.Polynomial | Represents a polynomial of degree \(n\) in power form |
| Cumontreal.ssj.functions.PowerMathFunction | Represents a function computing \((af(x) + b)^p\) for a user-defined function \(f(x)\) and power \(p\) |
| Cumontreal.ssj.functions.ShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| Cumontreal.ssj.functions.SquareMathFunction | Represents a function computing \((af(x) + b)^2\) for a user-defined function \(f(x)\) |
| Cumontreal.ssj.functions.MathFunctionWithIntegral | Represents a mathematical function whose integral can be computed by the integral(double,double) method |
| Cumontreal.ssj.functionfit.BSpline | Represents a B-spline with control points at \((X_i, Y_i)\) |
| Cumontreal.ssj.functionfit.SmoothingCubicSpline | Represents a cubic spline with nodes at \((x_i, y_i)\) computed with the smoothing cubic spline algorithm of Schoenberg [41], |
| Cumontreal.ssj.functions.AverageMathFunction | Represents a function computing the average of several functions |
| Cumontreal.ssj.functions.IdentityMathFunction | Represents the identity function \(f(x)=x\) |
| Cumontreal.ssj.functions.Polynomial | Represents a polynomial of degree \(n\) in power form |
| Cumontreal.ssj.functions.ShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| Cumontreal.ssj.functions.PiecewiseConstantFunction | Represents a piecewise-constant function |
| Cumontreal.ssj.functions.Polynomial | Represents a polynomial of degree \(n\) in power form |
| Cumontreal.ssj.functions.PowerMathFunction | Represents a function computing \((af(x) + b)^p\) for a user-defined function \(f(x)\) and power \(p\) |
| Cumontreal.ssj.functions.ShiftedMathFunction | Represents a function computing \(f(x) - \delta\) for a user-defined function \(f(x)\) and shift \(\delta\) |
| Cumontreal.ssj.functions.SqrtMathFunction | Represents a function computing the square root of another function |
| Cumontreal.ssj.functions.MathFunctionUtil | Provides utility methods for computing derivatives and integrals of functions |
| Cumontreal.ssj.functions.MultiFunction | This interface should be implemented by classes which represent multivariate mathematical functions |
| Cumontreal.ssj.gof.FBar | 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 |
| Cumontreal.ssj.gof.FDist | This class provides methods to compute (or approximate) the distribution functions of special types of goodness-of-fit test statistics |
| Cumontreal.ssj.gof.GofFormat | This class contains methods used to format results of GOF test statistics, or to apply a series of tests simultaneously and format the results |
| Cumontreal.ssj.gof.GofStat | 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 |
| Cumontreal.ssj.gof.GofStat.OutcomeCategoriesChi2 | This class helps managing the partitions of possible outcomes into categories for applying chi-square tests |
| Cumontreal.ssj.gof.KernelDensity | 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 |
| Cumontreal.ssj.hups.F2wStructure | This class implements methods and fields needed by the classes |
| Cumontreal.ssj.hups.PointSet | This abstract class represents a general point set |
| Cumontreal.ssj.hups.CachedPointSet | This container class caches a point set by precomputing and storing all the points locally in an array |
| Cumontreal.ssj.hups.IndependentPointsCached | Similar to IndependentPoints, but the points are all generated and stored (cached) when the point set is randomized |
| Cumontreal.ssj.hups.LatinHypercube | Implements Latin Hypercube Sampling (LHS) with \(n\) points in the |
| Cumontreal.ssj.hups.SortedAndCutPointSet | 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 |
| Cumontreal.ssj.hups.StratifiedUnitCube | This class implements a stratification of the unit cube in rectangular boxes of same size and orientation |
| Cumontreal.ssj.hups.StratifiedUnitCubeAnti | This class implements a stratification of the unit cube in rectangular boxes of same size and orientation, similar to StratifiedUnitCube |
| Cumontreal.ssj.hups.ContainerPointSet | 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 |
| Cumontreal.ssj.hups.AntitheticPointSet | This container class provides antithetic versions of the contained points: |
| Cumontreal.ssj.hups.BakerTransformedPointSet | 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]) |
| Cumontreal.ssj.hups.RandShiftedMod1PointSet | 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 |
| Cumontreal.ssj.hups.CycleBasedPointSet | This abstract class provides the basic structures for storing and manipulating a point set defined by a set of cycles |
| Cumontreal.ssj.hups.CycleBasedPointSetBase2 | Similar to CycleBasedPointSet, except that the successive values in the cycles are stored as integers in the range \(\{0,\dots,2^k-1\}\), where |
| Cumontreal.ssj.hups.CycleBasedLFSR | 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 |
| Cumontreal.ssj.hups.F2wCycleBasedLFSR | This class creates a point set based upon a linear feedback shift register sequence |
| Cumontreal.ssj.hups.F2wCycleBasedPolyLCG | This class creates a point set based upon a linear congruential sequence in the finite field \(\mathbb F_{2^w}[z]/P(z)\) |
| Cumontreal.ssj.hups.LCGPointSet | 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\) |
| Cumontreal.ssj.hups.DigitalNet | This class provides the basic structures for storing and manipulating linear digital nets in base \(b\), for an arbitrary base \(b\ge2\) |
| Cumontreal.ssj.hups.DigitalNetBase2 | A special case of DigitalNet for the base \(b=2\) |
| Cumontreal.ssj.hups.DigitalNetBase2FromFile | 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 |
| Cumontreal.ssj.hups.DigitalSequenceBase2 | This abstract class describes methods specific to digital sequences in base |
| Cumontreal.ssj.hups.NiedSequenceBase2 | This class implements digital sequences constructed from the Niederreiter sequence in base 2 |
| Cumontreal.ssj.hups.NiedXingSequenceBase2 | This class implements digital sequences based on the Niederreiter-Xing sequence in base 2 |
| Cumontreal.ssj.hups.SobolSequence | 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] |
| Cumontreal.ssj.hups.F2wNetLFSR | This class implements a digital net in base 2 starting from a linear feedback shift register generator |
| Cumontreal.ssj.hups.F2wNetPolyLCG | This class implements a digital net in base 2 starting from a polynomial LCG in \(\mathbb F_{2^w}[z]/P(z)\) |
| Cumontreal.ssj.latnetbuilder.DigitalNetSearch.DigitalNetBase2FromLatNetBuilder | Class for the construction of digital nets |
| Cumontreal.ssj.hups.DigitalNetFromFile | 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 |
| Cumontreal.ssj.hups.DigitalSequence | This abstract class describes methods specific to digital sequences |
| Cumontreal.ssj.hups.FaureSequence | This class implements digital nets or digital sequences formed by the first \(n = b^k\) points of the Faure sequence in base \(b\) |
| Cumontreal.ssj.hups.HaltonSequence | 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 |
| Cumontreal.ssj.hups.HammersleyPointSet | This class implements Hammersley point sets, which are defined as follows |
| Cumontreal.ssj.hups.Rank1Lattice | This class implements point sets specified by integration lattices of rank 1 |
| Cumontreal.ssj.hups.KorobovLattice | This class implements a Korobov lattice, which represents the same point set as in class LCGPointSet, but implemented differently |
| Cumontreal.ssj.hups.KorobovLatticeSequence | |
| Cumontreal.ssj.hups.SubsetOfPointSet | This container class permits one to select a subset of a point set |
| Cumontreal.ssj.hups.PointSetRandomization | This interface is for a randomization that can be used to randomize a umontreal.ssj.hups.PointSet |
| Cumontreal.ssj.hups.EmptyRandomization | This class implements an empty |
| Cumontreal.ssj.hups.NestedUniformScrambling | This PointSetRandomization class provides the nested uniform scrambling (NUS) randomization proposed by Owen ([185], [189]) for digital nets |
| Cumontreal.ssj.hups.RandomShift | This class implements a umontreal.ssj.hups.PointSetRandomization |
| Cumontreal.ssj.hups.LMScramble | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a left matrix scrambling |
| Cumontreal.ssj.hups.LMScrambleShift | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a left matrix scrambling and adds a random digital shift |
| Cumontreal.ssj.hups.SMScrambleShift | This class implements a umontreal.ssj.hups.PointSetRandomization that performs a striped matrix scrambling [189] and adds a random digital shift |
| Cumontreal.ssj.hups.RandomStart | This class implements a umontreal.ssj.hups.PointSetRandomization that randomizes a sequence simply by taking a random starting point |
| Cumontreal.ssj.hups.RadicalInverse | This class implements basic methods for working with radical inverses of integers in an arbitrary basis \(b\) |
| Cumontreal.ssj.hups.RQMCPointSet | This class is used for randomized quasi-Monte Carlo (RQMC) simulations |
| Cumontreal.ssj.latnetbuilder.Search | Abstract class for the search of highly uniform point sets with LatNet Builder |
| Cumontreal.ssj.latnetbuilder.DigitalNetSearch | Class for the search of good digital nets using LatNet Builder |
| Cumontreal.ssj.latnetbuilder.PolynomialLatticeSearch | Class for the search of good polynomial lattice rules using LatNet Builder |
| Cumontreal.ssj.latnetbuilder.OrdinaryLatticeSearch | Class for the search of good rank-1 ordinary lattice rules using LatNet Builder |
| Cumontreal.ssj.latnetbuilder.weights.SingletonWeight< T > | Implements a single instance of a weight for search-algorithms for quasi-Monte Carlo point sets as, e.g., those implemented in LatNet Builder |
| Cumontreal.ssj.latnetbuilder.weights.SingletonWeightComparable< T extends Comparable< T > > | Implements single instances of weights |
| Cumontreal.ssj.latnetbuilder.weights.Weights< T > | This abstract class implements generic weights that can be used to search for good quasi-Monte Carlo point sets such as Rank1Lattice, DigitalNet, etc |
| Cumontreal.ssj.latnetbuilder.weights.PODWeights | This class implements so-called product- and order dependent weights (POD weights) |
| Cumontreal.ssj.latnetbuilder.weights.WeightsComparable< T extends Comparable< T > > | Implements comparable Weights |
| Cumontreal.ssj.latnetbuilder.weights.Weights< CoordinateSet > | |
| Cumontreal.ssj.latnetbuilder.weights.ProjectionDependentWeights | Class implementing projection dependent weights |
| Cumontreal.ssj.latnetbuilder.weights.WeightsComparable< Integer > | |
| Cumontreal.ssj.latnetbuilder.weights.OrderDependentWeights | Class implementing order dependent weights |
| Cumontreal.ssj.latnetbuilder.weights.GeometricWeights | 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 |
| Cumontreal.ssj.latnetbuilder.weights.ProductWeights | Class implementing product weights |
| Cumontreal.ssj.markovchainrqmc.ArrayOfComparableChains< T extends MarkovChainComparable > | This class provides tools to simulate an array of |
| Cumontreal.ssj.markovchainrqmc.ArrayOfDoubleChains | Similar to ArrayOfComparableChains, except that instead of working with \(n\) clones of a MarkovChain, we use a single |
| Cumontreal.ssj.mcqmctools.anova.Anova | This class automates the process of replicating estimators of the ANOVA variances |
| Cumontreal.ssj.mcqmctools.anova.AnovaObserver | ANOVA observer |
| Cumontreal.ssj.mcqmctools.anova.CoordinateSet | Represents a set of coordinates |
| Cumontreal.ssj.mcqmctools.anova.CoordinateSetLong | Implementation of CoordinateSet using a long bit-mask internal representation |
| Cumontreal.ssj.mcqmctools.anova.Integrator | |
| Cumontreal.ssj.mcqmctools.anova.RandomIntegrator | |
| Cumontreal.ssj.mcqmctools.anova.MonteCarloIntegrator | |
| Cumontreal.ssj.mcqmctools.anova.Replicator | Replicator class |
| Cumontreal.ssj.mcqmctools.anova.MeanVarExperiment | |
| Cumontreal.ssj.mcqmctools.anova.ObservationCollector< E > | |
| Cumontreal.ssj.mcqmctools.anova.BasicObservationCollector< E > | Does nothing but counting the total number of observations |
| Cumontreal.ssj.mcqmctools.anova.ObservationCollectorList< E > | |
| Cumontreal.ssj.mcqmctools.anova.Report | |
| Cumontreal.ssj.mcqmctools.anova.Sampler | |
| Cumontreal.ssj.mcqmctools.anova.QMCSampler | QMC sampler |
| Cumontreal.ssj.mcqmctools.anova.RandomSampler | |
| Cumontreal.ssj.mcqmctools.anova.MonteCarloSampler | Monte Carlo sampler |
| Cumontreal.ssj.mcqmctools.anova.MonteCarloIntegrator | |
| Cumontreal.ssj.mcqmctools.anova.RQMCSampler | QMC sampler |
| Cumontreal.ssj.mcqmctools.MonteCarloExperiment | Provides generic tools to perform simple Monte Carlo experiments with a simulation model that implements one of the interfaces MonteCarloModelDouble, MonteCarloModelDoubleArray, or MonteCarloModelCV |
| Cumontreal.ssj.mcqmctools.RQMCExperiment | Provides basic generic tools to perform RQMC experiments with a simulation model that implements the MonteCarloModelDouble interface |
| Cumontreal.ssj.mcqmctools.MonteCarloModel< E > | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| Cumontreal.ssj.mcqmctools.anova.AnovaVarianceEstimator | ANOVA variance estimator |
| Cumontreal.ssj.mcqmctools.anova.MonteCarloModelRQMC< E > | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| Cumontreal.ssj.mcqmctools.anova.PartialVarianceEstimator | Partial variance estimator |
| Cumontreal.ssj.mcqmctools.MonteCarloModelDouble | An interface for a very simple simulation model for which Monte Carlo (MC) and RQMC experiments are to be performed |
| Ctutorial.AsianGBM2 | |
| Ctutorial.AsianGBMRQMC2 | |
| Ctutorial.San13Dist | 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" |
| Ctutorial.TestAsianRQMCSeries | |
| Cumontreal.ssj.mcqmctools.MonteCarloModelCV | An extension of MonteCarloModelDouble that also implements a vector of control variates |
| Cumontreal.ssj.mcqmctools.MonteCarloModelDensityKnown | An interface for a simulation model for which Monte Carlo (MC) and RQMC experiments are to be performed |
| Cumontreal.ssj.mcqmctools.anova.MonteCarloModelDoubleRQMC | An interface for a simple simulation model for which Monte Carlo (MC) or RQMC experiments are to be performed |
| Cumontreal.ssj.mcqmctools.MonteCarloModelDoubleArray | Similar to MonteCarloModelDouble except that the returned performance is an array of real numbers |
| Cumontreal.ssj.mcqmctools.RQMCExperimentSeries | 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\) |
| Cumontreal.ssj.probdist.Distribution | This interface should be implemented by all classes supporting discrete and continuous distributions |
| Cumontreal.ssj.probdist.ContinuousDistribution | Classes implementing continuous distributions should inherit from this base class |
| Cumontreal.ssj.probdist.AndersonDarlingDist | Extends the class ContinuousDistribution for the Anderson–Darling distribution (see [6], [161], [169], |
| Cumontreal.ssj.probdist.AndersonDarlingDistQuick | Extends the class AndersonDarlingDist for the Anderson–Darling distribution (see [6], [161], [216] ) |
| Cumontreal.ssj.probdist.BetaDist | Extends the class ContinuousDistribution for the beta distribution |
| Cumontreal.ssj.probdist.BetaSymmetricalDist | Specializes the class BetaDist to the case of a symmetrical beta distribution over the interval \([0,1]\), with shape parameters |
| Cumontreal.ssj.probdist.CauchyDist | Extends the class ContinuousDistribution for the Cauchy distribution [95] (page 299) with location parameter |
| Cumontreal.ssj.probdist.ChiDist | Extends the class ContinuousDistribution for the chi distribution |
| Cumontreal.ssj.probdist.ChiSquareDist | Extends the class ContinuousDistribution for the chi-square distribution with \(n\) degrees of freedom, where \(n\) is a positive integer [95] (page 416) |
| Cumontreal.ssj.probdist.ChiSquareDistQuick | Provides a variant of ChiSquareDist with faster but less accurate methods |
| Cumontreal.ssj.probdist.ChiSquareNoncentralDist | Extends the class ContinuousDistribution for the noncentral chi-square distribution with \(\nu\) degrees of freedom and noncentrality parameter \(\lambda\), where \(\nu> 0\) and |
| Cumontreal.ssj.probdist.CramerVonMisesDist | Extends the class ContinuousDistribution for the Cramér-von Mises distribution (see [54], [215], [216] ) |
| Cumontreal.ssj.probdist.ExponentialDist | Extends the class ContinuousDistribution for the exponential distribution [95] (page 494) with mean \(1/\lambda\) where \(\lambda> 0\) is the rate parameter |
| Cumontreal.ssj.probdist.ExponentialDistFromMean | Extends the ExponentialDist class with a constructor accepting as argument the mean \(1/\lambda\) instead of the rate \(\lambda\) |
| Cumontreal.ssj.probdist.ExtremeValueDist | This class has been replaced by GumbelDist |
| Cumontreal.ssj.probdist.FatigueLifeDist | Extends the class ContinuousDistribution for the fatigue life distribution [19] with location parameter \(\mu\), scale parameter \(\beta\) and shape parameter \(\gamma\) |
| Cumontreal.ssj.probdist.FisherFDist | Extends the class ContinuousDistribution for the Fisher F distribution with \(n_1\) and \(n_2\) degrees of freedom, where |
| Cumontreal.ssj.probdist.FoldedNormalDist | Extends the class ContinuousDistribution for the folded normal distribution with parameters \(\mu\ge0\) and \(\sigma> 0\) |
| Cumontreal.ssj.probdist.FrechetDist | Extends the class ContinuousDistribution for the Fréchet distribution [96] (page 3), with location parameter |
| Cumontreal.ssj.probdist.GammaDist | Extends the class ContinuousDistribution for the gamma distribution [95] (page 337) with shape parameter |
| Cumontreal.ssj.probdist.ErlangDist | Extends the class GammaDist for the special case of the Erlang distribution with shape parameter \(k > 0\) and scale parameter |
| Cumontreal.ssj.probdist.GammaDistFromMoments | 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\) |
| Cumontreal.ssj.probdist.GumbelDist | Extends the class ContinuousDistribution for the Gumbel distribution [96] (page 2), with location parameter |
| Cumontreal.ssj.probdist.HalfNormalDist | Extends the class ContinuousDistribution for the half-normal distribution with parameters \(\mu\) and \(\sigma> 0\) |
| Cumontreal.ssj.probdist.HyperbolicSecantDist | Extends the class ContinuousDistribution for the hyperbolic secant distribution with location parameter \(\mu\) and scale parameter |
| Cumontreal.ssj.probdist.HypoExponentialDist | This class implements the hypoexponential distribution, also called the generalized Erlang distribution |
| Cumontreal.ssj.probdist.HypoExponentialDistEqual | This class implements the hypoexponential distribution for the case of equidistant \(\lambda_i = (n+1-i)h\) |
| Cumontreal.ssj.probdist.HypoExponentialDistQuick | This class is a subclass of HypoExponentialDist and also implements the hypoexponential distribution |
| Cumontreal.ssj.probdist.InverseDistFromDensity | Implements a method for computing the inverse of an arbitrary continuous distribution function when only the probability density is known |
| Cumontreal.ssj.probdist.InverseGammaDist | Extends the class ContinuousDistribution for the inverse gamma distribution with shape parameter \(\alpha> 0\) and scale parameter |
| Cumontreal.ssj.probdist.InverseGaussianDist | Extends the class ContinuousDistribution for the inverse Gaussian distribution with location parameter \(\mu> 0\) and scale parameter |
| Cumontreal.ssj.probdist.JohnsonSystem | This class contains common parameters and methods for the Johnson system of distributions [97], [95] with shape parameters \(\gamma\) and \(\delta> 0\), location parameter |
| Cumontreal.ssj.probdist.JohnsonSBDist | Extends the class ContinuousDistribution for the Johnson |
| Cumontreal.ssj.probdist.JohnsonSLDist | Extends the class ContinuousDistribution for the Johnson |
| Cumontreal.ssj.probdist.JohnsonSUDist | Extends the class ContinuousDistribution for the Johnson |
| Cumontreal.ssj.probdist.KolmogorovSmirnovDist | Extends the class ContinuousDistribution for the Kolmogorov-Smirnov distribution with parameter \(n\) |
| Cumontreal.ssj.probdist.KolmogorovSmirnovDistQuick | Extends the class KolmogorovSmirnovDist for the Kolmogorov–Smirnov distribution |
| Cumontreal.ssj.probdist.KolmogorovSmirnovPlusDist | Extends the class ContinuousDistribution for the Kolmogorov–Smirnov+ distribution (see [39], [54], |
| Cumontreal.ssj.probdist.LaplaceDist | Extends the class ContinuousDistribution for the Laplace distribution (see, e.g., [96] (page 165)) |
| Cumontreal.ssj.probdist.LogisticDist | Extends the class ContinuousDistribution for the logistic distribution (e.g., [96] (page 115)) |
| Cumontreal.ssj.probdist.LoglogisticDist | Extends the class ContinuousDistribution for the Log-Logistic distribution with shape parameter \(\alpha> 0\) and scale parameter |
| Cumontreal.ssj.probdist.LognormalDist | Extends the class ContinuousDistribution for the lognormal distribution [95] |
| Cumontreal.ssj.probdist.LognormalDistFromMoments | Extends the LognormalDist class with a constructor accepting the mean \(m\) and the variance \(v\) of the distribution as arguments |
| Cumontreal.ssj.probdist.NakagamiDist | Extends the class ContinuousDistribution for the Nakagami distribution with location parameter \(a\), scale parameter \(\lambda> 0\) and shape parameter \(c > 0\) |
| Cumontreal.ssj.probdist.NormalDist | Extends the class ContinuousDistribution for the normal distribution (e.g., [95] (page 80)) |
| Cumontreal.ssj.probdist.NormalDistQuick | A variant of the class NormalDist (for the normal distribution with mean \(\mu\) and variance \(\sigma^2\)) |
| Cumontreal.ssj.probdist.NormalInverseGaussianDist | Extends the class ContinuousDistribution for the normal inverse gaussian distribution with location parameter \(\mu\), scale parameter |
| Cumontreal.ssj.probdist.ParetoDist | Extends the class ContinuousDistribution for a distribution from the Pareto family, with shape parameter \(\alpha> 0\) and location parameter \(\beta> 0\) [95] (page 574) |
| Cumontreal.ssj.probdist.Pearson5Dist | THIS CLASS HAS BEEN RENAMED InverseGammaDist |
| Cumontreal.ssj.probdist.Pearson6Dist | 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\) |
| Cumontreal.ssj.probdist.PiecewiseLinearEmpiricalDist | 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)) |
| Cumontreal.ssj.probdist.PowerDist | Extends the class ContinuousDistribution for the power distribution [56] (page 161) with shape parameter \(c >
0\), over the interval \([a,b]\), where \(a < b\) |
| Cumontreal.ssj.probdist.RayleighDist | This class extends the class ContinuousDistribution for the Rayleigh distribution [56] with location parameter |
| Cumontreal.ssj.probdist.StudentDist | Extends the class ContinuousDistribution for the Student |
| Cumontreal.ssj.probdist.StudentDistQuick | Extends the class StudentDist for the Student |
| Cumontreal.ssj.probdist.TriangularDist | Extends the class ContinuousDistribution for the triangular distribution (see [96] (page 297) and |
| Cumontreal.ssj.probdist.TruncatedDist | 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 |
| Cumontreal.ssj.probdist.UniformDist | Extends the class ContinuousDistribution for the uniform distribution [96] (page 276) over the interval |
| Cumontreal.ssj.probdist.WatsonGDist | Extends the class ContinuousDistribution for the Watson \(G\) distribution (see [40], [228] ) |
| Cumontreal.ssj.probdist.WatsonUDist | Extends the class ContinuousDistribution for the Watson U distribution (see [54], [215], [216] ) |
| Cumontreal.ssj.probdist.WeibullDist | 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\) |
| Cumontreal.ssj.probdist.DiscreteDistribution | This class implements discrete distributions over a finite set of real numbers (also over integers as a particular case) |
| Cumontreal.ssj.probdist.ConstantDist | Represents a constant discrete distribution taking a single real value with probability 1 |
| Cumontreal.ssj.probdist.EmpiricalDist | Extends DiscreteDistribution to an empirical distribution function, based on the observations \(X_{(1)},…,X_{(n)}\) (sorted by increasing order) |
| Cumontreal.ssj.probdist.DiscreteDistributionInt | Classes implementing discrete distributions over the integers should inherit from this class |
| Cumontreal.ssj.probdist.BernoulliDist | Extends the class DiscreteDistributionInt for the Bernoulli distribution [114] with parameter \(p\), where |
| Cumontreal.ssj.probdist.BinomialDist | Extends the class DiscreteDistributionInt for the binomial distribution [114] (page 321) with parameters \(n\) and |
| Cumontreal.ssj.probdist.GeometricDist | Extends the class DiscreteDistributionInt for the geometric distribution [114] (page 322) with parameter \(p\), where \(0 < p < 1\) |
| Cumontreal.ssj.probdist.HypergeometricDist | 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 |
| Cumontreal.ssj.probdist.LogarithmicDist | Extends the class DiscreteDistributionInt for the logarithmic distribution |
| Cumontreal.ssj.probdist.NegativeBinomialDist | 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\) |
| Cumontreal.ssj.probdist.PascalDist | The Pascal distribution is a special case of the negative binomial distribution [114] (page 324) with parameters \(n\) and |
| Cumontreal.ssj.probdist.PoissonDist | Extends the class DiscreteDistributionInt for the Poisson distribution [114] (page 325) with mean |
| Cumontreal.ssj.probdist.UniformIntDist | Extends the class DiscreteDistributionInt for the discrete uniform distribution over the range \([i,j]\) |
| Cumontreal.ssj.probdist.ConstantIntDist | Represents a constant discrete distribution taking a single integer value with probability 1 |
| Cumontreal.ssj.probdist.DistributionFactory | This class implements a string API for the package probdist |
| Cumontreal.ssj.probdistmulti.ContinuousDistributionMulti | Classes implementing continuous multi-dimensional distributions should inherit from this class |
| Cumontreal.ssj.probdistmulti.ContinuousDistribution2Dim | Classes implementing 2-dimensional continuous distributions should inherit from this class |
| Cumontreal.ssj.probdistmulti.BiNormalDist | Extends the class ContinuousDistribution2Dim for the bivariate normal distribution [94] (page 84) |
| Cumontreal.ssj.probdistmulti.BiNormalDonnellyDist | Extends the class BiNormalDist for the bivariate normal distribution [94] (page 84) using a translation of Donnelly’s Fortran code in [52] |
| Cumontreal.ssj.probdistmulti.BiNormalGenzDist | Extends the class BiNormalDist for the bivariate normal distribution [94] (page 84) using Genz’s algorithm as described in [65] |
| Cumontreal.ssj.probdistmulti.BiStudentDist | Extends the class ContinuousDistribution2Dim for the standard bivariate Student’s \(t\) distribution [94] (page 132) |
| Cumontreal.ssj.probdistmulti.DirichletDist | Implements the abstract class ContinuousDistributionMulti for the Dirichlet distribution with parameters ( \(\alpha_1\),…, \(\alpha_d\)), \(\alpha_i > 0\) |
| Cumontreal.ssj.probdistmulti.MultiNormalDist | Implements the abstract class ContinuousDistributionMulti for the multinormal distribution with mean vector \(\boldsymbol{\mu}\) and covariance matrix \(\boldsymbol{\Sigma}\) |
| Cumontreal.ssj.probdistmulti.DiscreteDistributionIntMulti | Classes implementing multi-dimensional discrete distributions over the integers should inherit from this class |
| Cumontreal.ssj.probdistmulti.MultinomialDist | Implements the abstract class DiscreteDistributionIntMulti for the multinomial distribution with parameters \(n\) and ( \(p_1\), …, \(p_d\)) |
| Cumontreal.ssj.probdistmulti.NegativeMultinomialDist | 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\) |
| Cumontreal.ssj.probdistmulti.norta.NortaInitDisc | This abstract class defines the algorithms used for NORTA initialization when the marginal distributions are discrete |
| Cumontreal.ssj.probdistmulti.norta.NI1 | Extends the class NortaInitDisc and implements the algorithm NI1 |
| Cumontreal.ssj.probdistmulti.norta.NI2a | Extends the class NortaInitDisc and implements the algorithm NI2a |
| Cumontreal.ssj.probdistmulti.norta.NI2b | Extends the class NortaInitDisc and implements the algorithm NI2b |
| Cumontreal.ssj.probdistmulti.norta.NI3 | Extends the class NortaInitDisc and implements the algorithm NI3 |
| Cumontreal.ssj.randvar.RandomVariateGen | This is the base class for all random variate generators over the real line |
| Cumontreal.ssj.randvar.BetaGen | 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\) |
| Cumontreal.ssj.randvar.BetaRejectionLoglogisticGen | Implements Beta random variate generators using the rejection method with log-logistic envelopes from [33] |
| Cumontreal.ssj.randvar.BetaStratifiedRejectionGen | This class implements Beta random variate generators using the stratified rejection/patchwork rejection method from [202], |
| Cumontreal.ssj.randvar.BetaSymmetricalGen | This class implements random variate generators with the symmetrical beta distribution with shape parameters \(\alpha= \beta\), over the interval \((0,1)\) |
| Cumontreal.ssj.randvar.BetaSymmetricalBestGen | This class implements symmetrical beta random variate generators using Devroye’s one-liner method |
| Cumontreal.ssj.randvar.BetaSymmetricalPolarGen | This class implements symmetrical beta random variate generators using Ulrich’s polar method [223] |
| Cumontreal.ssj.randvar.CauchyGen | This class implements random variate generators for the Cauchy distribution |
| Cumontreal.ssj.randvar.ChiGen | This class implements random variate generators for the chi distribution |
| Cumontreal.ssj.randvar.ChiRatioOfUniformsGen | This class implements Chi random variate generators using the ratio of uniforms method with shift |
| Cumontreal.ssj.randvar.ChiSquareGen | This class implements random variate generators with the chi square distribution with \(n>0\) degrees of freedom |
| Cumontreal.ssj.randvar.ChiSquareNoncentralGen | This class implements random variate generators for the noncentral chi square distribution with \(\nu> 0\) degrees of freedom and noncentrality parameter \(\lambda> 0\) |
| Cumontreal.ssj.randvar.ChiSquareNoncentralGamGen | This class implements noncentral chi square random variate generators using the additive property of the noncentral chi square distribution |
| Cumontreal.ssj.randvar.ChiSquareNoncentralPoisGen | This class implements noncentral chi square random variate generators using Poisson and central chi square generators |
| Cumontreal.ssj.randvar.ConstantGen | This class implements a random variate generator that returns a constant value |
| Cumontreal.ssj.randvar.ExponentialGen | This class implements random variate generators for the exponential distribution |
| Cumontreal.ssj.randvar.ExponentialInverseFromDensityGen | This class implements exponential random variate generators using numerical inversion of the exponential density as described in |
| Cumontreal.ssj.randvar.ExtremeValueGen | This class has been replaced by GumbelGen |
| Cumontreal.ssj.randvar.FNoncentralGen | This class implements random variate generators for the noncentral F-distribution |
| Cumontreal.ssj.randvar.FatigueLifeGen | This class implements random variate generators for the fatigue life distribution [19] with location parameter \(\mu\), scale parameter \(\beta\) and shape parameter \(\gamma\) |
| Cumontreal.ssj.randvar.FisherFGen | 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 |
| Cumontreal.ssj.randvar.FoldedNormalGen | This class implements methods for generating random variates from the folded normal distribution with parameters \(\mu\ge0\) and |
| Cumontreal.ssj.randvar.FrechetGen | 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\) |
| Cumontreal.ssj.randvar.GammaGen | This class implements random variate generators for the gamma distribution |
| Cumontreal.ssj.randvar.ErlangGen | This class implements random variate generators for the Erlang distribution with parameters \(k > 0\) and \(\lambda> 0\) |
| Cumontreal.ssj.randvar.ErlangConvolutionGen | This class implements Erlang random variate generators using the convolution method |
| Cumontreal.ssj.randvar.GammaAcceptanceRejectionGen | This class implements gamma random variate generators using a method that combines acceptance-rejection with acceptance-complement, and proposed in [2], [4] |
| Cumontreal.ssj.randvar.GammaRejectionLoglogisticGen | This class implements gamma random variate generators using a rejection method with loglogistic envelopes, from [32] |
| Cumontreal.ssj.randvar.GumbelGen | This class implements methods for generating random variates from the Gumbel distribution |
| Cumontreal.ssj.randvar.HalfNormalGen | This class implements methods for generating random variates from the half-normal distribution with parameters \(\mu\) and \(\sigma> 0\) |
| Cumontreal.ssj.randvar.HyperbolicSecantGen | This class implements random variate generators for the hyperbolic secant distribution with location parameter \(\mu\) and scale parameter \(\sigma\) |
| Cumontreal.ssj.randvar.HypoExponentialGen | 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) |
| Cumontreal.ssj.randvar.InverseFromDensityGen | Implements a method for generating random variates by numerical inversion of an arbitrary continuous distribution when only the probability density is known [43] |
| Cumontreal.ssj.randvar.InverseGammaGen | This class implements random variate generators for the inverse gamma distribution with shape parameter \(\alpha> 0\) and scale parameter |
| Cumontreal.ssj.randvar.InverseGaussianGen | This class implements random variate generators for the inverse Gaussian distribution with location parameter \(\mu> 0\) and scale parameter |
| Cumontreal.ssj.randvar.InverseGaussianMSHGen | This class implements inverse gaussian random variate generators using the many-to-one transformation method of Michael, Schucany and Haas (MHS) |
| Cumontreal.ssj.randvar.JohnsonSystemG | This class contains common parameters and methods for the random variate generators associated with the Johnson system of distributions |
| Cumontreal.ssj.randvar.JohnsonSBGen | This class implements random variate generators for the Johnson |
| Cumontreal.ssj.randvar.JohnsonSLGen | This class implements random variate generators for the Johnson |
| Cumontreal.ssj.randvar.JohnsonSUGen | This class implements random variate generators for the Johnson |
| Cumontreal.ssj.randvar.KernelDensityGen | 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], |
| Cumontreal.ssj.randvar.KernelDensityVarCorrectGen | 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] |
| Cumontreal.ssj.randvar.LaplaceGen | This class implements methods for generating random variates from the Laplace distribution |
| Cumontreal.ssj.randvar.LogisticGen | This class implements random variate generators for the logistic distribution |
| Cumontreal.ssj.randvar.LoglogisticGen | This class implements random variate generators for the log-logistic distribution with shape parameter \(\alpha> 0\) and scale parameter |
| Cumontreal.ssj.randvar.LognormalGen | This class implements methods for generating random variates from the lognormal distribution |
| Cumontreal.ssj.randvar.LognormalSpecialGen | Implements methods for generating random variates from the lognormal distribution using an arbitrary normal random variate generator |
| Cumontreal.ssj.randvar.MixtureGen | This class implements random variate generators for a mixture distribution |
| Cumontreal.ssj.randvar.NakagamiGen | This class implements random variate generators for the Nakagami distribution |
| Cumontreal.ssj.randvar.NormalGen | This class implements methods for generating random variates from the normal distribution \(N(\mu, \sigma)\) |
| Cumontreal.ssj.randvar.NormalACRGen | This class implements normal random variate generators using the acceptance-complement ratio method [83] |
| Cumontreal.ssj.randvar.NormalBoxMullerGen | This class implements normal random variate generators using the Box-Muller method from [22] |
| Cumontreal.ssj.randvar.NormalInverseFromDensityGen | This class implements normal random variate generators using numerical inversion of the normal density as described in [43] |
| Cumontreal.ssj.randvar.NormalKindermannRamageGen | This class implements normal random variate generators using the Kindermann-Ramage method [102] |
| Cumontreal.ssj.randvar.NormalPolarGen | This class implements normal random variate generators using the polar method with rejection [172] |
| Cumontreal.ssj.randvar.NormalInverseGaussianGen | This class implements random variate generators for the normal inverse gaussian ( \(\mathcal{NIG}\)) distribution |
| Cumontreal.ssj.randvar.NormalInverseGaussianIGGen | 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 |
| Cumontreal.ssj.randvar.ParetoGen | This class implements random variate generators for one of the Pareto distributions, with parameters \(\alpha>0\) and \(\beta>0\) |
| Cumontreal.ssj.randvar.Pearson5Gen | THIS CLASS HAS BEEN RENAMED InverseGammaGen |
| Cumontreal.ssj.randvar.Pearson6Gen | 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\) |
| Cumontreal.ssj.randvar.PowerGen | This class implements random variate generators for the power distribution with shape parameter \(c > 0\), over the interval |
| Cumontreal.ssj.randvar.RandomVariateGenInt | This is the base class for all generators of discrete random variates over the set of integers |
| Cumontreal.ssj.randvar.BernoulliGen | This class implements random variate generators for the Bernoulli distribution (see class umontreal.ssj.probdist.BernoulliDist ) |
| Cumontreal.ssj.randvar.BinomialGen | This class implements random variate generators for the binomial distribution |
| Cumontreal.ssj.randvar.BinomialConvolutionGen | Implements binomial random variate generators using the convolution method |
| Cumontreal.ssj.randvar.GeometricGen | This class implements a random variate generator for the geometric distribution |
| Cumontreal.ssj.randvar.HypergeometricGen | This class implements random variate generators for the hypergeometric distribution |
| Cumontreal.ssj.randvar.LogarithmicGen | This class implements random variate generators for the (discrete) logarithmic distribution |
| Cumontreal.ssj.randvar.NegativeBinomialGen | This class implements random variate generators having the negative binomial distribution |
| Cumontreal.ssj.randvar.PascalGen | Implements Pascal random variate generators, which is a special case of the negative binomial generator with parameter \(\gamma\) equal to a positive integer |
| Cumontreal.ssj.randvar.PascalConvolutionGen | Implements Pascal random variate generators by the convolution method (see [114] ) |
| Cumontreal.ssj.randvar.PoissonGen | This class implements random variate generators having the Poisson distribution |
| Cumontreal.ssj.randvar.PoissonTIACGen | This class implements random variate generators having the Poisson distribution (see PoissonGen ) |
| Cumontreal.ssj.randvar.UniformIntGen | This class implements a random variate generator for the uniform distribution over integers, over the interval \([i,j]\) |
| Cumontreal.ssj.randvar.RandomVariateGenWithCache | This class represents a random variate generator whose values are cached for more efficiency when using common random numbers |
| Cumontreal.ssj.randvar.RayleighGen | This class implements random variate generators for the Rayleigh distribution |
| Cumontreal.ssj.randvar.StudentGen | This class implements methods for generating random variates from the Student distribution with \(n>0\) degrees of freedom |
| Cumontreal.ssj.randvar.StudentPolarGen | This class implements Student random variate generators using the polar method of [13] |
| Cumontreal.ssj.randvar.StudentNoncentralGen | This class implements random variate generators for the noncentral Student-t distribution with \(n>0\) degrees of freedom and noncentrality parameter \(\delta\) |
| Cumontreal.ssj.randvar.TriangularGen | This class implements random variate generators for the triangular distribution |
| Cumontreal.ssj.randvar.UniformGen | This class implements random variate generators for the (continuous) uniform distribution over the interval \((a,b)\), where \(a\) and |
| Cumontreal.ssj.randvar.WeibullGen | This class implements random variate generators for the Weibull distribution |
| Cumontreal.ssj.randvar.RandUnuran | This internal class provides the access point to the C package UNURAN |
| Cumontreal.ssj.randvarmulti.RandomMultivariateGen | This class is the multivariate counterpart of |
| Cumontreal.ssj.randvarmulti.DirichletGen | Extends RandomMultivariateGen for a Dirichlet |
| Cumontreal.ssj.randvarmulti.IIDMultivariateGen | Extends RandomMultivariateGen for a vector of independent identically distributed (i.i.d.) random variables |
| Cumontreal.ssj.randvarmulti.MultinormalGen | Extends RandomMultivariateGen for a multivariate normal (or multinormal) distribution [94] |
| Cumontreal.ssj.randvarmulti.MultinormalCholeskyGen | Extends MultinormalGen for a multivariate normal distribution |
| Cumontreal.ssj.randvarmulti.MultinormalPCAGen | Extends MultinormalGen for a multivariate normal distribution |
| Cumontreal.ssj.rng.RandomPermutation | Provides methods to randomly shuffle arrays or lists using a random stream |
| Cumontreal.ssj.rng.RandomStream | 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 |
| Cumontreal.ssj.hups.PointSetIterator | This is the interface for iterators that permit one to go through the points of a PointSet and the successive coordinates of these points |
| Cumontreal.ssj.hups.PointSet.DefaultPointSetIterator | This class implements a default point set iterator |
| Cumontreal.ssj.hups.CachedPointSet.CachedPointSetIterator | 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 |
| Cumontreal.ssj.hups.ContainerPointSet.ContainerPointSetIterator | |
| Cumontreal.ssj.hups.AntitheticPointSet.AntitheticPointSetIterator | |
| Cumontreal.ssj.hups.BakerTransformedPointSet.BakerTransformedPointSetIterator | |
| Cumontreal.ssj.hups.CycleBasedPointSet.CycleBasedPointSetIterator | |
| Cumontreal.ssj.hups.CycleBasedPointSetBase2.CycleBasedPointSetBase2Iterator | |
| Cumontreal.ssj.hups.DigitalNet.DigitalNetIterator | |
| Cumontreal.ssj.hups.DigitalNet.DigitalNetIteratorNoGray | |
| Cumontreal.ssj.hups.DigitalNetBase2.DigitalNetBase2Iterator | |
| Cumontreal.ssj.hups.DigitalNetBase2.DigitalNetBase2IteratorNoGray | |
| Cumontreal.ssj.hups.DigitalSequenceBase2.DigitalNetBase2IteratorShiftGenerators | |
| Cumontreal.ssj.hups.DigitalSequenceBase2.DigitalNetBase2IteratorShiftNoGray | |
| Cumontreal.ssj.hups.DigitalSequence.DigitalNetIteratorShiftGenerators | |
| Cumontreal.ssj.hups.DigitalSequence.DigitalNetIteratorShiftNoGray | |
| Cumontreal.ssj.hups.Rank1Lattice.Rank1LatticeIterator | |
| Cumontreal.ssj.hups.SortedAndCutPointSet.SortedAndCutPointSetIterator | |
| Cumontreal.ssj.rng.AntitheticStream | This container class allows the user to force any RandomStream to return antithetic variates |
| Cumontreal.ssj.rng.BakerTransformedStream | This container class permits one to apply the baker’s transformation to the output of any RandomStream |
| Cumontreal.ssj.rng.CloneableRandomStream | CloneableRandomStream extends RandomStream and Cloneable |
| Cumontreal.ssj.rng.RandomStreamWithCache | This class represents a random stream whose uniforms are cached for more efficiency when using common random numbers |
| Cumontreal.ssj.rng.TruncatedRandomStream | Represents a container random stream generating numbers in an interval |
| Cumontreal.ssj.stochprocess.InverseGaussianProcessMSH.NonRandomStream | NonRandomStream: Given a double array, this class will return those values as if it where a random stream |
| Cumontreal.ssj.rng.RandomStreamFactory | 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 |
| Cumontreal.ssj.rng.BasicRandomStreamFactory | Represents a basic random stream factory that can constructs new instances of a given RandomStream implementation via the newInstance method |
| Cumontreal.ssj.rng.RandomStreamManager | Manages a list of random streams for more convenient synchronization |
| Cumontreal.ssj.simevents.Continuous | Represents a variable in a continuous-time simulation |
| Ctutorial.PreyPred.Preds | |
| Ctutorial.PreyPred.Preys | |
| Cumontreal.ssj.simevents.ContinuousState | Represents the portion of the simulator’s state associated with continuous-time simulation |
| Cumontreal.ssj.simevents.ContinuousState.IntegMethod | |
| Cumontreal.ssj.simevents.ListWithStat< E >.Node< E > | Represents a node that can be part of a list with statistical collecting |
| Cumontreal.ssj.simevents.Sim | This static class contains the executive of a discrete-event simulation |
| Cumontreal.ssj.simevents.Simulator | Represents the executive of a discrete-event simulator |
| Cumontreal.ssj.simexp.SimExp | Represents a framework for performing experiments using simulation |
| Cumontreal.ssj.simexp.BatchMeansSim | Performs a simulation experiment on an infinite horizon, for estimating steady-state performance measures, using batch means |
| Cumontreal.ssj.simexp.RepSim | Performs a simulation experiment on a finite horizon, using a certain number of independent runs or replications |
| Cumontreal.ssj.stat.density.DensityEstimator | This abstract class represents a univariate density estimator (DE) |
| Cumontreal.ssj.stat.density.DEHistogram | Histogram density estimator for a univariate density |
| Cumontreal.ssj.stat.density.DEKernelDensity | 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 |
| Cumontreal.ssj.stat.density.DensityDerivativeEstimator | 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 |
| Cumontreal.ssj.stat.density.DEDerivativeGaussian | This class implements a density derivative estimator (DDE) with a Gaussian ( i.e., standard normal) kernel function |
| Cumontreal.ssj.stat.density.DensityEstimatorDoubleArray | Same as DensityEstimator but here the observations of the underlying model are \(t\)-dimensional |
| Cumontreal.ssj.stat.density.ConditionalDensityEstimator | This is an abstract class that implements an DensityEstimatorDoubleArray |
| Cumontreal.ssj.stat.FunctionOfMultipleMeansTally.CIType | |
| Cumontreal.ssj.stat.HistogramChartToLatex | |
| Cumontreal.ssj.stat.list.ArrayOfObservationListener | Represents an object that can listen to observations broadcast by lists of statistical probes |
| Cumontreal.ssj.stat.list.ListOfStatProbes< E > | |
| Cumontreal.ssj.stat.list.ListOfFunctionOfMultipleMeansTallies< E extends FunctionOfMultipleMeansTally > | Represents a list of tally statistical collectors for a vector of functions of multiple means |
| Cumontreal.ssj.stat.list.ListOfTallies< E extends Tally > | Represents a list of tally statistical collectors |
| Cumontreal.ssj.mcqmctools.anova.AnovaVarianceCollector | Extends ListOfTallies to collect ANOVA variances |
| Cumontreal.ssj.stat.list.ListOfTallies< E > | |
| Cumontreal.ssj.stat.list.ListOfTalliesWithCovariance< E extends Tally > | Extends ListOfTallies to add support for the computation of the sample covariance between each pair of elements in a list, without storing all observations |
| Cumontreal.ssj.stat.list.lincv.ListOfTalliesWithCV< E extends Tally > | Represents a list of tallies with control variables that inherits the functionalities of a list of tallies, and accepts vectors of length |
| Cumontreal.ssj.stat.matrix.MatrixOfObservationListener | Represents an object that can listen to observations broadcast by matrices of statistical probes |
| Cumontreal.ssj.stat.matrix.MatrixOfStatProbes< E extends StatProbe >.ListType | |
| Cumontreal.ssj.stat.matrix.MatrixOfStatProbes< E > | |
| Cumontreal.ssj.stat.matrix.MatrixOfFunctionOfMultipleMeansTallies< E extends FunctionOfMultipleMeansTally > | Represents a matrix of statistical collectors for functions of multiple means |
| Cumontreal.ssj.stat.matrix.MatrixOfTallies< E extends Tally > | Represents a matrix of tally statistical collectors |
| Cumontreal.ssj.stat.ObservationListener | Represents an object that can listen to observations broadcast by statistical probes |
| Ctutorial.QueueObs.LargeWaitsCollector | |
| Ctutorial.QueueObs.ObservationTrace | |
| Cumontreal.ssj.stat.PgfDataTable | 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 |
| Cumontreal.ssj.stat.ScaledHistogram | This class provides histograms for which the bin counts (heights of rectangles) are replaced by real-valued frequencies (in double) and can be rescaled |
| Cumontreal.ssj.stat.StatProbe | The objects of this class are statistical probes or collectors, which are elementary devices for collecting statistics |
| Cumontreal.ssj.simevents.Accumulate | A subclass of umontreal.ssj.stat.StatProbe, for collecting statistics on a variable that evolves in simulation time, with a piecewise-constant trajectory |
| Cumontreal.ssj.stat.FunctionOfMultipleMeansTally | Represents a statistical collector for estimating a function of multiple means with a confidence interval based on the delta theorem |
| Cumontreal.ssj.stat.Tally | A subclass of StatProbe |
| Cumontreal.ssj.stat.Tally.CIType | |
| Cumontreal.ssj.stochprocess.StochasticProcess | 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\) |
| Cumontreal.ssj.stochprocess.BrownianMotion | This class represents a Brownian motion process \(\{X(t) : t \geq0 \}\), sampled at times \(0 = t_0 < t_1 < \cdots< t_d\) |
| Cumontreal.ssj.stochprocess.BrownianMotionBridge | Represents a Brownian motion process \(\{X(t) : t \geq0 \}\) sampled using the bridge sampling technique (see for example |
| Cumontreal.ssj.stochprocess.BrownianMotionPCA | A Brownian motion process \(\{X(t) : t \geq0 \}\) sampled using the principal component decomposition (PCA) [67], [91], |
| Cumontreal.ssj.stochprocess.BrownianMotionPCAEqualSteps | Same as BrownianMotionPCA, but uses a trick to speed up the calculation when the time steps are equidistant |
| Cumontreal.ssj.stochprocess.CIRProcess | This class represents a CIR (Cox, Ingersoll, Ross) process |
| Cumontreal.ssj.stochprocess.CIRProcessEuler | This class represents a CIR process as in CIRProcess, but the process is generated using the simple Euler scheme |
| Cumontreal.ssj.stochprocess.GammaProcess | This class represents a gamma process [167] (page 82) \(\{
S(t) = G(t; \mu, \nu) : t \geq0 \}\) with mean parameter |
| Cumontreal.ssj.stochprocess.GammaProcessBridge | This class represents a gamma process \(\{ S(t) = G(t; \mu, \nu) : t \geq0
\}\) with mean parameter \(\mu\) and variance parameter |
| Cumontreal.ssj.stochprocess.GammaProcessSymmetricalBridge | 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 |
| Cumontreal.ssj.stochprocess.GammaProcessPCA | Represents a gamma process sampled using the principal component analysis (PCA) |
| Cumontreal.ssj.stochprocess.GammaProcessPCABridge | Same as GammaProcessPCA, but the generated uniforms correspond to a bridge transformation of the BrownianMotionPCA instead of a sequential transformation |
| Cumontreal.ssj.stochprocess.GammaProcessPCASymmetricalBridge | Same as GammaProcessPCABridge, but uses the fast inversion method for the symmetrical beta distribution, proposed by L’Ecuyer and Simard |
| Cumontreal.ssj.stochprocess.GeometricBrownianMotion | Represents a geometric Brownian motion (GBM) process \(\{S(t), t\ge0\}\), which evolves according to the stochastic differential equation |
| Cumontreal.ssj.stochprocess.GeometricLevyProcess | Abstract class used as a parent class for the exponentiation of a Lévy process \(X(t)\): |
| Cumontreal.ssj.stochprocess.GeometricNormalInverseGaussianProcess | The geometric normal inverse gaussian (GNIG) process is the exponentiation of a NormalInverseGaussianProcess : |
| Cumontreal.ssj.stochprocess.GeometricVarianceGammaProcess | This class represents a geometric variance gamma process \(S(t)\) (see |
| Cumontreal.ssj.stochprocess.InverseGaussianProcess | 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 |
| Cumontreal.ssj.stochprocess.InverseGaussianProcessMSH | Uses a faster generating method (MSH) [175] than the simple inversion of the distribution function used by |
| Cumontreal.ssj.stochprocess.InverseGaussianProcessBridge | Samples the path by bridge sampling: first finding the process value at the final time and then the middle time, etc |
| Cumontreal.ssj.stochprocess.InverseGaussianProcessPCA | Approximates a principal component analysis (PCA) decomposition of the InverseGaussianProcess |
| Cumontreal.ssj.stochprocess.MultivariateStochasticProcess | This class is a multivariate version of StochasticProcess where the process evolves in the \(c\)-dimensional real space |
| Cumontreal.ssj.stochprocess.MultivariateBrownianMotion | This class represents a multivariate Brownian motion process |
| Cumontreal.ssj.stochprocess.MultivariateBrownianMotionBridge | A multivariate Brownian motion process \(\{\mathbf{X}(t) : t \geq0 \}\) sampled via bridge sampling |
| Cumontreal.ssj.stochprocess.MultivariateBrownianMotionPCA | A multivariate Brownian motion process \(\{\mathbf{X}(t) : t \geq0 \}\) sampled entirely using the principal component decomposition (PCA), as explained in [67] , page 92 |
| Cumontreal.ssj.stochprocess.MultivariateBrownianMotionPCABigSigma | A multivariate Brownian motion process \(\{\mathbf{X}(t) : t \geq0 \}\) sampled entirely using the principal component decomposition (PCA) |
| Cumontreal.ssj.stochprocess.MultivariateGeometricBrownianMotion | This class is a multivariate version of GeometricBrownianMotion |
| Cumontreal.ssj.stochprocess.NormalInverseGaussianProcess | This class represents a normal inverse gaussian process (NIG) |
| Cumontreal.ssj.stochprocess.OrnsteinUhlenbeckProcess | This class represents an Ornstein-Uhlenbeck process \(\{X(t) : t \geq0
\}\), sampled at times \(0 = t_0 < t_1 < \cdots< t_d\) |
| Cumontreal.ssj.stochprocess.OrnsteinUhlenbeckProcessEuler | This class represents an Ornstein-Uhlenbeck process as in |
| Cumontreal.ssj.stochprocess.OrnsteinUhlenbeckWithIntegratedProcess | This class is custom-made for the CallableBond example |
| Cumontreal.ssj.stochprocess.VarianceGammaProcess | This class represents a variance gamma (VG) process \(\{S(t) = X(t;
\theta, \sigma, \nu) : t \geq0\}\) |
| Cumontreal.ssj.stochprocess.VarianceGammaProcessAlternate | This is a VarianceGammaProcess for which the successive random numbers are used in a different order to generate the sample path |
| Cumontreal.ssj.stochprocess.VarianceGammaProcessDiff | This class represents a variance gamma (VG) process \(\{S(t) = X(t;
\theta, \sigma, \nu) : t \geq0\}\) |
| Cumontreal.ssj.stochprocess.VarianceGammaProcessDiffPCA | Same as VarianceGammaProcessDiff, but the two inner |
| Cumontreal.ssj.stochprocess.VarianceGammaProcessDiffPCABridge | Same as VarianceGammaProcessDiff, but the two inner |
| Cumontreal.ssj.stochprocess.VarianceGammaProcessDiffPCASymmetricalBridge | Same as VarianceGammaProcessDiff, but the two inner |
| Cumontreal.ssj.util.AbstractChrono | 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 |
| Cumontreal.ssj.util.Chrono | The Chrono class extends the umontreal.ssj.util.AbstractChrono class and computes the CPU time for the current thread only |
| Cumontreal.ssj.util.ChronoSingleThread | Extends the AbstractChrono class to compute the CPU time for a single thread |
| Cumontreal.ssj.util.ChronoWall | Extends the AbstractChrono class to compute the wall-clock time using Java's builtin System.nanoTime |
| Cumontreal.ssj.util.ArithmeticMod | This class provides facilities to compute multiplications of scalars, of vectors and of matrices modulo m |
| Cumontreal.ssj.util.DMatrix | This class implements a few methods for matrix calculations when the matrix entries are in double |
| Cumontreal.ssj.util.Introspection | Provides utility methods for introspection using the Java Reflection API |
| Cumontreal.ssj.util.io.DataField | This class represents a data field from a file read by an instance of a class implementing DataReader |
| Cumontreal.ssj.util.io.DataReader | Data reader interface |
| Cumontreal.ssj.util.io.AbstractDataReader | This abstract class implements shared functionality for data readers |
| Cumontreal.ssj.util.io.BinaryDataReader | Binary data reader |
| Cumontreal.ssj.util.io.DataWriter | Data writer interface |
| Cumontreal.ssj.util.io.AbstractDataWriter | This abstract class implements shared functionality for data writers |
| Cumontreal.ssj.util.io.BinaryDataWriter | Binary data writer |
| Cumontreal.ssj.util.io.CachedDataWriter | 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 |
| Cumontreal.ssj.util.io.TextDataWriter | Text data writer |
| Cumontreal.ssj.util.io.TextDataWriter.Format | Output format: organize fields as columns or as rows |
| Cumontreal.ssj.util.JDBCManager | This class provides some facilities to connect to a SQL database and to retrieve data stored in it |
| Cumontreal.ssj.util.Misc | This class provides miscellaneous functions that are hard to classify |
| Cumontreal.ssj.util.multidimsort.BatchSort< T > | |
| Cumontreal.ssj.util.multidimsort.BatchSortPow2< T extends MultiDimComparable<? super T > > | This is a subclass of BatchSort for which the batch numbers |
| Cumontreal.ssj.util.multidimsort.HilbertCurveMap | This class implements the mapping of a Hilbert curve in the |
| Cumontreal.ssj.util.multidimsort.MultiDim01 | This interface represents a point or array of \(d\) dimensions in a unit hypercube \([0, 1)^d\) |
| Cumontreal.ssj.util.multidimsort.MultiDimComparable< T > | This interface is an extension (or variant) of the Comparable interface in Java |
| Cumontreal.ssj.markovchainrqmc.MarkovChainComparable | A subclass of MarkovChain for which there is a total ordering between the states, induced by the implementation of the |
| Cumontreal.ssj.util.multidimsort.MultiDimSort< T > | This interface is meant to be implemented by certain multivariate sorting algorithms that sort objects based on different fields (or dimensions) |
| Cumontreal.ssj.util.multidimsort.MultiDimSort01< T extends MultiDim01 > | This interface extends MultiDimSort<T> to implement multivariate sorting algorithms that sort points of \(d\) dimensions in the unit hypercube \([0, 1)^d\) |
| Cumontreal.ssj.util.multidimsort.MultiDimSortComparable< T extends MultiDimComparable<? super T > > | This interface extends MultiDimSort<T> to implement multivariate sorting algorithms that sort objects that are pairwise comparable |
| Cumontreal.ssj.util.multidimsort.MultiDimSort01< MultiDim01 > | |
| Cumontreal.ssj.util.multidimsort.HilbertCurveSort | 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 |
| Cumontreal.ssj.util.multidimsort.MultiDimSortComparable< T > | |
| Cumontreal.ssj.util.multidimsort.BatchSort< T extends MultiDimComparable<? super T > > | This class implements a MultiDimSortComparable that performs a batch sort on multivariate arrays |
| Cumontreal.ssj.util.multidimsort.HilbertCurveBatchSort< T extends MultiDimComparable<? super T > > | This sort is similar to BatchSortPow2, except that after applying the batch sort, the objects are given labels that map them to the |
| Cumontreal.ssj.util.multidimsort.OneDimSort< T extends MultiDimComparable<? super T > > | This class implements a MultiDimSortComparable that simply sorts the objects according to a given sorting coordinate \(j \ge0\) specified in the constructor |
| Cumontreal.ssj.util.multidimsort.SplitSort< T extends MultiDimComparable<? super T > > | Implements a MultiDimSortComparable that performs a split sort on a MultiDimComparable<T> array based on its first \(d\) dimensions |
| Cumontreal.ssj.util.MultivariateFunction | Represents a function of multiple variables |
| Cumontreal.ssj.util.RatioFunction | Represents a function computing a ratio of two values |
| Cumontreal.ssj.util.NativeUtils | A simple library class which helps with loading dynamic libraries stored in the JAR archive |
| Cumontreal.ssj.util.Num | This class provides various constants and methods to compute numerical quantities such as factorials, combinations, gamma functions, and so on |
| Cumontreal.ssj.util.RootFinder | This class provides numerical methods to solve non-linear equations |
| Cumontreal.ssj.util.Systeme | This class provides a few tools related to the system or the computer |
| Cumontreal.ssj.util.TableFormat | This class provides methods to format arrays and matrices into String s in different styles |
| Cumontreal.ssj.util.TextDataReader | Provides static methods to read data from text files |
| Cumontreal.ssj.util.TimeUnit | Represents a time unit for conversion of time durations |
| CXYItemRenderer | |
| Cumontreal.ssj.charts.EmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| CXYLineAndShapeRenderer | |
| Cumontreal.ssj.charts.EmpiricalRenderer | A renderer that draws horizontal lines between points and/or draws shapes at each data point to provide an empirical style chart |
| CXYListSeriesCollection | |
| Cumontreal.ssj.charts.YListSeriesCollection | This class extends umontreal.ssj.charts.XYListSeriesCollection |
1.16.1