Class List

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

Ngum	Gum is the global namespace for all aGrUM entities
N__sig__	Internal namespace for aGrUM signaler/listener components
CIConnector	Abstract interface for signal connectors with variadic arguments
CConnector	Concrete connector binding a target object and its member function
CBasicSignaler	Base class for signalers, managing connector lifecycle
Naggregator	Aggregators are functional description of CPTs
CAmplitude	Amplitude aggregator
CAnd	And aggregator
CCount	Count aggregator
CExists	Exists aggregator
CForall	Forall aggregator
CMax	Max aggregator
CMedian	Median aggregator
CMin	Min aggregator
CMultiDimAggregator	<agrum/base/multidim/aggregators/multiDimAggregator.h>
COr	Or aggregator
CSum	Sum aggregator
Ncredal	Namespace for all credal networks entities
Nlp	Namespace for constraint-based description of credal sets
CLpInterface	Class representing a linear program
CLpCol	Class representing a variable ( a column ) of a linear program, i.e
CLpExpr	Class representing a linear expression
CLpRow	Class representing a row of the linear program, i.e
CCNLoopyPropagation	<agrum/CN/CNLoopyPropagation.h>
CCNMonteCarloSampling	<agrum/CN/CNMonteCarloSampling.h>
CCredalNet	Class template representing a Credal Network
CInferenceEngine	Abstract class template representing a CredalNet inference engine
CLRSWrapper	Class template acting as a wrapper for Lexicographic Reverse Search by David Avis
CMultipleInferenceEngine	Class template representing a CredalNet inference engine using one or more IBayesNet inference engines such as LazyPropagation
CVarMod2BNsMap	Class used to store optimum IBayesNet during some inference algorithms
Nlearning	Include the inlined functions if necessary
C_GraphChangesGenerator4K2_
CArcAddition	The class for notifying learning algorithms of new arc additions
CArcDeletion	The class for notifying learning algorithms of arc removals
CArcReversal	The class for notifying learning algorithms of arc reversals
CArcTriangleDeletion1	The graph change substituting a triangle node1->node2->node3 + node1->node3 into v-structure node2->node1<-node3
CArcTriangleDeletion2	The graph change substituting a triangle node1->node2->node3 + node1->node3 into v-structure node1->node2<-node3
CBDeuPrior	Internal prior for the BDeu score (N' / (r_i * q_i)
CBNDatabaseGenerator
CBNLearner	A pack of learning algorithms that can easily be used
CBNLearnerListener	A class that redirects gum_signal from algorithms to the listeners of BNLearn
CCachedContingencyCounter	Common counting infrastructure shared by IndependenceTest and KNML
CCIBasedLearning	Abstract base for CI-test-based causal structure learning (PC, FCI)
CSepSetEntry_
CConstraintBasedLearning	Abstract base class for constraint-based structure learning algorithms
CCorrectedMutualInformation	The class computing n times the corrected mutual information, as used in the MIIC algorithm
CCSVParser	Class for fast parsing of CSV file (never more than one line in application memory)
CDAG2BNLearner	A class that, given a structure and a parameter estimator returns a full Bayes net
CDatabaseTable	The class representing a tabular database as used by learning tasks
CDBCell	The class representing the original values of the cells of databases
CDBHandler	The base class for all database handlers
CDBInitializerFromCSV	The class for initializing DatabaseTable and RawDatabaseTable instances from CSV files
CDBInitializerFromSQL	The class for initializing DatabaseTable and RawDatabaseTable instances from SQL databases
CDBRow	The class for storing a record in a database
CDBRowGenerator	The base class for all DBRow generators
CDBRowGenerator4CompleteRows	A DBRowGenerator class that returns the rows that are complete (fully observed) w.r.t
CDBRowGeneratorEM	A DBRowGenerator class that returns incomplete rows as EM would do
CDBRowGeneratorIdentity	A DBRowGenerator class that returns exactly the rows it gets in input
CDBRowGeneratorParser	Class used to read a row in the database and to transform it into a set of DBRow instances that can be used for learning
CDBRowGeneratorSet	The class used to pack sets of generators
CDBRowGeneratorWithBN	Base class for DBRowGenerator classes that use a BN for computing their outputs
CDBTranslatedValue	The union class for storing the translated values in learning databases
CDBTranslator	The base class for all the tabular database cell translators
CDBTranslator4ContinuousVariable	The databases' cell translators for continuous variables
CDBTranslator4DiscretizedVariable	The databases' cell translators for discretized variables
CDBTranslator4IntegerVariable	The databases' cell translators for integer variables
CDBTranslator4LabelizedVariable	The databases' cell translators for labelized variables
CDBTranslator4NumericalDiscreteVariable	The databases' cell translators for numerical Discrete variables
CDBTranslator4RangeVariable	The databases' cell translators for range variables
CDBTranslatorSet	Class for packing together the translators used to preprocess the datasets
CDirichletPriorFromBN	A dirichlet priori: computes its N'_ijk from a database
CDirichletPriorFromDatabase	A dirichlet priori: computes its N'_ijk from a database
CEdgeAddition	The class for notifying learning algorithms of new edge additions
CEdgeDeletion	The class for notifying learning algorithms of edge removals
CEMApproximationScheme	A class for parameterizing EM's parameter learning approximations
CFCI	Fast Causal Inference — PAG learning via constraint-based methods
CGraphChange
CGraphChangesGenerator4DiGraph	The basic class for computing the next graph changes possible in a structure learning algorithm
CGraphChangesGenerator4K2	The basic class for computing the next graph changes possible in a structure learning algorithm
CGraphChangesGenerator4UndiGraph	The basic class for computing the next graph changes possible in an undirected structure learning algorithm
CGraphChangesGeneratorOnSubDiGraph	The basic class for computing the next graph changes possible in a structure learning algorithm
CGraphChangesSelector4DiGraph	The mecanism to compute the next available graph changes for directed structure learning search algorithms
CGreaterAbsPairOn2nd
CGreaterPairOn2nd
CGreaterTupleOnLast
CGreedyHillClimbing	The greedy hill climbing learning algorithm (for directed graphs)
CGreedyThickThinning	The greedy thick-thinning learning algorithm (for directed graphs)
CIBNLearner	A pack of learning algorithms that can easily be used
CDatabase	Helper to easily read databases
CIDatabaseTable	The common class for the tabular database tables
CHandler	(unsafe) handler for the tabular databases
CHandlerSafe	Safe handler of the tabular databases
CIDatabaseTableInsert4DBCell
CIDatabaseTableInsert4DBCell< false >
CIDatabaseTableInsert4DBCell< true >
CIDBInitializer	The base class for initializing DatabaseTable and RawDatabaseTable instances from CSV files or SQL databases
CIdCondSet	A class for storing a pair of sets of NodeIds, the second one corresponding to a conditional set
CIdCondSetIterator	The iterators for IdSets
CIGraphChangesGenerator4DiGraph
CIGraphChangesGenerator4UndiGraph
CIKTBNLearner	Pure-virtual configuration interface shared by all k-TBN learners
CIndependenceTest	The base class for all the independence tests used for learning
CIndepTestChi2	Class for computing Chi2 independence test scores
CIndepTestG2	Class for computing G2 independence test scores
CK2	The K2 algorithm
CK2Prior	Internal prior for the K2 score = Laplace Prior
CKNML	Class for computing the NML penalty used by MIIC
CKTBNAdaptiveLearner	Learns a k-TBN (order k + structure + parameters) from trajectory CSVs
CKTBNDatabaseGenerator	Generates a database of trajectories from a k-DBN (one CSV per trajectory)
CParentRef	Parent of a template node, precompiled for fast sampling
CNodeRef	Template node, precompiled for fast sampling
CKTBNLearner	Learns a k-TBN (structure and/or parameters) from trajectory CSVs
CLocalSearchWithTabuList	The local search with tabu list learning algorithm (for directed graphs)
CMiic	The MIIC learning algorithm
CNanodbcParser	Class for parsing SQL results using Nanodbc
CNoPrior	No a priorclass: corresponds to 0 weight-sample
CParamEstimator	The base class for estimating parameters of CPTs
CParamEstimatorML	The class for estimating parameters of CPTs using Maximum Likelihood
CPC	PC (Peter-Clark) constraint-based structure learning algorithm
CPrior	Base class for all a priori
CPseudoCount	The class for giving access to pseudo count : count in the database + prior
CRawDatabaseTable	The table containing the raw/original data of a database
CRecordCounter	The class that computes counting of observations from the database
CScore	The base class for all the scores used for learning (BIC, BDeu, etc)
CScoreAIC	Class for computing AIC scores
CScoreBD	Class for computing Bayesian Dirichlet (BD) log2 scores
CScoreBDeu	Class for computing BDeu scores
CScoreBIC	Class for computing BIC scores
CScorefNML	Class for computing fNML scores
CScoreK2	Class for computing K2 scores (actually their log2 value)
CScoreLog2Likelihood	Class for computing Log2-likelihood scores
CScoringCache	Cache for caching scores and independence tests results
CSimpleMiic	The miic learning algorithm
CSmoothingPrior	Smooth a priori: adds a weight w to all the counts
CStructuralConstraintDAG	The base class for structural constraints imposed by DAGs
CStructuralConstraintDiGraph	The base class for structural constraints used by learning algorithms that learn a directed graph structure
CStructuralConstraintEmpty	Base class for all structural constraints
CStructuralConstraintForbiddenArcs	Structural constraint for forbidding the creation of some arcs during structure learning
CStructuralConstraintIndegree	Class for structural constraints limiting the number of parents of nodes in a directed graph
CStructuralConstraintMandatoryArcs	Structural constraint indicating that some arcs shall never be removed or reversed
CStructuralConstraintNoChildrenNodes	Structural constraint for forbidding children for some nodes
CStructuralConstraintNoParentNodes	Structural constraint for forbidding parents for some nodes
CStructuralConstraintPossibleEdges	Structural constraint for forbidding the creation of some arcs except those defined in the class during structure learning
CStructuralConstraintSetStatic	"meta-programming" class for storing structural constraints
CStructuralConstraintSliceOrder	Structural constraint imposing a partial order over nodes
CStructuralConstraintTabuList	The class imposing a N-sized tabu list as a structural constraints for learning algorithms
CStructuralConstraintTotalOrder	Structural constraint imposing a total order over some nodes
CStructuralConstraintUndiGraph	The base class for structural constraints used by learning algorithms that learn an undirected graph structure
Nprm	Namespace for all probabilistic relational models entities
Ngspan
CDFSCode	Reprensent a Depth First Search coding of a graph
CDFSTree	A DFSTree is used by gspan to sort lexicographically patterns discovered in an interface graph
CPatternData
CNeighborDegreeSort	This is used to generate the max_indep_set of a Pattern
CEdgeCode	Represent a DFS code used by gspan
CEdgeData	Inner class to handle data about edges in graph
CEdgeGrowth	This class is used to define an edge growth of a pattern in this DFSTree
CFrequenceSearch	This is class is an implementation of a simple serach strategy for the gspan algorithm: it accept a growth if its frequency is above a user defined value
CInterfaceGraph	This class represent the interface graph of a given gum::prm::PRMSystem<GUM_SCALAR>
CLabelData	Inner class to handle data about labels in this interface graph
CNodeData	Inner class to handle data about nodes in graph
CPattern	This contains all the information we want for a node in a DFSTree
CSearchStrategy	This is an abstract class used to tune search strategies in the gspan algorithm
CStrictSearch	This is class is an implementation of a strict strategy for the GSpan algorithm
CPData	Private structure to represent data about a pattern
CTreeWidthSearch	A growth is accepted if and only if the new growth has a tree width less large or equal than its father
No3prm
CO3Aggregate	The O3Aggregate is part of the AST of the O3PRM language
CO3Assignment	The O3Assignment is part of the AST of the O3PRM language
CO3Attribute	The O3Attribute is part of the AST of the O3PRM language
CO3Class	The O3Class is part of the AST of the O3PRM language
CO3ClassFactory	Builds gum::prm::Class from gum::prm::o3prm::O3Class
CO3Float	The O3Float is part of the AST of the O3PRM language
CO3Formula	The O3Formula is part of the AST of the O3PRM language
CO3Import	The O3Import is part of the AST of the O3PRM language
CO3Increment	The O3Increment is part of the AST of the O3PRM language
CO3Instance	The O3Instance is part of the AST of the O3PRM language
CO3InstanceParameter	The O3InstanceParameter is part of the AST of the O3PRM language
CO3Integer	The O3Integer is part of the AST of the O3PRM language
CO3Interface	The O3Interface is part of the AST of the O3PRM language
CO3InterfaceElement	The O3InterfaceElement is part of the AST of the O3PRM language
CO3InterfaceFactory	Bulds gum::prm:PRMInterface from gum::prm::o3prm::O3Interface
CO3IntType	The O3IntType is part of the AST of the O3PRM language
CO3Label	The O3Label is part of the AST of the O3PRM language
CO3NameSolver	Resolves names for the different O3PRM factories
CO3Parameter	The O3Parameter is part of the AST of the O3PRM language
CO3Position	The O3Position is part of the AST of the O3PRM language
CO3PRM	The O3PRM is part of the AST of the O3PRM language
CO3prmReader	This class read O3PRM files and creates the corresponding gum::prm::PRM
CO3RawCPT	The O3RawCPT is part of the AST of the O3PRM language
CO3RealType	The O3RealType is part of the AST of the O3PRM language
CO3ReferenceSlot	The O3ReferenceSlot is part of the AST of the O3PRM language
CO3RuleCPT	The O3RuleCPT is part of the AST of the O3PRM language
CO3System	The O3System is part of the AST of the O3PRM language
CO3SystemFactory	Builds gum::prm::PRMSystem from gum::prm::o3prm::O3System
CO3Type	The O3Type is part of the AST of the O3PRM language
CO3TypeFactory	Builds gum::prm::PRMType from gum::prm::o3prm::O3Type, gum::prm::o3prm::O3IntType and gum::prm::o3prm::O3RealType
No3prmr
CImportCommand
CO3prmrCommand	This is an abstract class
CO3prmrContext	Represent a o3prmr context, with an import, and some sequencials commands
CO3prmrInterpreter	Represents a O3PRMR context
CO3prmrSession	This class contains a o3prmr session
CObserveCommand
CQueryCommand
CQueryResult
CSetEngineCommand
CSetGndEngineCommand
CSingleResult
CUnobserveCommand
CClassBayesNet	This class decorates a gum::prm::Class<GUM_SCALAR> has an IBaseBayesNet
CClassDependencyGraph	This class represent the dependencies of all classes in a PRM<GUM_SCALAR>
CClusteredLayerGenerator	<agrum/PRM/generator/clusteredLayerGenerator.h>
CMyData
CGroundedInference	<agrum/PRM/groundedInference.h>
CGSpan	This class discovers pattern in a PRM<GUM_SCALAR>'s PRMSystem<GUM_SCALAR> to speed up structured inference
CLabelSort	Private class used to sort LabelData using STL sort algorithms
CPatternSort	Private class used to sort Pattern using STL sort algorithms
CInstanceBayesNet	This class decorates an PRMInstance<GUM_SCALAR> as an IBaseBayesNet
CIPRMFactory	Non-template interface-like parent for every PRM Factory
CLayerGenerator	<agrum/PRM/generator/layerGenerator.h>
CLayerData	Getters and setters
CMyData
CNameGenerator	This is a name generator for classes, types, systems, instances and class elements
CParamScopeData
CPRM	This class represents a Probabilistic Relational PRMSystem<GUM_SCALAR>
CPRMAggregate
CPRMAttribute	PRMAttribute is a member of a Class in a PRM
CPRMClass	A PRMClass is an object of a PRM representing a fragment of a Bayesian network which can be instantiated in PRMInstance
CPRMClassElement	Abstract class representing an element of PRM class
CPRMClassElementContainer	<agrum/PRM/classElementContainer.h>
CPRMFactory	Factory which builds a PRM<GUM_SCALAR>
CPRMFormAttribute	<agrum/PRM/elements/formAttribute.h>
CPRMFuncAttribute	<agrum/PRM/elements/funcAttribute.h>
CPRMGenerator	This class is the base class to all PRM generators
CPRMInference	This abstract class is used as base class for all inference class on PRM<GUM_SCALAR>
CPRMInstance	An PRMInstance is a Bayesian network fragment defined by a Class and used in a PRMSystem
CRefIterator	Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations
CRefConstIterator	Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations
CPRMInterface	An PRMInterface is implemented by a Class<GUM_SCALAR> and defines a set of PRMReferenceSlot<GUM_SCALAR> and PRMAttribute<GUM_SCALAR> which the implementing Class<GUM_SCALAR> must contain
CPRMObject	Abstract base class for any element defined in a PRM
CPRMParameter	PRMParameter is a member of a Class in a PRM
CPRMReferenceSlot	A PRMReferenceSlot represent a relation between two PRMClassElementContainer
CPRMScalarAttribute	<agrum/PRM/elements/scalarAttribute.h>
CPRMSlotChain	A PRMSlotChain represents a sequence of gum::prm::PRMClassElement<GUM_SCALAR> where the n-1 first gum::prm::PRMClassElement<GUM_SCALAR> are gum::prm::PRMReferenceSlot and the last gum::prm::PRMClassElement<GUM_SCALAR> an gum::prm::PRMAttribute or an gum::prm::PRMAggregate
CPRMSystem	A PRMSystem is a container of PRMInstance and describe a relational skeleton
CPRMType	This is a decoration of the DiscreteVariable class
CStructuredBayesBall	<agrum/PRM/structuredBayesBall.h>
CStructuredInference	<agrum/PRM/structuredInference.h>
CRGData	Private structure to represent data about a reduced graph
CPData	Private structure to represent data about a pattern
CCData	Private structure to represent data about a Class<GUM_SCALAR>
CSVE	This class is an implementation of the Structured Variable Elimination algorithm on PRM<GUM_SCALAR>
CSVED	This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR>
NthreadsOMP
CThreadExecutor
NthreadsSTL
CThreadExecutor
CAbstractFMDPFactory	A factory class to ease Factored Markov Decision Process construction
CAbstractLeaf	<agrum/FMDP/learning/datastructure/leaves/abstractLeaf.h>
CAbstractSimulator	<agrum/FMDP/simulation/abstractSimulator.h>
CActionSet	A class to store the optimal actions
CAdaptiveRMaxPlaner	<agrum/FMDP/planning/adaptiveRMaxPlaner.h>
CAggregatorDecomposition	<agrum/BN/inference/tools/aggregatorDecomposition.h>
CAlmostDifferent	Indicate whether two elements are (almost) different or not
CAlmostDifferent< T * >	Indicate whether two elements are (almost) different or not
CApproximateInference
CApproximationPolicy	Mother class for all approximation policy classes
CApproximationScheme	Approximation Scheme
CApproximationSchemeListener	The ApproximationSchemeListener class
CArc	The base class for all directed edges
CArcGraphPart	Classes for directed edge sets
CArgMaxSet	Class to handle efficiently argMaxSet
CArgumentMaximises	Arg Max function object class
CArgumentMaximisesAction	<agrum/FMDP/planning/actionSet.h>
CASTBinaryOp	Base class for binary algebraic operators (e.g., +, -, ×, ÷)
CASTdiv	Elementwise division of two AST sub-expressions (left / right)
CASTjointProba	Joint probability term ( \mathbb{P}(\mathrm{vars}) ) in an observational BN
CASTminus	Difference of two AST sub-expressions (left minus right)
CASTmult	Elementwise product of two AST sub-expressions
CASTplus	Sum of two AST sub-expressions
CASTposteriorProba	Posterior probability term ( \mathbb{P}_{bn}(\mathrm{vars}\mid\mathrm{knw}) )
CASTsum	Summation (marginalization) over one or more variables
CASTtree	Root abstract node for the AST of algebraic expressions
CAVLTree	AVL binary search tree
CAVLTreeIterator	AVL binary search tree iterator
CAVLTreeIteratorSafe	AVL binary search tree safe (w.r.t
CAVLTreeReverseIterator	AVL binary search tree reverse iterator
CAVLTreeReverseIteratorSafe	AVL binary search tree safe (w.r.t
CBarrenNodesFinder	Detect barren nodes for inference in Bayesian networks
CBayesBall	Implementation of Shachter's Bayes Balls algorithm
CBayesNet	Class representing a Bayesian network
CBayesNetFactory	A factory class to ease BayesNet construction
CBayesNetFragment	Portion of a BN identified by the list of nodes and a BayesNet
CBayesNetInference	<agrum/BN/inference/BayesNetInference.h>
CBIFReader	Definition of templatized reader of BIF files for Bayesian networks
CBIFWriter	Writes a IBayesNet in the BIF format
CBIFXMLBNReader	<agrum/BN/io/BIFXML/BIFXMLBNReader.h>
CBIFXMLBNWriter	<agrum/BN/io/BIFXML/BIFXMLBNWriter.h>
CBIFXMLIDReader	Read an influence diagram from an XML file with BIF format
CBIFXMLIDWriter	Writes an influence diagram in a XML files with BIF format
CBijection	Set of pairs of elements with fast search for both elements
CBijectionImplementation	A non scalar implementation of a Bijection
CBijectionIterator	Unsafe iterators for bijection
CBijectionIteratorGet	Dummy classes for discriminating scalars and non-scalars operators and -> wihtout any overhead
CBijectionIteratorGet< true >
CBijectionIteratorSafe	Safe iterators for bijectionIterator
CBinaryJoinTreeConverter
CBinaryJoinTreeConverterDefault
CBinSearchTree	A generic binary search tree
CBinSearchTreeIterator	A Generic binary search tree
CBinTreeNode	Nodes of a binary trees
CBNdistance
CBNReader	Pure virtual class for reading a BN from a file
CBNWriter	Virtual class for writing a BN to a file
CCausalFormula	A container for an identified causal query
CCausalImpact	Builds a CausalFormula for a query (d-sep -> backdoor -> frontdoor -> (optional) do-calculus)
CCausalModel	A causal model pairing a causal DAG with an optional observational BayesNet
CChi2	Static math utilities for the chi2 distribution
CChi2TestPolicy	<agrum/base/multidim/core/testPolicy/Chi2TestPolicy.h>
CChiSquare	<agrum/FMDP/learning/core/testPolicy/chiSquare.h>
CCliqueGraph	Basic graph of cliques
C_RunningIntersect_	Structure used for the computation of the running intersection property
CCNFWriter	Writes a IBayesNet in the BN format
CCompleteProjectionRegister4MultiDim	A container for registering complete projection functions on multiDimImplementations, i.e., functions projecting tables over all their variables
CCompleteProjections4MultiDimInitialize	Class used to register complete projections over non-pointers types
CCompleteProjections4MultiDimInitialize< GUM_ELEMENT * >	Class used to register complete projections over pointers types
CComposedLeaf	<agrum/FMDP/learning/datastructure/leaves/composedLeaf.h>
CConcreteLeaf	<agrum/FMDP/learning/datastructure/leaves/concreteLeaf.h>
CContextualDependenciesCNFWriter	<agrum/BN/io/cnf/ContextualDependenciesCNFWriter.h>
CContingencyTable	<agrum/FMDP/learning/core/contingencyTable.h>
CContinuousVariable	Defines a continuous random variable
CCounterfactual	Computes a counterfactual distribution by building a twin model, then evaluating a causal effect on that twin and adapting the result back to the original model’s variables
CDAG	Base class for dag
CDAGCycleDetector	A class for detecting directed cycles in DAGs when trying to apply many changes to the graph
CChange	Base class indicating the possible changes
CArcAdd	Class to indicate that we wish to add a new arc
CArcDel	Class to indicate that we wish to remove an arc
CArcReverse	Class to indicate that we wish to reverse an arc
CDAGmodel	Virtual base class for PGMs using a DAG
CDecisionTensor	<agrum/ID/inference/decisionTensor.h>
CDefaultEliminationSequenceStrategy	An efficient unconstrained elimination sequence algorithm
CDefaultJunctionTreeStrategy	An algorithm producing a junction given the elimination tree produced by a triangulation algorithm
CDefaultPartialOrderedEliminationSequenceStrategy	An Elimination sequence algorithm that imposes a given partial ordering on the nodes elimination sequence
CDefaultTriangulation	The default triangulation algorithm used by aGrUM
CDiGraph	Base class for all oriented graphs
CDiGraphListener	Abstract Base class for all diGraph Listener
CDirichlet	A class for sampling w.r.t
CDiscreteGraphicalModel	<agrum/base/graphicalModels/discreteGraphicalModel.h>
CDiscreteVariable	Base class for discrete random variable
CDiscretizedVariable	Class for discretized random variable
CDoCalculus	Instance-based do-calculus utilities bound to a single CausalModel
CDoorCriteria	Implements Backdoor and Frontdoor criteria utilities for a DAG
CdSeparationAlgorithm	D-separation algorithm as described in Koller & Friedman (2009)
CDSLReader	Pure virtual class for reading a BN from a file
CDSLWriter	Writes a IBayesNet in the DSL format
CdummyHash
CE_GreedyDecider	<agrum/FMDP/decision/E_GreedyDecider.h>
CEdge	The base class for all undirected edges
CEdgeGraphPart	Classes for undirected edge sets
CEliminationSequenceStrategy	The base class for all elimination sequence algorithms used by triangulation algorithms
CErrorsContainer	This class is used contain and manipulate gum::ParseError
CEssentialGraph	Class building the essential graph from a BN
CEstimator
CEvidenceInference	<agrum/BN/inference/evidenceInference.h>
CEvidenceMRFInference	<agrum/MRF/inference/evidenceMRFInference.h>
CExactBNdistance	ExactBNdistance computes exactly the KL divergence betweens 2 BNs
CExactPolicy	Class implementing exact approximation policy (meaning a value is approximate to itself)
CExactTerminalNodePolicy	Implementation of a Terminal Node Policy that maps nodeid directly to value
CException	Base class for all aGrUM's exceptions
CFactorisedValuesCNFWriter	<agrum/BN/io/cnf/FactorisedValuesCNFWriter.h>
CFactorySimulator	A class to simulate the Factory problem
CFixedAllocator	Allocates objects of one given size
C_Chunk_	Allocates objects of one given size
CFMDP	This class is used to implement factored decision process
CFMDPDatReader	Definition of templatized reader of FMDPDat files for Factored Markov Decision Processes
CFMDPFactory	A factory class to ease Factored Markov Decision Process construction
CFMDPLearner
CFMDPReader	Pure virtual class for reading a FMDP from a file
CFMDPSimulator	<agrum/FMDP/simulation/fmdpSimulator.h>
CFormula	Evaluates a string as a algebraic formula
CFormulaPart	Represents part of a formula
CFusionContext	<agrum/FMDP/learning/datastructure/leaves/fusionContext.h>
CGammaLog2	The class for computing Log2 (Gamma(x))
CGeneralizedCNFWriter	<agrum/BN/io/cnf/GeneralizedCNFWriter.h>
CGibbsBNdistance	GibbsKL computes the KL divergence betweens 2 BNs using an approximation pattern: GIBBS sampling
CGibbsOperator	Class containing all variables and methods required for Gibbssampling
CGibbsSampling	<agrum/BN/inference/gibbsSampling.h>
CGraphicalModel	Virtual base class for probabilistic graphical models
CGraphicalModelInference	<agrum/base/graphicalModels/graphicalModel.h>
CGTestPolicy	<agrum/base/multidim/core/testPolicies/GTestPolicy.h>
CGumBNReader
CGumBNWriter	Writes a IBayesNet in the GUM json format
CGumIDReader	Reads an InfluenceDiagram from a GUM (json) file
CGumIDWriter	Writes an InfluenceDiagram in the GUM json format
CGumMRFReader	Reads a MarkovRandomField from a GUM (json) file
CGumMRFWriter	Writes a MarkovRandomField in the GUM json format
CHashFunc	This class should be useless as only its specializations should be used
CHashFunc< bool >	Hash function for booleans
CHashFunc< credal::lp::LpCol >
CHashFunc< Debug >	Hash function for gum::Debug
CHashFunc< double >	Hash function for doubles
CHashFunc< float >	Hash function for floats
CHashFunc< Instantiation >	Hash function for gum::Instantiation
CHashFunc< int >	Hash function for integers
CHashFunc< learning::ArcAddition >	Hash function for Arc Additions
CHashFunc< learning::ArcDeletion >	Hash function for Arc Deletions
CHashFunc< learning::ArcReversal >	Hash function for Arc Reversals
CHashFunc< learning::ArcTriangleDeletion1 >	Hash function for Arc Triangle Deletions creating a v-structure in node 1
CHashFunc< learning::ArcTriangleDeletion2 >	Hash function for Arc Triangle Deletions creating a v-structure in node 2
CHashFunc< learning::EdgeAddition >	Hash function for Edge Additions
CHashFunc< learning::EdgeDeletion >	Hash function for Edge Deletions
CHashFunc< learning::GraphChange >	Hash function for Graph Changes
CHashFunc< learning::IdCondSet >	Hash function for idSets
CHashFunc< long >	Hash function for long integers
CHashFunc< Set< T > >	Hash function for sets of int
CHashFunc< std::pair< Key1, Key2 > >
CHashFunc< std::shared_ptr< Type > >	Hash function for shared pointers
CHashFunc< std::string >	Hash function for strings
CHashFunc< std::tuple< unsigned int, unsigned int, unsigned int > >	Hash function for tuple (unsigned int, unsigned int,unsigned int)
CHashFunc< std::vector< Idx > >	Hash function for vectors of gum::Idx
CHashFunc< Type * >	Hash function for pointers
CHashFunc< typename HashFuncConditionalType< std::size_t, unsigned long, unsigned int, long, int >::type >	Hash function for std::size_t
CHashFunc< unsigned int >	Hash function for unsigned integers
CHashFunc< unsigned long >	Hash function for unsigned long integers
CHashFuncBase	All hash functions should inherit from this class
CHashFuncCastKey	Generic hash functions for keys castable as Size whose size is either smaller than Size, or equal to that of one or two Size
CHashFuncConditionalType	This class enables to safely define hash functions for types that may or may not already has defined hash functions
CHashFuncConditionalType< Key >
CHashFuncConditionalType< KEY_TYPE, FIRST_TYPE, OTHER_TYPES... >
CHashFuncConditionalType< KEY_TYPE, TYPE >
CHashFuncConst	Useful constants for hash functions
CHashFuncLargeCastKey	Generic hash functions for keys castable as Size and whose size is precisely twice that of Size
CHashFuncMediumCastKey	Generic hash functions for keys castable as Size and whose size is precisely that of Size
CHashFuncSmallCastKey	Generic hash functions for keys castable as Size and whose size is strictly smaller than that of Size
CHashFuncSmallKey	Generic hash functions for numeric keys smaller than or equal to Size
CHashTable	The class for generic Hash Tables
CHashTableBucket	A recipient for a pair of key value in a gum::HashTableList
CHashTableConst	Parameters specifying the default behavior of the hashtables
CHashTableConstIteratorSafe	Safe Const Iterators for hashtables
CHashTableList	A chained list used by gum::HashTable
CHeap	Heap data structure
CIApproximationSchemeConfiguration	Approximation Scheme
CIBayesNet	Class representing the minimal interface for Bayesian network with no numerical data
CIBayesNetFactory	IBayesNetFactory is the non-template interface for BayesNetFactory : many ways to build a BN do not depend on the specification of the GUM_SCALAR template argument (for instance for BN readers)
CIBayesNetGenerator	Class for generating Bayesian networks
CIContinuousVariable	A base class for continuous variables, independent of the GUM_SCALAR type
CIDecisionStrategy	<agrum/FMDP/SDyna/IDecisionStrategy.h>
CIDiscretizedVariable	A base class for discretized variables, independent of the ticks type
CIDReader	Pure virtual class for importing an ID from a file
CIDWriter	Pure virtual class for exporting an ID
CILearningStrategy	<agrum/FMDP/SDyna/ILearningStrategy.h>
CIMarkovRandomField	Class representing the minimal interface for Markov random field
CIMDDI
CImportanceSampling
CIncrementalGraphLearner	<agrum/FMDP/learning/datastructure/incrementalGraphLearner>
CIncrementalTriangulation	Class that performs incremental triangulations
CIndexedTree	The class for storing the nodes of the Arborescence
CInfluenceDiagram	Class representing an Influence Diagram
CInfluenceDiagramGenerator	<agrum/ID/generator/influenceDiagramGenerator.h>
CInfluenceDiagramInference	<agrum/ID/inference/influenceDiagramInference.h>
CInformationTheory	InformationTheory is a template class which aims at gathering the implementation of informational functions (entropy, mutual information, etc.)
CInstantiation	Class for assigning/browsing values to tuples of discrete variables
CInt2Type
CIntegerVariable	Class IntegerVariable
CInternalNode	Structure used to represent a node internal structure
CIOperatorStrategy	<agrum/FMDP/SDyna/IOperatorStrategy.h>
CIPlanningStrategy	<agrum/FMDP/SDyna/IPlanningStrategy.h>
CIScheduleMultiDim	The Table-agnostic base class of scheduleMultiDim
CITerminalNodePolicy	Interface specifying the methods to be implemented by any TerminalNodePolicy
CITestPolicy	<agrum/base/multidim/core/testPolicies/ITestPolicy.h>
CIThreadNumberManager
CITI	Learn a graphical representation of a function as a decision tree
CIVisitableGraphLearner	<agrum/FMDP/SDyna/IVisitableGraphLearner.h>
CJointTargetedInference	<agrum/BN/inference/jointTargetedInference.h>
CJointTargetedMRFInference	<agrum/MRF/inference/jointTargetedMRFInference.h>
CJunctionTreeStrategy	Base Class for all the algorithms producing a junction given a set of cliques/subcliques resulting from a triangulation
CKTBN	Class representing a k-order dynamic Bayesian network (k-DBN)
CKTBNGenerator	Draws a random k-DBN template (structure and, optionally, CPTs)
C_Arc_	A (tail, head) endpoint pair, each as (base, slice)
CKTBNInference	Exact inference on a gum::KTBN with observations and interventions, by the interface algorithm
C_Series_	A cached marginal time-series for one base: owned variable descriptors paired with their marginals, indexed by slice (single entry for an atemporal base). Descriptors are owned so tensors get a stable per-slice name rather than the reused ring-slot name they came from
C_Slot_	One node of a window template: a base (index into baseNames) at a lag behind the window's current slice. lag == ATEMPORAL marks an atemporal base, which sits in every interface and never ages
C_Window_	A compiled window: the junction tree of \(H_t = I_{t-1} \cup V_t\), rooted at the clique holding \(I_t\), plus everything needed to fill and message-pass it. Built once; windows 0..k-2 are the initial ones, window k-1 is the repeating one, re-entered from slice k-1 on
CKTBNModality	A parent's value in gum::KTBN::fillCPT(): a modality index or a modality label
CLabelizedVariable	Class LabelizedVariable
CLazyDecider	Class to make decision randomly
CLazyPropagation	Implementation of a Shafer-Shenoy's-like version of lazy propagation for inference in Bayesian networks
CLeafAggregator	<agrum/FMDP/learning/FunctionGraph/leafAggregator.h>
CLeafPair	<agrum/FMDP/learning/datastructure/leaves/leafPair.h>
CLearnerSelect
CLearnerSelect< ITILEARNER, A, B >
CLeastSquareTestPolicy	<agrum/base/multidim/core/testPolicy/leastSquareTestPolicy.h>
CLinearApproximationPolicy	Class implementing linear approximation policy (meaning possible value are split out in interval)
CLink	Link of a chain list allocated using the SmallObjectAllocator
CLinkedList	Chain list allocated using the SmallObjectAllocator
CList	Generic doubly linked lists
CListBucket	Bucket for a chained list
CListConstIterator	Unsafe but fast const iterators for Lists
CListConstIteratorSafe	Safe const iterators for Lists
CListener	Every class who would catch signal from signaler should derive from Listener
CListIterator	Unsafe but fast iterators for Lists
CListIteratorSafe	Safe iterators for Lists
CLoopyBeliefPropagation	<agrum/BN/inference/loopyBeliefPropagation.h>
CLoopySamplingInference	<agrum/BN/inference/loopySamplingInference.h>
CMarginalTargetedInference	<agrum/BN/inference/marginalTargetedInference.h>
CMarginalTargetedMRFInference	<agrum/MRF/inference/marginalTargetedMRFInference.h>
CMarkovBlanket	Class building the markov Blanket from a BN and a nodeName
CMaximizes	Maximization function object class
CMaxInducedWidthMCBayesNetGenerator	MaxInducedWidthMCBayesNetGenerator.h <agrum/BN/generator/SimpleMCayesNetGenerator.h>
CMaxParentsMCBayesNetGenerator	<agrum/BN/generator/SimpleMCayesNetGenerator.h>
CMCBayesNetGenerator	<agrum/BN/generator/MCayesNetGenerator.h>
CMCBNDistance	MCBNDistance computes the KL divergence betweens 2 BNs using an approximation pattern: independent (forward/topological) Monte Carlo sampling
CMDDOperatorStrategy	<agrum/FMDP/planning/mddOperatorStrategy.h>
CMeekRules	Applies Meek's orientation rules to propagate arc directions in a mixed graph
CMinimizes	Minimization function object class
CMixedGraph	Base class for mixed graphs
CMixedGraphListener	Abstract Base class for all mixed Graph Listener
CMonteCarloSampling
CMRFInference	<agrum/MRF/inference/MRFInference.h>
CMRFReader	Pure virtual class for reading a MRF from a file
CMRFWriter	Pure virtual class for writing a MRF to a file
CMultiDimAdressable	Abstract base class for all multi dimensionnal addressable
CMultiDimArray	Multidimensional matrix stored as an array in memory
CMultiDimBijArray	Decorator of a MultiDimArray, using a bijection over the variables
CMultiDimBucket	A multidim implementation for buckets
CMultiDimCombination	A generic interface to combine efficiently several MultiDim tables
CMultiDimCombinationDefault	A class to combine efficiently several MultiDim tables
CMultiDimCombineAndProject	A generic interface to combine and project efficiently MultiDim tables
CMultiDimCombineAndProjectDefault	An efficient class for combining and projecting MultiDim tables
CMultiDimCompleteProjection	A generic class to project efficiently a MultiDim table over all of its variables
CMultiDimContainer	Abstract base class for all multi dimensionnal containers
CMultiDimDecorator	Decorator design pattern in order to separate implementations from multidimensional matrix concepts
CMultiDimFunctionGraph	Class implementingting a function graph
CMultiDimFunctionGraphGenerator	Class implementing a function graph generator with template type double
CMultiDimFunctionGraphManager	Class implementingting a function graph manager
CMultiDimFunctionGraphOperator	Class used to perform Function Graph Operations
CMultiDimFunctionGraphProjector	Class used to perform Function Graph projections
CMultiDimFunctionGraphROManager
CMultiDimFunctionGraphTreeManager
CMultiDimICIModel	Abstract class for Conditional Indepency Models
CMultiDimImplementation	<agrum/base/multidim/multiDimImplementation.h>
CMultiDimInterface	Interface for all classes addressing in a multiDim fashion
CMultiDimLogit	Logit representation
CMultiDimNoisyAND	Noisy AND representation
CMultiDimNoisyORCompound	Noisy OR representation
CMultiDimNoisyORNet	Noisy OR representation
CMultiDimPartialInstantiation	A generic class to instantiate a subset of variables of a multidimensional table
CMultiDimProjection	A generic class to project efficiently a MultiDim table over a subset of its variables
CMultiDimReadOnly	Abstract base class for all multi dimensionnal read only structure
CMultiDimSparse	Multidimensional matrix stored as a sparse array in memory
CMultiDimWithOffset	Abstract class for Multidimensional matrix stored as an array in memory and with an offset associated with each slave instantiation
CMultiPriorityQueue	A MultiPriorityQueue is a heap in which each element has a mutable priority and duplicates are allowed
CNetReader	Pure virtual class for reading a BN from a file
CNetWriter	Writes a IBayesNet in the BN format
CNodeDatabase	<agrum/FMDP/learning/datastructure/nodeDatabase.h>
CNodeGraphPart	Class for node sets in graph
CNodeGraphPartIterator	Unsafe iterator on the node set of a graph
CNodeGraphPartIteratorSafe	Safe iterator on the node set of a graph
CNumericalDiscreteVariable	Class NumericalDiscreteVariable
CO3prmBNReader	Read an O3PRM and transform the gum::prm::PRMSystem into gum::BayesNet
CO3prmBNWriter	<agrum/PRM/o3prm/O3prmBNWriter.h>
CO4DGContext	Class used to manipulate context during Function Graph Operations
CObservation
COperatorRegister4MultiDim	A container for registering binary functions on multiDimImplementations
COperators4MultiDimInitialize	Class used to register operators over non-pointers types
COperators4MultiDimInitialize< GUM_ELEMENT * >	Class used to register operators over pointers types
Coptional_ref	A lightweight wrapper around a pointer providing an optional-like API for references (not supported by std::optional<T&>)
COrderedEliminationSequenceStrategy	An Elimination sequence algorithm that imposes a given complete ordering on the nodes elimination sequence
COrderedTriangulation	Class for graph triangulations for which we enforce a given complete ordering on the nodes eliminations
CPAG	Partial Ancestral Graph: undirected topology with endpoint marks
CParent	Represent a node's parent
CParseError	This class is used to represent parsing errors for the different parser implemented in aGrUM
CPartialInstantiation4MultiDimInitialize	A class used to register instantiation functions over non-pointers types
CPartialInstantiation4MultiDimInitialize< GUM_ELEMENT * >
CPartialInstantiationRegister4MultiDim	A container for registering partial instantiation functions on multiDimImplementations, i.e., functions assigning values to subsets of the variables of some tables
CPartialOrderedEliminationSequenceStrategy	Base class for all elimination sequence algorithm that impose a given partial ordering on the nodes elimination sequence, that is, the set of all the nodes is divided into several subsets
CPartialOrderedTriangulation	Class for graph triangulations for which we enforce a given partial ordering on the nodes eliminations, that is, the set of all the nodes is divided into several subsets
CPDAG	Base class for partially directed acyclic graphs
CPriorityQueue	A priorityQueue is a heap in which each element has a mutable priority
CPriorityQueueImplementation	The internal class for representing priority queues
CProgressListener	The ProgressListener class
CProgressNotifier	Notification for progress using listener
CProjectionRegister4MultiDim	A container for registering projection functions on multiDimImplementations, i.e., functions projecting tables over a subset of their variables
CProjections4MultiDimInitialize	Class used to register projections over non-pointers types
CProjections4MultiDimInitialize< GUM_ELEMENT * >	Class used to register projections over pointers types
CRandomDecider	Class to make decision randomly
CRangeVariable	Defines a discrete random variable over an integer interval
CRational	Class template used to approximate decimal numbers by rationals
CRegress	Class used to perform Function Graph Operations in the FMDP Framework
CSamplingInference	<agrum/BN/inference/samplingInference.h>
CSchedule	Class containing a schedule of operations to perform on multidims
CScheduleBinaryCombination	Binary Combination operator class used for scheduling inferences
CScheduledInference	Class containing the scheduler used by schedule-based inferences
CScheduleMultiDim	Wrapper for multi-dimensional tables used for scheduling inferences
CElementType	Metaprogramming to get the types of the elements stored into the ScheduleMultidims
CElementType< CONTAINER< T, Args... > >
CScheduleOperator	Base class for "low-level" operators used to schedule inferences
CScheduleProjection	Projection operator class used for scheduling inferences
CScheduler	The common interface of all the schedulers
CSchedulerParallel	A scheduler that executes available operators in parallel
CSchedulerSequential
CUnexecutedOperation	Structure to keep informations about operations that could not be executed due to memory usage limitations
CScheduleStorage	Class for storing multidimensional tables into containers (sets, etc.)
CSDYNA	The general SDyna architecture abstract class
CSeparation	Consolidated d-separation utilities (DAG-centric)
CSequence	The generic class for storing (ordered) sequences of objects
CSequenceImplementation	The internal class for storing (ordered) sequences of objects
CSequenceIteratorSafe	Safe iterators for Sequence
CSet	Representation of a set
CSetInst	Class for assigning/browsing values to tuples of discrete variables
CSetIterator	Unsafe iterators for the Set class
CSetIteratorSafe	Safe iterators for the Set class
CSetTerminalNodePolicy	Implementation of a Terminal Node Policy that maps nodeid to a set of value
CShaferShenoyInference	Implementation of Shafer-Shenoy's propagation algorithm for inference in Bayesian networks
CShaferShenoyLIMIDInference
CShaferShenoyMRFInference	<agrum/MRF/inference/ShaferShenoyMRFInference.h>
CSignaler	Variadic template signaler for any number of arguments
CSimpleBayesNetGenerator	<agrum/BN/generator/simpleBayesNetGenerator.h>
CSimpleCPTDisturber	<agrum/BN/generator/simpleCPTDisturber.h>
CSimpleCPTGenerator	<agrum/BN/generator/simpleCPTGenerator.h>
CSimpleUTGenerator	Class for generating Utility Tables
CSimplicialSet	Class enabling fast retrieval of simplicial, quasi and almost simplicial nodes
CSmallObjectAllocator	<agrum/base/core/smallObjectAllocator.h>
CSortedPriorityQueue	A priority queue in which we can iterate over the elements from the top to bottom or conversely
CSortedPriorityQueueIterator	Sorted priority queue iterator
CSortedPriorityQueueIteratorSafe	Sorted priority queues safe (w.r.t
CSortedPriorityQueueReverseIterator	Sorted priority queue reverse iterator
CSortedPriorityQueueReverseIteratorSafe	Sorted priority queue safe (w.r.t
CSpanningForest	Base class for computing min cost spanning trees or forests
CSpanningForestPrim	The Prim algorithm for computing min cost spanning trees or forests
CSplayBinaryNode	Nodes of splay trees
CSplayTree	A splay tree
CStatesChecker	<agrum/FMDP/simulation/statesChecker.h>
CStatesCounter	<agrum/FMDP/simulation/statesCounter.h>
CStaticTriangulation	Base class for all non-incremental triangulation methods
CStatisticalLazyDecider	<agrum/FMDP/decision/statisticalLazyDecider.h>
CStructuralMetrics	A class for comparing graphs based on their structures
CStructuredPlaner	<agrum/FMDP/planning/structuredPlaner.h>
CTaxiSimulator	A class to simulate the Taxi problem
CTensor	AGrUM's Tensor is a multi-dimensional array with tensor operators
CTestSelect
CTestSelect< CHI2TEST, A, B, C >
CTestSelect< LEASTSQUARETEST, A, B, C >
CThreadData	A wrapper that enables to store data in a way that prevents false cacheline sharing
CThreadExecutorBase	Set the max number of threads to be used
CThreadNumberManager	A class to manage the number of threads to use in an algorithm
CTimer	Class used to compute response times for benchmark purposes
CTreeOperator	Class used to perform Decision Tree Operation in the FMDP Framework
CTreeOperatorStrategy	<agrum/FMDP/planning/treeOperatorStrategy.h>
CTreeRegress	Class used to perform Decision Tree Regression in the FMDP Framework
CTriangulation	Interface for all the triangulation methods
CUAIBNReader	Pure virtual class for reading a BN from a file
CUAIBNWriter	Writes a Bayes net in a text file with UAI format
CUAIMRFReader	Pure virtual class for reading a MRF from a file
CUAIMRFWriter	<agrum/MRF/io/UAI/UAIMRFWriter.h>
CUGmodel	Virtual base class for PGMs using a undirected graph
CUnconstrainedEliminationSequenceStrategy	The base class for all elimination sequence algorithms that require only the graph to be triangulated and the nodes' domain sizes to produce the node elimination ordering
CUnconstrainedTriangulation	Interface for all triangulation methods without constraints on node elimination orderings
CUndiGraph	Base class for undirected graphs
CUndiGraphListener	Abstract Base class for all undiGraph Listener
CUTGenerator	Abstract class for generating Utility Tables
CValueSelect
CValueSelect< false, A, B >
CVariable	Base class for every random variable
CVariableElimination	Implementation of a Variable Elimination's-like version of lazy propagation for inference in Bayesian networks
CVariableLog2ParamComplexity	Class for computing the log2 of the parametric complexity of an r-ary multinomial variable
CVariableNodeMap	Container used to map discrete variables with nodes
CVariableSelector	<agrum/FMDP/planning/FunctionGraph/variableselector.h>
CWeightedSampling
CXDSLBNReader	<agrum/BN/io/XDSL/XDSLBNReader.h>
CXDSLBNWriter	<agrum/BN/io/XDSLXML/XDSLBNWriter.h>
CXmlDocument	An XML document, opaque over ticpp::Document
CImpl
CXmlElement	A non-owning handle to an XML element, opaque over ticpp::Element
CXmlException	Thrown by XmlDocument/XmlElement on any ticpp/tinyxml parse or access error
Nstd	STL namespace
C_auxiliary_print_tuple_
CAbstractScheduleMultiDim	Exception : The Schedule MultiDim Table is abstract
CAPPROX
CArgumentError	Exception base for argument error
CBNGumReader	Class for reading a Bayesian network from a GUM (json) file
CCPTError	Exception base for CPT error
CDatabaseError	Error: An unknown error occurred while accessing a database
CDefaultInLabel	Exception : default in label
CDuplicateElement	Exception : a similar element already exists
CDuplicateLabel	Exception : a similar label already exists
CDuplicateScheduleMultiDim	Exception : There exists another identical Schedule MultiDim Table
CEstimator	Class for estimating tools for approximate inference
CFactoryError	Exception base for factory error
CFactoryInvalidState	Exception : invalid state error
CFatalError	Exception : fatal (unknown ?) error
CFormatNotFound	Exception : a I/O format was not found
CGraphError	Exception base for graph error
CHashTableConstIterator	Unsafe Const Iterators for hashtables
CHashTableIterator	Unsafe Iterators for hashtables
CHashTableIteratorSafe	Safe Iterators for hashtables
CHedgeException	Exception : "hedge" (witness of non-identifiability) is detected in do-calculus / ID computations
CImportanceInference	<agrum/BN/inference/importanceInference.h>
CIncompatibleEvidence	Exception : several evidence are incompatible together (proba=0)
CIncompatibleScorePrior	Error: The score already contains a different 'implicit' prior
CInvalidArc	Exception : there is something wrong with an arc
CInvalidArgument	Exception: at least one argument passed to a function is not what was expected
CInvalidArgumentsNumber	Exception: the number of arguments passed to a function is not what was expected
CInvalidDirectedCycle	Exception : existence of a directed cycle in a graph
CInvalidEdge	Exception : there is something wrong with an edge
CInvalidNode	Exception : node does not exist
CIOError	Exception : input/output problem
CKL	KL is the base class for KL computation betweens 2 BNs
CLearningError	Exceptions for learning
CMissingValueInDatabase	Error: The database contains some missing values
CMissingVariableInDatabase	Error: A name of variable is not found in the database
CMonteCarloInference	<agrum/BN/inference/monteCarloInference.h>
CNoChild	Exception : no child for a given node was found
CNoNeighbour	Exception : no neighbour to a given node was found
CNoParent	Exception : no parent for a given node was found
CNotFound	Exception : the element we looked for cannot be found
CNotImplementedYet	Exception : there is something wrong with an implementation
CNullElement	Exception : a pointer or a reference on a nullptr (0) object
COperationNotAllowed	Exception : operation not allowed
COutOfBounds	Exception : out of bound
CPossiblyIncompatibleScorePrior	Error: Due to its weight, the prior is currently compatible with the score but if you change the weight, it will become incompatible"
CPRMAggregate	Defines an aggregate in a PRM
CPRMTypeError	Exception : wrong subtype or subclass
CScheduleMultiDimError	Exception base for ScheduleMultiDim errors
CScheduleOperationError	Exception base for ScheduleOperator errors
CScoreMDL	Class for computing MDL scores
CSizeError	Exception : problem with size
CSyntaxError	Special exception for syntax errors in files
CThreadExecutor	The class enables to uses openMP to execute callables in parallel
CThreadExecutor	The class enables to launch std::threads to execute callables in parallel
CTypeError	Exception : wrong type for this operation
CUnavailableScheduleOperation	Exception : The Schedule Operation is not available yet
CUndefinedElement	Exception : a looked-for element could not be found
CUndefinedIteratorKey	Exception : iterator does not point to any valid key
CUndefinedIteratorValue	Exception : generic error on iterator
CUnexecutedScheduleOperation	Exception : The Schedule Operation has not been executed yet
CUnknownLabelInDatabase	Error: An unknown label is found in the database
CUnknownScheduleMultiDim	Exception : The Schedule MultiDim Table is unknown
CUnknownScheduleOperation	Exception : The Schedule Operation is unknown
CWeightedInference	<agrum/BN/inference/weightedInference.h>
CWrongClassElement	Exception: wrong PRMClassElement for this operation