Class List

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

[detail level 12]

BetaFunctions	Efficient implementation of the computation of the incomplete regularized beta function and related functions
ExponentialIntegralFunctions	Efficient implementation of the exponential integral function for complex arguments
exprtk	A math expression parser
GammaFunctions	Efficient implementation of the computation of the incomplete regularized gamma function and related functions
KFactorFunctions	Efficient implementation of the computation of the k factor
OpenTURNS	The header file that declares all general types
OT	GeometricProfile
GeometricProfile
LHSResult
LinearProfile
MonteCarloLHS
OptimalLHSExperiment
SimulatedAnnealingLHS
SpaceFilling
SpaceFillingC2
SpaceFillingImplementation
SpaceFillingMinDist
SpaceFillingPhiP
TemperatureProfile
TemperatureProfileImplementation
StudentFunctions	Efficient implementation of the computation of the Student T CDF and quantile
tbb	This file supplies support for multithreading
Test	The namespace for test specific definitions
ExitCode
TestFailed
AbdoRackwitz	AbdoRackwitz is an actual implementation for OptimizationAlgorithm using the AbdoRackwitz algorithm
AbsoluteExponential
AdaptiveDirectionalSampling	ADS simulation algorithm
AdaptiveStieltjesAlgorithm	Implement the modified adaptive Stieltjes algorithm to compute the coefficients of the 3 terms recurrence relation of an orthonormal polynomial family
AdaptiveStrategy	This is the interface class for adaptive strategies
AdaptiveStrategyImplementation	This is a abstract class for adaptive strategy implementations
AggregatedEvaluation	The evaluation part of an aggregation of functions from R^n to R^p_1,...,R^n to R^p_k
AggregatedFunction	The class that implements aggregated functions
AggregatedGradient	The gradient part of linear combination of polynomials
AggregatedHessian	The hessian part of linear combination of polynomials
AggregatedProcess	A class which implements the AggregatedProcess process
AliMikhailHaqCopula	The AliMikhailHaqCopula distribution
AliMikhailHaqCopulaFactory	Factory for AliMikhailHaqCopula distribution
Analytical	Analytical implements an algorithm to find the design point
AnalyticalResult	AnalyticalResult implements an algorithm to find the design point
ANCOVA	ANCOVA implements the sensivity analysis method for correlated data
ApproximationAlgorithm	Regression from a data sample upon a particular basis
ApproximationAlgorithmImplementation	Regression from a data sample upon a particular basis
ApproximationAlgorithmImplementationFactory	A factory for building ApproximationAlgorithmImplementation objects
ArchimedeanCopula	Abstract top-level class for non elliptical distributions
Arcsine	The Arcsine distribution
ArcsineFactory	Factory for DerivativeArcsine distribution
ArcsineMuSigma	Arcsine distribution with mu and sigma as parameters
ARMA	A class which implements the ARMA process
ARMACoefficients	ARMACoefficients class enables to stock coefficients of an ARMA process Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
ARMAFactory	The interface class that implements all process
ARMAFactoryImplementation	An interface for all implementation class of process
ARMALikelihoodFactory	The class enables to get the coefficients of an ARMA process using the likelihood function
ARMAState	ARMAState class enables to set a State before a simulation of an ARMA process and / or t get the State Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
Atomic	This file supplies some atomic functions to support multithreading
Axial	Axial experiment plane
BarPlot	BarPlot class for barplots
Basis	A collection of numerical math function
BasisFactory	Abstract top-level class for all BasisFactory
BasisImplementation	This is an abstract class for basis
BasisSequence	A sequence of numerical math function collection
BasisSequenceFactory	A factory for building BasisSequence objects
BasisSequenceFactoryImplementation	A factory for building BasisSequence objects
BasisSequenceImplementation	A sequence of numerical math function collection
BayesDistribution	The BayesDistribution distribution
Bernoulli	The Bernoulli distribution
BernoulliFactory	Factory for Bernoulli distribution
BernsteinCopulaFactory	This class implements a non parametric density estimator for copulas based on the Bernstein copula approximation of the empirical copula
Beta	The Beta distribution
BetaFactory	Factory for Beta distribution
BetaMuSigma	Beta distribution with mu and sigma as parameters
BinaryStorageManager	Implements a storage manager that drives a XML file
Binomial	The Binomial distribution
BinomialFactory	Factory for Binomial distribution
BipartiteGraph	BipartiteGraph defines a graph with two sets of nodes (red and black) and links from one set to the other only
Bisection	Implementation class of the scalar nonlinear solver based on
BlendedStep	Implementation of BlendedStep
BootstrapExperiment	Abstract top-level view of an bootstrapExperiment plane
BoundingVolumeHierarchy	This class implements Bounding Volume Hierarchy (BVH) to speed-up point location
Box	Box experiment plane
BoxCoxEvaluation	Class for Box Cox function implementation
BoxCoxFactory	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
BoxCoxGradient	Class for Box Cox function implementation
BoxCoxHessian	Class for Box Cox function implementation
BoxCoxTransform	Abstract top-level class for all numerical math function implementations
Brent	Implementation class of the scalar nonlinear solver based on
Bulk
Burr	The Burr distribution
BurrFactory	Factory for Burr distribution
Cache	Cache holds the already computed points to speed up calculations
CalibrationAlgorithm	Abstract top-level class for all CalibrationAlgorithm
CalibrationAlgorithmImplementation	Default CalibrationAlgorithmImplementation
CalibrationResult	CalibrationResult implements the result of an algorithm for solving a calibration problem
CalibrationStrategy	Abstract top-level class for all CalibrationStrategy
CalibrationStrategyImplementation	Default CalibrationStrategyImplementation
CanonicalTensorEvaluation	Canonical tensor representation and evaluation
CanonicalTensorGradient	Canonical tensor gradient
Catalog	Catalog records all the object's factories into a dictionnary
Catalog_init
CauchyModel	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
CenteredFiniteDifferenceGradient	Class for the creation of a numerical math gradient implementation form a numerical math evaluation implementation by using centered finite difference formula
CenteredFiniteDifferenceHessian	Class for the creation of a numerical math hessian implementation form a numerical math evaluation implementation by using centered finite difference formula
Ceres	Ceres solver
CharlierFactory	Charlier polynomial factory
ChebychevFactory	Chebychev polynomial factory
Chi	The Chi distribution
ChiFactory	Factory for Chi distribution
ChiSquare	The ChiSquare distribution
ChiSquareFactory	Factory for ChiSquare distribution
CholeskyMethod	Cholesky decomposition based LS solver
Classifier	Classification algorithm interface
ClassifierImplementation	Classification algorithm base type
ClaytonCopula	The ClaytonCopula distribution
ClaytonCopulaFactory	Factory for ClaytonCopula distribution
CleaningStrategy	An implementation returning the set of polynomials in sequence
Cloud	Cloud class for cloud plots
CMinpack	CMinpack solver
cobyla	Cobyla is an actual implementation for OptimizationAlgorithmImplementation using the cobyla library
Collection	Collection defines top-most collection strategies
Combinations	Combinations experiment plane
CombinatorialGenerator	Abstract top-level view of an combinatorialGenerator plane
CombinatorialGeneratorImplementation	Abstract top-level view of an combinatorialGenerator plane
Compact	Compact history storage
ComparisonOperator	Abstract top-level class for all ComparisonOperator
ComparisonOperatorImplementation	Abstract top-level class for all ComparisonOperatorImplementation
ComplexMatrix
ComplexMatrixImplementation	ComplexMatrixImplementation implements the Matrix class with complex values
ComplexTensor
ComplexTensorImplementation	ComplexTensorImplementation implements the Tensor classes
ComposedCopula	The class that implements assembly distributions
ComposedDistribution	The class that implements assembly distributions
ComposedEvaluation	The class that implements the composition between numerical math functions implementations
ComposedFunction	The class that implements composed numerical math functions
ComposedGradient	The class that implements the composition between numerical math functions
ComposedHessian	The class that implements the composition between numerical math hessians
Composite	Composite experiment plane
CompositeDistribution	The CompositeDistribution distribution
CompositeProcess	A class which implements the CompositeProcess process
CompositeRandomVector	An implementation class for composite random vectors
ConditionalDistribution	The ConditionalDistribution distribution
ConditionalRandomVector	An implementation class for distribution-based random vectors
ConditionedGaussianProcess	A class which implements the ConditionedGaussianProcess
ConfigurationFileParsingException	Raised when the configuration file can not be read
ConstantBasisFactory	Constant basis factory
ConstantGradient	Class for a linear numerical math gradient impelmentation
ConstantHessian	Class for a constant numerical math hessian implementation
ConstantRandomVector	An implementation class for constant random vectors
ConstantStep	Implementation of ConstantStep
ContinuousDistribution	Abstract top-level class for Continuous distributions
Contour	Contour class for piechart plots
Copula	Abstract top-level class for all copula
CopulaImplementation	Abstract top-level class for all copula
CorrectedLeaveOneOut	Corrected implicit leave-one-out cross validation
CorrelationAnalysis	CorrelationAnalysis implements computation of correlation coefficients
CorrelationMatrix	The class CorrelationMatrix implements correlation matrices
CovarianceMatrix	The class CovarianceMatrix implements covariance matrices
CovarianceModel	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
CovarianceModelFactory	Top-level class for all spectral model factories
CovarianceModelFactoryImplementation	Top-level class for all spectral model factories
CovarianceModelImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
CSVParserState	The definition of the internal state of the CSV parser
CumulativeDistributionNetwork	This class implements the multivariate distribution based on a bipartite graph and a collection of distributions
Curve	Curve class for curve plots
DatabaseEvaluation	An implementation from samples
DatabaseFunction	The class that implements a pre-computed function
DesignProxy	Design matrix cached evaluation
DickeyFullerTest	StatTest implements statistical tests
Dirac	The Dirac distribution
DiracCovarianceModel
DiracFactory	Factory for Dirac distribution
DirectionalSampling	DirectionalSampling is an implementation of the directional sampling Montex Carlo simulation method
Dirichlet	The Dirichlet distribution
DirichletFactory	Factory for Dirichlet distribution
DiscreteDistribution	Abstract top-level class for Discrete distributions
DiscreteMarkovChain	A class which implements a discrete Markov chain process
DistFunc	OpenTURNS wrapper to a library of special functions
Distribution	Abstract top-level class for all distributions
DistributionFactory	Top-level class for all distribution factories
DistributionFactoryImplementation	Top-level class for all distribution factories
DistributionFactoryResult	Results of distribution estimation
DistributionImplementation
DistributionParameters	Abstract top-level class for all distributions parameters
DistributionParametersImplementation	Abstract top-level class for all distribution parameters
DistributionTransformation	Isoprobabilistic transformation
Dlib	Dlib solvers
DlibBfgsSearchStrategy	Implementation for conjugate gradient search strategy
DlibConjugateGradientSearchStrategy	Implementation for conjugate gradient search strategy
DlibFunction
DlibGradient
DlibHessian
Domain	Domain is the interface of DomainImplementation
DomainDifference	DomainDifference represents the difference of two Domain
DomainDisjunctiveUnion	DomainDisjunctiveUnion represents the disjunctive union of two Domain
DomainImplementation	DomainImplementation is defined as a domain of {R}^d
DomainIntersection	DomainIntersection represents the intersection of two Domain
DomainUnion	DomainUnion represents the union of two Domain
Drawable	Drawable implements graphic devices for plotting through R
DrawableImplementation	Abstract top-level class for all drawables
DualLinearCombinationEvaluation	The evaluation part of functional linear combination of vectors
DualLinearCombinationFunction	The class that implements linear combination of vectors
DualLinearCombinationGradient	The gradient part of functional linear combination of vectors
DualLinearCombinationHessian	The hessian part of functional linear combination of vectors
DynamicLibraryException	Raised when a dynamic library can not be loaded or when a symbol can not be found in it
EfficientGlobalOptimization	EfficientGlobalOptimization or EGO algorithm
EllipticalDistribution	Abstract top-level class for elliptical distributions
EmpiricalBernsteinCopula	The class that implements the Bernstein approximation of the empirical copula
EnclosingSimplexAlgorithm	This class provides fast point location. This is the interface class
EnclosingSimplexAlgorithmImplementation	This class provides fast point location. This is an abstract class
EnclosingSimplexMonotonic1D	This class provides a point location algorithm on monotonic 1D meshes
EnumerateFunction	The bijective function to select polynomials in the orthogonal basis
EnumerateFunctionImplementation	The bijective function to select polynomials in the orthogonal basis
Epanechnikov	The Epanechnikov distribution
Equal	Implementation of equality comparison
Evaluation	The class that implements numerical math functions
EvaluationImplementation
EvaluationProxy	Proxy class for EvaluationImplementation
Event	This class specializes the concept of RandomVector by constructing a Bernoulli
EventDomain	The class that implements an event domain based on a composite random vector built upon a boolean function which is described by a domain appartenance. The antecedent of the event must be a "classical" composite random vector in the context of OpenTURNS
EventProcess	The class that implements an event based on the evaluation of the domain appartenance of a stochastic process using a boolean function
EventRandomVector	The class that implements an event random vector, i.e. a composite random vector built upon a boolean function which is described by a threshold and a comparison operator. The antecedent of the event must be a "classical" composite random vector in the context of OpenTURNS
EventSimulation	EventSimulation is a generic view of simulation methods for computing probabilities and related quantities by sampling and estimation
Exception	The base class for all OpenTURNS' exceptions
ExpectationSimulationAlgorithm	Simulation algorithm to estimate an expectation
ExpectationSimulationResult	Result of an expectation simulation
Experiment	Abstract top-level view of an experiment plane
ExperimentImplementation	Abstract top-level view of an experiment plane
ExpertMixture	This class implements a meta-model based on mixture of experts
Exponential	The Exponential distribution
ExponentialFactory	Factory for Exponential distribution
ExponentiallyDampedCosineModel	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
ExponentialModel	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
ExtremeValueCopula	The ExtremeValueCopula distribution
Factorial	Factorial experiment plane
Factory	Ease the creation of factories for any PersistentObject based class
FarlieGumbelMorgensternCopula	The FarlieGumbelMorgensternCopula distribution
FarlieGumbelMorgensternCopulaFactory	Factory for FarlieGumbelMorgensternCopula distribution
FAST	FAST implements the sensivity analysis method based on fourier decomposition
FaureSequence	Implementation of the Faure sequence
Fehlberg	This class implements the adaptive Fehlberg method of order p/p+1
FFT	This class is enables to launch an FFT transformation /inverse transformation This is the interface class
FFTImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
Field	The class Field implements samples indexed by time
FieldFunction	The class that implements dynamical functions
FieldFunctionImplementation	Abstract top-level class for all numerical math function implementations
FieldImplementation	The class FieldImplementation implements values indexed by the vertices of a Mesh
FieldToFieldConnection	The class that implements the composition between field functions or point to field and field to point functions
FieldToPointConnection	The class that implements the field to point connection
FieldToPointFunction	The class that implements functions mapping fields into points
FieldToPointFunctionImplementation	Abstract top-level class for field to point function implementations
FileNotFoundException	Raised when a file can not be found on filesystem
FileOpenException	Raised when a file can not be opened
FilonQuadrature	Implement the Filon quadrature for oscilatory integrands
FilteringWindowsImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
FiniteBasis	This is an abstract class for basis
FiniteDifferenceGradient	Class for the creation of a numerical math gradient implementation form a numerical math evaluation implementation by using centered finite difference formula
FiniteDifferenceHessian	Class for the creation of a numerical math gradient implementation form a numerical math evaluation implementation by using centered finite difference formula
FiniteDifferenceStep	Interface for finite difference steps
FiniteDifferenceStepImplementation	Implementation of finite difference step
FisherSnedecor	The Fisher-Snedecor distribution
FisherSnedecorFactory	Factory for FisherSnedecor distribution
FittingAlgorithm	Cross-validation algorithm interface
FittingAlgorithmImplementation	Cross-validation algorithm implementation
FittingTest	StatTest implements statistical tests
FixedExperiment	Abstract top-level view of an fixedExperiment plane
FixedStrategy	An implementation directly returning the full set of polynomials
FORM	FORM implements the First Order Reliability Method
FORMResult	FORMResult implements the First Order Reliability Method
FourierSeries	Fourier series function implementation
FourierSeriesFactory	Fourier function factory
FractionalBrownianMotionModel
FrankCopula	The FrankCopula distribution
FrankCopulaFactory	Factory for FrankCopula distribution
Frechet	The Frechet distribution
FrechetFactory	Factory for Frechet distribution
Full	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
Function	The class that implements numerical math functions
FunctionalBasisProcess	A class which implements the FunctionalBasisProcess process
FunctionalChaosAlgorithm	The class building chaos expansions
FunctionalChaosRandomVector	An implementation class for functionalChaos random vectors
FunctionalChaosResult	The result of a chaos expansion
FunctionalChaosSobolIndices	Sensitivity analysis based on functional chaos expansion
FunctionImplementation
Gamma	The Gamma distribution
GammaFactory	Factory for Gamma distribution
GammaMuSigma	Gamma distribution with mu and sigma as parameters
GaussianLinearCalibration	GaussianLinearCalibration algorithm
GaussianProcess	A class which implements the Gaussian process
GaussKronrod	Implement the Gauss-Kronrod adaptive integration method for functions with 1D argument
GaussKronrodRule	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
GaussLegendre	Implement a tensorized Gauss-Legendre quadrature
GaussProductExperiment	Abstract top-level view of an monteCarloExperiment plane
GeneralizedExponential
GeneralizedExtremeValue	The GeneralizedExtremeValue distribution
GeneralizedPareto	The GeneralizedPareto distribution
GeneralizedParetoFactory	Factory for GeneralizedPareto distribution
GeneralLinearModelAlgorithm	The class builds generalized linear models
GeneralLinearModelResult	The result of a linear model estimation
GenericCounterImplementation	The class SharedPointer implements a shared pointer
Geometric	The Geometric distribution
GeometricFactory	Factory for Geometric distribution
Gradient	The interface class that implements numerical math functions
GradientImplementation
Graph	Graph implements graphic devices for plotting through R
GraphImplementation	GraphImplementation implements graphic devices for plotting through R
Greater	Implementation of strict greater comparison
GreaterOrEqual	Implementation of greater or equal comparison
Gumbel	The Gumbel distribution
GumbelAB	Gumbel distribution with a and b as parameters
GumbelCopula	The GumbelCopula distribution
GumbelCopulaFactory	Factory for GumbelCopula distribution
GumbelFactory	Factory for Gumbel distribution
GumbelMuSigma	Gumbel distribution with mu and sigma as parameters
HaarWavelet	Haar wavelet function implementation
HaarWaveletFactory	Haar wavelet function factory
HaltonSequence	Implementation of the Halton sequence
Hamming	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
Hanning	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
HaselgroveSequence	Implementation of the Haselgrove sequence
HermiteFactory	Hermite polynomial factory
HermitianMatrix
Hessian	The interface class that implements numerical math functions
HessianImplementation
Histogram	The Histogram distribution
HistogramFactory	Factory for Histogram distribution
HistogramPolynomialFactory	HistogramPolynomial polynomial factory
HistoryStrategy	This class is a top-level class for the history mechanism
HistoryStrategyImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
HMatrix	This file supplies support for HMat
HyperbolicAnisotropicEnumerateFunction	The bijective function to select polynomials in the orthogonal basis
Hypergeometric	The Hypergeometric distribution
HypothesisTest	StatTest implements statistical tests
IdentityEvaluation	Class for identity evaluation
IdentityFunction	The class that implements identity functions
IdentityMatrix	The class IdentityMatrix implements identity matrices
IdFactory	The class IdFactory builds unique Ids for all Objects
ImportanceSamplingExperiment	Abstract top-level view of an importanceSamplingExperiment plane
IndependentCopula	A class that implements an independent copula
IndicatorEvaluation	The class that implements the composition between numerical math functions implementations
IndicatorFunction	The class that implements indicator functions
Indices	Set of indices defined as a Collection of UnsignedInteger class
IndicesCollection	IndicesCollectionImplementation stores a Collection of Indices contiguously
IndicesCollectionImplementation	IndicesCollectionImplementation stores a Collection of Indices contiguously
IntegrationAlgorithm	This class is enables to integrate a function over an interval This is the interface class
IntegrationAlgorithmImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
IntegrationStrategy	An implementation of projection strategy as a leastSquares
InterfaceObject	The abstract class InterfaceObject defines the GetImplementation method
InternalException	Raised when an internal failure happened preventing processing termination
Interval	DomainComplement represents the complement of a Domain
IntervalMesher	Meshing algorithm for intervals
InvalidArgumentException	Raised when an incorrect argument is passed to a method
InvalidDimensionException	Raised when an abject of an incorrect dimension is passed to a method
InvalidRangeException	Raised when an incorrect
InverseBoxCoxEvaluation	Class for Inverse Box Cox function
InverseBoxCoxGradient	Class for Box Cox function implementation
InverseBoxCoxHessian	Class for Box Cox function implementation
InverseBoxCoxTransform	Abstract top-level class for all numerical math function implementations
InverseChiSquare	The InverseChiSquare distribution
InverseGamma	The InverseGamma distribution
InverseNatafEllipticalCopulaEvaluation	Class for the InverseNataf transformation evaluation for elliptical
InverseNatafEllipticalCopulaGradient	Class for the InverseNataf transformation evaluation for elliptical
InverseNatafEllipticalCopulaHessian	Class for the InverseNataf transformation evaluation for elliptical
InverseNatafEllipticalDistributionEvaluation	Class for the InverseNataf transformation evaluation for elliptical
InverseNatafEllipticalDistributionGradient	Class for the InverseNataf transformation gradient for elliptical
InverseNatafEllipticalDistributionHessian	Class for the InverseNataf transformation hessian for elliptical
InverseNatafIndependentCopulaEvaluation	Class for the InverseNataf transformation evaluation for independent
InverseNatafIndependentCopulaGradient	Class for the InverseNataf transformation evaluation for independent
InverseNatafIndependentCopulaHessian	Class for the InverseNataf transformation evaluation for independent
InverseNormal	The InverseNormal distribution
InverseNormalFactory	Factory for InverseNormal distribution
InverseRosenblattEvaluation	Class for the Nataf transformationEvaluation evaluation for elliptical
InverseTrendEvaluation	Class for Box Cox function implementation
InverseTrendTransform	Abstract top-level class for all numerical math function implementations
InverseWishart	The InverseWishart distribution
IteratedQuadrature	Implement an iterated quadrature based on a 1D quadrature
JacobiFactory	Jacobi polynomial factory
JansenSensitivityAlgorithm	Implementation for sensitivity algorithms
KarhunenLoeveAlgorithm	Karhunen-Loeve decomposition and projection
KarhunenLoeveAlgorithmImplementation	Karhunen-Loeve decomposition and projection
KarhunenLoeveLifting	Field to point function allowing to perform the lifting of a point into a field using a Karhunen-Loeve basis
KarhunenLoeveP1Algorithm	This class implements the computation of the Karhunen-Loeve basis and eigenvalues of a given covariance model based on P1 Lagrange approximation
KarhunenLoeveProjection	Field to point function allowing to perform the projection of a field over a Karhunen-Loeve basis
KarhunenLoeveQuadratureAlgorithm	This class implements the computation of the Karhunen-Loeve basis and eigenvalues of a given covariance model based on quadrature approximation
KarhunenLoeveResult	Karhunen-Loeve decomposition and projection
KarhunenLoeveResultImplementation	Karhunen-Loeve decomposition and by-products
KarhunenLoeveSVDAlgorithm	This class implements the computation of the Karhunen-Loeve basis and eigenvalues of a given covariance model based on SVD decomposition of a process sample
KDNearestNeighboursFinder
KDTree
KernelMixture	The class that implements kernelMixtures
KernelSmoothing	This class acts like a KernelMixture factory, implementing a
KFold	K-Fold cross validation
KissFFT	This class is enables to build an exponential covariance model, a second order model's implementation
KPermutations	KPermutations experiment plane
KPermutationsDistribution	The KPermutationsDistribution distribution
KrawtchoukFactory	Krawtchouk polynomial factory
KrigingAlgorithm	The class building gaussian process regression
KrigingEvaluation	The class building gaussian process regression
KrigingGradient	The class building gaussian process regression
KrigingRandomVector	An implementation class for kriging random vectors
KrigingResult	The result of a kriging estimation
LaguerreFactory	Laguerre polynomial factory
Laplace	The Laplace distribution
LaplaceFactory	Factory for Laplace distribution
LARS	Least Angle Regression Algorithm
Last	This class is a top-level class for the history mechanism of simulation algorithms. It delegates to its children the effective history strategy
LeastSquaresMetaModelSelection	Basis selection algorithm
LeastSquaresMetaModelSelectionFactory	A factory for building LeastSquaresMetaModelSelection objects
LeastSquaresMethod	LeastSquares solving algorithm interface
LeastSquaresMethodImplementation	LeastSquares solving algorithm implementation
LeastSquaresProblem	LeastSquaresProblem allows to describe an optimization problem
LeastSquaresStrategy	An implementation of projection strategy as a leastSquares
LegendreFactory	Legendre polynomial factory
Less	Implementation of strict less comparison
LessOrEqual	Implementation of less or equal comparison
LevelSet	LevelSet is defined as the set of points such that f(x_1,...,x_n) <= level
LevelSetMesher	Meshing algorithm for levelSets
LHS	LHS is an implementation of the hit or miss Monte Carlo simulation method
LHSExperiment	Abstract top-level view of an LHSExperiment plane
LinearBasisFactory	Linear canonical basis factory
LinearCombinationEvaluation	The evaluation part of linear combination of polynomials
LinearCombinationFunction	The class that implements linear combination of functions
LinearCombinationGradient	The gradient part of linear combination of polynomials
LinearCombinationHessian	The hessian part of linear combination of polynomials
LinearEnumerateFunction	The bijective function to select polynomials in the orthogonal basis
LinearEvaluation	Class for a linear numerical math function implementation of the form y = constant + <linear, x - c> where c is a dim(x) numerical point, linear a dim(x) by dim(y) matrix and <linear, x - c> means Transpose(linear).(x - c)
LinearFunction	The class that implements linear numerical math functions
LinearGradient	Class for a quadratic numerical math gradient implementation
LinearLeastSquares	First order polynomial response surface by least square
LINEARLEASTSQUARESCALIBRATION	LinearLeastSquaresCalibration algorithm
LinearModelAlgorithm	LinearModelAlgorithm implements the linear model
LinearModelAnalysis	The linear model analysis
LinearModelResult	The result of a linear model estimation
LinearModelTest	StatTest implements statistical tests
LinearTaylor	First order polynomial response surface by Taylor expansion
log	Records all user information to a file or tty
Log_init
Logistic	The Logistic distribution
LogisticFactory	Factory for Logistic distribution
LogNormal	The LogNormal distribution
LogNormalFactory	Factory for LogNormal distribution
LogNormalMuSigma	LogNormal distribution with mu and sigma as parameters
LogNormalMuSigmaOverMu	LogNormal distribution with mu and sigma over mu as parameters
LogUniform	The LogUniform distribution
LogUniformFactory	Factory for LogUniform distribution
LowDiscrepancyExperiment	Abstract top-level view of an monteCarloExperiment plane
LowDiscrepancySequence	Interface for low discrepancy sequences
LowDiscrepancySequenceImplementation	This class is a top-level class for low discrepancy sequences
MarginalDistribution	The class that implements a generic mechanism to extract marginal distributions
MarginalTransformationEvaluation	Class for the Nataf transformationEvaluation evaluation for elliptical
MarginalTransformationGradient	Class for the Nataf transformationGradient evaluation for elliptical
MarginalTransformationHessian	Class for the Nataf transformationHessian evaluation for elliptical
MartinezSensitivityAlgorithm	Implementation for sensitivity algorithms
MaternModel
Matrix
MatrixImplementation	MatrixImplementation implements the classical mathematical Matrix
MauntzKucherenkoSensitivityAlgorithm	Implementation for sensitivity algorithms
MaximumDistribution	The MaximumDistribution distribution
MaximumEntropyOrderStatisticsCopula	The maximum entropy order statistics copula
MaximumEntropyOrderStatisticsDistribution	The maximum entropy order statistics distribution
MaximumLikelihoodFactory	Maximum likelihood estimation
MCMC	MCMC base class
MediumSafe	Find the roots in a given direction according to the Proban
MeixnerDistribution	The MeixnerDistribution distribution
MeixnerDistributionFactory	Factory for MeixnerDistribution distribution
MeixnerFactory	Meixner polynomial factory
MemoizeEvaluation	Class for identity evaluation
MemoizeFunction	This class is a Function with history of input and output
MersenneTwister	RandomGenerator implements methods to control the random generator
Mesh	Mesh is defined as a collection of n-D vertices and simplices
MeshDomain	MeshDomain converts a Mesh into a DomainImplementation
MetaModelAlgorithm	Implementation for metamodel algorithms
MetaModelResult	Result of a Meta-model algorithm
MetaModelValidation	Implementation for metamodel validation
MethodBoundEvaluation
MethodOfMomentsFactory	Estimation by method of moments
MinCopula	A class that implements a min copula
Mixture	The class that implements mixtures
MixtureClassifier	K-Fold cross validation
MonomialFunction	Monomial function implementation
MonomialFunctionFactory	This a class for 1D monomial function factories
MonteCarloExperiment	Abstract top-level view of an monteCarloExperiment plane
Multinomial	The Multinomial distribution
MultinomialFactory	Factory for Multinomial distribution
MultiStart	MultiStart optimization algorithm
MutexLock	The class MutexLock manages the lock/unlock of Pthread mutexes This file is intended to be only include in .cxx files (avoid .hxx)
NaiveEnclosingSimplex	This class provides a naive implementation of point location. It is only meant for debugging purpose
NaiveNearestNeighbour
NaiveNearestNeighboursFinder
NatafEllipticalCopulaEvaluation	Class for the Nataf transformation evaluation for elliptical
NatafEllipticalCopulaGradient	Class for the Nataf transformation evaluation for elliptical
NatafEllipticalCopulaHessian	Class for the Nataf transformation evaluation for elliptical
NatafEllipticalDistributionEvaluation	Class for the Nataf transformation evaluation for elliptical
NatafEllipticalDistributionGradient	Class for the Nataf transformation gradient for elliptical
NatafEllipticalDistributionHessian	Class for the Nataf transformation hessian for elliptical
NatafIndependentCopulaEvaluation	Class for the Nataf transformation evaluation for independent
NatafIndependentCopulaGradient	Class for the Nataf transformation evaluation for independent
NatafIndependentCopulaHessian	Class for the Nataf transformation evaluation for independent
NearestNeighbour1D
NearestNeighbourAlgorithm	This class provides fast search of neighbours. This is the interface class
NearestNeighbourAlgorithmImplementation	This class provides fast search of neighbours. This is an abstract class
NearestPointChecker	NearestPointChecker checks wether the nearest point found is really the nearestpoint
NearestPointCheckerResult	NearestPointCheckerResult stores the test result
NearestPointProblem	NearestPointProblem allows to describe an optimization problem
NegativeBinomial	The NegativeBinomial distribution
NegativeBinomialFactory	Factory for NegativeBinomial distribution
NLopt	NLopt solver
NO_MATCH_ON_ReturnTypeAdapter	This class gives a implementation for object's methods so they can be used in Functions
NoEvaluation	Class for unavailable evaluation implementations
NoGradient	Abstract top-level class for all numerical math gradient implementations
NoHessian	Abstract top-level class for all numerical math hessian implementations
NonCenteredFiniteDifferenceGradient	Class for the creation of a numerical math gradient implementation form a numerical math evaluation implementation by using noncentered finite difference formula
NonCentralChiSquare	The NonCentralChiSquare distribution
NonCentralStudent	The NonCentralStudent distribution
NONLINEARLEASTSQUARESCALIBRATION	NonLinearLeastSquaresCalibration algorithm
NonStationaryCovarianceModelFactory	Top-level class for all spectral model factories
Normal	The Normal distribution
NormalCopula	A class that implements a normal copula
NormalCopulaFactory	Factory for NormalCopula distribution
NormalFactory	Factory for Normal distribution
NormalGamma	The NormalGamma distribution
NormalityTest	StatTest implements statistical tests
NormInfEnumerateFunction	The bijective function to select polynomials in the orthogonal basis
NotDefinedException	Raised when raise when a method has no definition and should not have one
NotSymmetricDefinitePositiveException	Raised when a matrix seems not to be symmetric nor positive definite
NotYetImplementedException	Raised when a method has not been implemented yet though it should be
Null	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
Object	The base classe for almost every object in OpenTURNS
ObjectNotInStudyException	Raised when a file does not belong to a saved study
ODESolver
ODESolverImplementation	ODE solver base class
OptGSS	OPTpp solver implementation
OptimizationAlgorithm	OptimizationAlgorithm provides capabilities to solve optimization problems
OptimizationAlgorithmImplementation	OptimizationAlgorithmImplementation implements an algorithm for solving an optimization problem
OptimizationProblem	OptimizationProblem allows to describe an optimization problem
OptimizationProblemImplementation	OptimizationProblemImplementation allows to describe an optimization problem
OptimizationResult	OptimizationResult implements the result of an algorithm for solving an optimization problem
OPTpp
OPTppImplementation
OrderStatisticsMarginalChecker	OrderStatisticsMarginalChecker class
OrdinalSumCopula	The class that implements assembly distributions
OrthogonalBasis	This is the interface class for orthogonal basis
OrthogonalDirection	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
OrthogonalFunctionFactory	This is an abstract class for orthogonal basis
OrthogonalProductFunctionFactory	This is the orthogonal function basis
OrthogonalProductPolynomialFactory	This is the orthogonal polynomial basis
OrthogonalUniVariateFunctionFactory	This an abstract class for 1D function factories
OrthogonalUniVariateFunctionFamily	This is the interface class for orthogonal function factories
OrthogonalUniVariatePolynomial	This is an orthogonal 1D polynomial
OrthogonalUniVariatePolynomialFactory	This an abstract class for 1D polynomial factories
OrthogonalUniVariatePolynomialFamily	This is the interface class for orthogonal polynomial factories
OrthogonalUniVariatePolynomialFunctionFactory	Polynomial function factory
OrthonormalizationAlgorithm	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
OrthonormalizationAlgorithmImplementation	Top level class for the orthonormalization algorithms
Os	This class provides operating system specific variables
OSS
OSSFormater
OStream	The class Ostream is an helper for pretty printing of Objects
OutOfBoundException	Raised when an index of a collection jumped out of the expected bounds
P1LagrangeEvaluation	P1 Lagrange piecewise linear function
P1LagrangeInterpolation	P1 Lagrange interpolation between two meshes
Pairs	Pairs class for piechart plots
ParametricEvaluation	ParametricEvaluation
ParametricFunction	The class that implements parametric functions
ParametricGradient	ParametricGradient
ParametricHessian	ParametricHessian
ParametricPointToFieldFunction	The class that implements parametric Point To Field functions
ParametrizedDistribution	Abstract top-level class for Parametrized distributions
Path	This class provides all the mechanism of path manipulation
PenalizedLeastSquaresAlgorithm	This Penalized Least Squares Algorithm as a functor class
PenalizedLeastSquaresAlgorithmFactory	A factory for building PenalizedLeastSquaresAlgorithm objects
PersistentCollection
PersistentObject	This class defines load and save mechanisms
PersistentObjectFactory	Class PersistentObjectFactory reloads a PersistentObject from a storage manager
Pie	Pie class for piechart plots
PiecewiseHermiteEvaluation	The evaluation part of a hermite piecewise scalar function
PiecewiseLinearEvaluation	The evaluation part of a linear piecewise scalar function
PlatformInfo	The class PlatformInfo gives information about the library
Point	Point implements the classical mathematical point
Pointer	The class Pointer implements a shared pointer strategy
PointInSourceFile	Exception defines top-most exception strategies
PointToFieldConnection	The class that implements the composition between evaluation and point to field function or between point to field function and field function
PointToFieldFunction	The class that implements functions mapping points to fields
PointToFieldFunctionImplementation
PointToPointConnection	The class that implements the point to point connection
PointToPointEvaluation	The class that implements the composition between numerical math functions implementations or a point to field function and a field to point function
PointWithDescription	PointWithDescription extends the classical mathematical point with a description of the coordinates
Poisson	The Poisson distribution
PoissonFactory	Factory for Poisson distribution
Polygon	Polygon class for polygon plots
PolygonArray	PolygonArray class for array of polygons plots
PostAnalyticalControlledImportanceSampling	PostAnalyticalControlledImportanceSampling is an implementation of the importance sampling Montex Carlo simulation method
PostAnalyticalImportanceSampling	PostAnalyticalImportanceSampling is an implementation of the importance sampling Montex Carlo simulation method
PostAnalyticalSimulation	PostAnalyticalSimulation is a generic view of postAnalyticalSimulation methods for computing probabilities and related quantities by sampling and estimation
PosteriorDistribution	The PosteriorDistribution distribution
ProbabilitySimulationAlgorithm	ProbabilitySimulationAlgorithm is a generic view of simulation methods for computing probabilities and related quantities by sampling and estimation
ProbabilitySimulationResult	Implementation of SimulationResult
Process	The interface class that implements all process
ProcessImplementation
ProcessSample	ProcessSample class
ProcessSampleImplementation	ProcessSampleImplementation class
ProductCovarianceModel
ProductDistribution	The ProductDistribution distribution
ProductEvaluation	The class that implements the composition between numerical math functions implementations
ProductFunction	The class that implements product numerical math functions
ProductGradient	The class that implements the composition between numerical math functions
ProductHessian	The class that implements the composition between numerical math hessians
ProductPolynomialEvaluation	This is a nD polynomial build as a product of n 1D polynomial
ProductPolynomialGradient	This is a nD polynomial build as a product of n 1D polynomial
ProductPolynomialHessian	This is a nD polynomial build as a product of n 1D polynomial
ProductUniVariateFunctionEvaluation	This is a nD function build as a product of n 1D function
ProductUniVariateFunctionGradient	This is a nD polynomial build as a product of n 1D polynomial
ProductUniVariateFunctionHessian	This is a nD function build as a product of n 1D function
ProjectionStrategy	This is the interface class for projection strategies
ProjectionStrategyImplementation	This is a abstract class for projection strategy implementations
QRMethod	QR-decomposition based LS solver
QuadrantSampling	Sampling in standard space quadrants
QuadraticBasisFactory	Quadratic canonical basis factory
QuadraticEvaluation	Class for a quadratic numerical math function implementation of the form y = constant + <linear, x-c> + <<quadratic, x-c>, x-c> where constant is a dim(y) numerical point, c a dim(x) numerical point, linear is a dim(x) by dim(y) matrix, quadratic is a dim(x) by dim(x) by dim(y) symmetric tensor and <linear, x> means Transpose(linear).x, <quadratic, x> means Transpose_kj(quadratic).x
QuadraticFunction	The class that implements quadratic numerical math functions
QuadraticLeastSquares	Second order polynomial response surface by least square
QuadraticTaylor	Second order polynomial response surface by Taylor expansion
RandomDirection	Sampling in standard space quadrants
RandomGenerator
RandomGeneratorState	RandomGeneratorState implements methods to manage the random generator state
RandomMixture	The class that implements randomMixtures
RandomVector	The class that implements all random vectors
RandomVectorImplementation
RandomWalk	A class which implements the RandomWalk process
RandomWalkMetropolisHastings	Metropolis-Hastings algorithm
RankMCovarianceModel
RatioDistribution	The RatioDistribution distribution
Rayleigh	The Rayleigh distribution
RayleighFactory	Factory for Rayleigh distribution
RegularGrid	The class RegularGrid implements an equaly spaced set of real values
RegularGridEnclosingSimplex	This class provides a point location algorithm on RegularGrid
RegularGridNearestNeighbour	Nearest neighbour index search on a RegularGrid
ResourceMap	ResourceMap defines a resource catalog
ResourceMap_init
ReverseHaltonSequence	Implementation of the ReverseHalton sequence
Rice	The Rice distribution
RiceFactory	Factory for Rice distribution
RiskyAndFast	Find the roots in a given direction according to the Proban
RootStrategy	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
RootStrategyImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
RosenblattEvaluation	Class for the Nataf transformationEvaluation evaluation for elliptical
RungeKutta	This class implements the fourth order fixed-step Runge-Kutta ODE integrator
SafeAndSlow	Find the roots in a given direction according to the Proban
SaltelliSensitivityAlgorithm	Implementation for sensitivity algorithms
Sample	The class Sample implements blank free samples
SamplingStrategy	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
SamplingStrategyImplementation	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
SaveAction
Secant	Implementation class of the scalar nonlinear solver based on
SequentialStrategy	An implementation returning the set of polynomials in sequence
SharedPointer	This class implements a shared pointer strategy
SimulationAlgorithm	EventSimulation algorithms base class
SimulationResult	Base class for simulation results
SimulationSensitivityAnalysis	Implementation of SimulationResult
Skellam	The Skellam distribution
SkellamFactory	Factory for Skellam distribution
SklarCopula	The SklarCopula distribution
SmoothedUniform	The SmoothedUniform distribution
SobolIndicesAlgorithm	SobolIndicesAlgorithm provides capabilities for sensitivity algorithm
SobolIndicesAlgorithmImplementation	Implementation for sobol indices algorithms
SobolIndicesExperiment	Experiment to compute Sobol' indices
SobolSequence	Implementation of the Sobol sequence
SobolSimulationAlgorithm	Simulation algorithm to estimate Sobol indices
SobolSimulationResult	Result of a Sobol indices simulation
SoizeGhanemFactorEvaluation	This is the evaluation part of the Soize-Ghanem basis coupling factor
SoizeGhanemFactory	This is the natural orthogonal basis associated to a multidimensional distribution
Solver	Interface class for a nonlinear scalar solver
SolverImplementation	Implementation class for a nonlinear scalar solver
SORM	SORM implements the First Order Reliability Method
SORMResult	SORMResult implements the First Order Reliability Method
SparseMethod	Sparse approximation LS solver
SpecFunc	OpenTURNS wrapper to a library of special functions
SpectralGaussianProcess	A class which implements the SpectralGaussianProcess process
SpectralModel	This class is enables to build a spectral model using its spectral density function This is the interface class
SpectralModelFactory	Top-level class for all spectral model factories
SpectralModelImplementation	This class is enables to build a spectral model using its spectral density function This is the interface class
SphereUniformNorm	Implementation of a generic grid iterator
SphereUniformNorm1D	Implementation of a generic grid iterator
SphereUniformNormImplementation	The class SphereUniformNormImplementation implements walker on a regular grid
SphericalModel	Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
SQP	SQP is an actual implementation for OptimizationAlgorithm using the SQP algorithm
SquareComplexMatrix
SquaredExponential
SquareMatrix
Staircase	Staircase class for handling staircase plots
StandardDistributionPolynomialFactory	OrthogonalUniVariatePolynomialStandardDistribution polynomial factory
StandardEvent	The class that implements an event based on a composite random vector whose antecedent has a spherical distribution Copyright 2005-2019 Airbus-EDF-IMACS-Phimeca
StationaryCovarianceModel	This class enables to build a covariance model
StationaryCovarianceModelFactory	Top-level class for all spectral model factories
StorageManager	Abstract class defining the way OpenTURNS' objects are saved and reloaded
StratifiedExperiment	Abstract top-level view of an stratifiedExperiment plane
StrongMaximumTest	StrongMaxTest implements an algorithm to check if a given design point
Student	The Student distribution
StudentFactory	Factory for Student distribution
Study	Keeps all PersistentObjects in a file
StudyFileParsingException	Raised when the study file can be read
SubsetSampling	Subset simulation method
SubsetSamplingResult	Subset sampling result
SVDMethod	SVD-decomposition based LS solver
SymbolicEvaluation	The class that implements the evaluation of an analytical function
SymbolicFunction	The class that implements symbolic functions
SymbolicGradient	The class that implements the gradient of an analytical function
SymbolicHessian	The class that implements the Hessian of analytical functions
SymbolicParser	A math expression parser
SymbolicParserImplementation	A math expression parser
SymmetricMatrix
SymmetricTensor	SymmetricTensor implements the classical mathematical symmetric tensor
TaylorExpansionMoments	TaylorExpansionMoments implements Taylor expansion for moments estimation
TBB_init
Tensor
TensorApproximationAlgorithm	Tensor approximation algorithm
TensorApproximationResult	The result of a tensor approximation
TensorImplementation	TensorImplementation implements the Tensor classes
TensorizedCovarianceModel
TensorizedUniVariateFunctionFactory	This is the tensorized function basis
Test	StatTest implements statistical tests
TestResult	TestResult implements the result of a statistical test
Text	Text class to add text on graphs
THREEDVAR	GaussianNonLinearCalibration algorithm
TimeSeries	The class TimeSeries implements values indexed by time
TNC	TNC is an actual implementation for OptimizationAlgorithmImplementation using the TNC library
TranslationEvaluation	Class for a numerical math function implementation of the form y = constant + x
TranslationFunction	The class that implements translation functions
Trapezoidal	The Trapezoidal distribution
TrapezoidalFactory	Factory for Trapezoidal distribution
TrendEvaluation	Class for Box Cox function implementation
TrendFactory	This class is enables to estimate trend
TrendTransform	Abstract top-level class for all numerical math function implementations
Triangular	The Triangular distribution
TriangularComplexMatrix
TriangularFactory	Factory for Triangular distribution
TriangularMatrix
TruncatedDistribution	The TruncatedDistribution distribution
TruncatedNormal	The TruncatedNormal distribution
TruncatedNormalFactory	Factory for TruncatedNormal distribution
TTY	This file provides definitions for tty control sequences
Tuples	Tuples experiment plane
TypedCollectionInterfaceObject	TypedCollectionInterfaceObject implements TypedInterfaceObject for a class that manages a collection
TypedInterfaceObject	TypedInterfaceObject implements InterfaceObject for a specific class
Uniform	The Uniform distribution
UniformFactory	Factory for Uniform distribution
UniVariateFunction	Univariate function
UniVariateFunctionEvaluation	This is a nD function build as a product of n 1D function
UniVariateFunctionFactory	This an abstract class for 1D function factories
UniVariateFunctionFamily	This is the interface class for function factories
UniVariateFunctionImplementation	Univariate function implementation
UniVariatePolynomial	This is a 1D polynomial
UniVariatePolynomialImplementation	This is a 1D polynomial
UserDefined	The UserDefined distribution
UserDefinedCovarianceModel	This class builds a covariance model using a mesh and a covariance function given as a collection of Covariance Matrix or a global covariance matrix
UserDefinedFactory	Factory for UserDefined distribution
UserDefinedSpectralModel	This class build a spectral model using a frequency grid and a spectral function given as a collection of Hermitian Matrix This is the interface class
UserDefinedStationaryCovarianceModel	This class build a stationary covariance model using a time grid and a collection of covariance matrices
UsualRandomVector	An implementation class for distribution-based random vectors
ValueFunction	Abstract top-level class for all numerical math function implementations
VertexValueFunction	Abstract top-level class for all numerical math function implementations
VonMises	The VonMises distribution
Weibull	The Weibull distribution
WeibullFactory	Factory for Weibull distribution
WeibullMuSigma	Weibull distribution with mu and sigma as parameters
WeightedExperiment	WeightedExperiment interface
WeightedExperimentImplementation	Abstract top-level view of an weightedExperiment plane
WelchFactory	Top-level class for all spectral model factories
WhiteNoise	A class which implements the WhiteNoise process
WhittleFactory	The class enables to get the coefficients of an ARMA process using its spectral density function
WhittleFactoryState	This class stores the current state of the fitting step in the WhittleFactory class
Wilks	Wilks is a static class that gives access to the computation of the sample size for guaranteed upper bound of quantile
Wishart	The Wishart distribution
XMLException	Raised when a general XML error was detected
XMLParserException	Raised when an XML error was detected during file parsing
XMLStorageManager	Implements a storage manager that drives a XML file
ZipfMandelbrot	The ZipfMandelbrot distribution