 |
aGrUM
0.20.3
a C++ library for (probabilistic) graphical models
|
|
aGrUM
0.20.3
a C++ library for (probabilistic) graphical models
|
| ►Ngum | Copyright (c) 2005-2021 by Pierre-Henri WUILLEMIN() & Christophe GONZALES() info_at_agrum_dot_org |
| ►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/tools/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 |
| CLpCol | Class representing a variable ( a column ) of a linear program, i.e |
| CLpExpr | Class representing a linear expression |
| CLpInterface | Class representing a linear program |
| 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 | |
| C_GraphChangesGenerator4K2_ | |
| CApriori | Base class for all a priori |
| CAprioriBDeu | Internal apriori for the BDeu score (N' / (r_i * q_i)BDeu is a BD score with a N'/(r_i * q_i) apriori, where N' is an effective sample size and r_i is the domain size of the target variable and q_i is the domain size of the Cartesian product of its parents |
| CAprioriBDeuType | |
| CAprioriDirichletFromDatabase | A dirichlet priori: computes its N'_ijk from a database |
| CAprioriDirichletType | |
| CAprioriK2 | Internal apriori for the K2 score = Laplace AprioriK2 is a BD score with a Laplace apriori (i.e., a smoothing of 1) |
| CAprioriNoApriori | No a priori class: corresponds to 0 weight-sample |
| CAprioriNoAprioriType | |
| CAprioriSmoothing | Smooth a priori: adds a weight w to all the countings |
| CAprioriSmoothingType | |
| CArcAddition | The class for notifying learning algorithms of new arc additionsThis class is convenient to know at compile time which graph change we are dealing with |
| CArcDeletion | The class for notifying learning algorithms of arc removalsThis class is convenient to know at compile time which graph change we are dealing with |
| CArcReversal | The class for notifying learning algorithms of arc reversalsThis class is convenient to know at compile time which graph change we are dealing with |
| 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 |
| CCorrectedMutualInformation | The class computing n times the corrected mutual information, as used in the 3off2 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 |
| 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 |
| CDBTranslator4LabelizedVariable | The databases' cell translators for labelized variables |
| CDBTranslator4RangeVariable | The databases' cell translators for range variables |
| CDBTranslatorSet | Class for packing together the translators used to preprocess the datasets |
| CEdgeAddition | The class for notifying learning algorithms of new edge additionsThis class is convenient to know at compile time which graph change we are dealing with |
| CEdgeDeletion | The class for notifying learning algorithms of edge removalsThis class is convenient to know at compile time which graph change we are dealing with |
| ►CgenericBNLearner | A pack of learning algorithms that can easily be used |
| CDatabase | Helper to easily read databases |
| 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) |
| ►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< ALLOC, false > | |
| CIDatabaseTableInsert4DBCell< ALLOC, 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 | |
| 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 |
| CKNML | Class for computing the NML penalty used by 3off2 |
| CLocalSearchWithTabuList | The local search with tabu list learning algorithm (for directed graphs) |
| CMiic | The miic learning algorithm |
| CParamEstimator | The base class for estimating parameters of CPTs |
| CParamEstimatorML | The class for estimating parameters of CPTs using Maximum Likelihood |
| CPseudoCount | The class for giving access to pseudo count : count in the database + prior |
| CRawDatabaseTable | The table containing the raw/original data of a databaseClass RawDatabaseTable is intended to store in RAM the raw/original data of a database |
| CRecordCounter | The class that computes countings 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 resultsCaching previously computed scores or the results of conditional independence tests is very important for learning algorithms because computing a score or an independence test requires parsing the database and this is the most time consuming operation in learning |
| 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 |
| 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 constraintsIn aGrUM, there are two ways to store sets of structural constraints: the first one is to put them into a StructuralConstraintSetDynamic |
| 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 |
| 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 |
| CNeighborDegreeSort | This is used to generate the max_indep_set of a Pattern |
| CPatternData | |
| 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 |
| CRefConstIterator | Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations |
| CRefIterator | 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> |
| CCData | Private structure to represent data about a Class<GUM_SCALAR> |
| CPData | Private structure to represent data about a pattern |
| CRGData | Private structure to represent data about a reduced graph |
| 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> |
| 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 edgesThis class is used as a basis for manipulating all directed edges (i.e., edges in which the order of the nodes is meaningful) |
| CArcGraphPart | Classes for directed edge sets |
| CArgMaxSet | Class to handle efficiently argMaxSet |
| CArgumentMaximises | Arg Max function object class |
| CArgumentMaximisesAction | <agrum/FMDP/planning/actionSet.h> |
| 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 formatThis class export an influence diagram into an XML files, using BIF format See http://www-2.cs.cmu.edu/afs/cs/user/fgcozman/www/Research/InterchangeFormat/ for information about this 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 |
| CBijectionIteratorStaticEnd | A class which creates the static iterator used by gim::Bijections |
| 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 | Pure virtual class for writting a BN to a file |
| CChi2 | Represent the chi2 distribution |
| CChi2TestPolicy | <agrum/tools/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 typesThis class is of course completely redundant with function completeProjections4MultiDimInit |
| CCompleteProjections4MultiDimInitialize< GUM_SCALAR *> | Class used to register complete projections over pointers typesThis class is of course completely redundant with function pointerCompleteProjections4MultiDimInit |
| 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 |
| CCPTError | |
| CCPTNoSumTo1 | |
| CDAG | Base class for dag |
| ►CDAGCycleDetector | A class for detecting directed cycles in DAGs when trying to apply many changes to the graph |
| 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 |
| CChange | Base class indicating the possible changes |
| CDAGmodel | Virtual base class for PGMs using a DAG |
| CDatabaseError | |
| CDecisionPotential | <agrum/ID/inference/decisionPotential.h> |
| CDefaultEliminationSequenceStrategy | An efficient unconstrained elimination sequence algorithm |
| CDefaultInLabel | |
| 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 |
| CDirectory | Cross-platform directory utility |
| CDirichlet | A class for sampling w.r.t |
| CDiscreteVariable | Base class for discrete random variable |
| CDiscretizedVariable | Class for discretized random variable |
| CdSeparation | 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 | |
| CDuplicateElement | |
| CDuplicateLabel | |
| 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 |
| CEmptyBSTree | |
| CEmptySet | |
| 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> |
| CEvidenceMNInference | <agrum/MN/inference/evidenceMNInference.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> |
| CFactoryError | |
| CFactoryInvalidState | |
| CFactorySimulator | A class to simulate the Factory problem |
| CFatalError | |
| ►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> |
| CFormatNotFound | |
| 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> |
| CGraphError | |
| CGraphicalModel | Virtual base class for probabilistic graphical models |
| CGraphicalModelInference | <agrum/tools/graphicalModels/graphicalModel.h> |
| CGTestPolicy | <agrum/tools/multidim/core/testPolicies/GTestPolicy.h> |
| CHashFunc | Class template representing hashing function of LpCol |
| 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::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< ALLOC > > | Hash function for idSets |
| CHashFunc< long > | Hash function for long integers |
| CHashFunc< RefPtr< Type > > | Hash function for RefPtr |
| CHashFunc< Set< T, Alloc > > | Hash function for sets of int |
| CHashFunc< std::pair< Key1, Key2 > > | |
| 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 functionsThere are types that are defined differently depending on the architecture or the compiler you use |
| 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 |
| CHashTableConstIterator | Unsafe Const Iterators for hashtablesHashTableConstIterator provides a fast but unsafe way to parse HashTables |
| CHashTableConstIteratorSafe | Safe Const Iterators for hashtables |
| CHashTableIterator | Unsafe Iterators for hashtablesHashTableIterator provides a fast but unsafe way to parse HashTables |
| CHashTableIteratorSafe | Safe Iterators for hashtables |
| CHashTableIteratorStaticEnd | A class used to create the static iterator used by HashTables |
| CHashTableList | A chained list used by gum::HashTable |
| CHeap | Heap data structureThis structure is a basic heap data structure, i.e., it is a container in which elements are sorted according to a weak ordering |
| CIApproximationSchemeConfiguration | Approximation Scheme |
| CIBayesNet | Class representing the minimal interface for Bayesian network |
| 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> |
| CIdError | |
| 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> |
| CIMarkovNet | Class representing the minimal interface for Markov Network |
| CIMDDI | |
| CImportanceSampling | |
| CIncompatibleEvidence | Exception : several evidence are incompatible together (proba=0) |
| CIncompatibleScoreApriori | |
| 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> |
| CInstantiation | Class for assigning/browsing values to tuples of discrete variables |
| CInt2Type | |
| CInternalNode | Structure used to represent a node internal structure |
| CInvalidArc | |
| CInvalidArgument | |
| CInvalidArgumentsNumber | |
| CInvalidDirectedCycle | |
| CInvalidEdge | |
| CInvalidNode | |
| CIOError | |
| CIOperatorStrategy | <agrum/FMDP/SDyna/IOperatorStrategy.h> |
| CIPlanningStrategy | <agrum/FMDP/SDyna/IPlanningStrategy.h> |
| CITerminalNodePolicy | Interface specifying the methods to be implemented by any TerminalNodePolicy |
| CITestPolicy | <agrum/tools/multidim/core/testPolicies/ITestPolicy.h> |
| CITI | Learn a graphical representation of a function as a decision tree |
| CIVisitableGraphLearner | <agrum/FMDP/SDyna/IVisitableGraphLearner.h> |
| CJointTargetedInference | <agrum/BN/inference/jointTargetedInference.h> |
| CJointTargetedMNInference | <agrum/MN/inference/jointTargetedMNInference.h> |
| CJunctionTreeStrategy | Base Class for all the algorithms producing a junction given a set of cliques/subcliques resulting from a triangulation |
| CLabelizedVariable | Class LabelizedVariable |
| CLazyDecider | Class to make decision randomlyDoes nothing more than the interface for DecisionStrategy does |
| CLazyPropagation | <agrum/BN/inference/lazyPropagation.h> |
| CLeafAggregator | <agrum/FMDP/learning/FunctionGraph/leafAggregator.h> |
| CLeafPair | <agrum/FMDP/learning/datastructure/leaves/leafPair.h> |
| CLearnerSelect | |
| CLearnerSelect< ITILEARNER, A, B > | |
| CLearningError | |
| CLeastSquareTestPolicy | <agrum/tools/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> |
| CMarginalTargetedMNInference | <agrum/MN/inference/marginalTargetedMNInference.h> |
| CMarkovBlanket | Class building the markov Blanket from a BN and a nodeName |
| CMarkovNetInference | <agrum/MN/inference/MarkovNetInference.h> |
| CMaximizes | Maximization function object classReturns the maximum of its two arguments |
| CMaxInducedWidthMCBayesNetGenerator | MaxInducedWidthMCBayesNetGenerator.h <agrum/BN/generator/SimpleMCayesNetGenerator.h> |
| CMaxParentsMCBayesNetGenerator | <agrum/BN/generator/SimpleMCayesNetGenerator.h> |
| CMCBayesNetGenerator | <agrum/BN/generator/MCayesNetGenerator.h> |
| CMDDOperatorStrategy | <agrum/FMDP/planning/mddOperatorStrategy.h> |
| CMinimizes | Minimization function object classReturns the minimum of its two arguments |
| CMissingValueInDatabase | |
| CMissingVariableInDatabase | |
| CMixedGraph | Base class for mixed graphs |
| CMixedGraphListener | Abstract Base class for all mixed Graph Listener |
| CMNReader | Pure virtual class for reading a MN from a file |
| CMNWriter | Pure virtual class for writting a MN to a file |
| CMonteCarloSampling | |
| 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 tablesMultiDimCombinationDefault is a class designed to combine efficiently several multidimensional objects, that is, to compute expressions like T1 op T2 op T3 op ... |
| 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/tools/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 allowedA priority queue is quite similar to a heap except that a priority (a score) is assigned to each element in the structure |
| CNetReader | Pure virtual class for reading a BN from a file |
| CNetWriter | Writes a IBayesNet in the BN format |
| CNoChild | |
| 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 |
| CNoNeighbour | |
| CNoParent | |
| CNotFound | |
| CNotImplementedYet | |
| CNullElement | |
| CNullStream | Implements a stream with the same behaviour as /dev/null |
| 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 | |
| COperationNotAllowed | |
| COperatorRegister4MultiDim | A container for registering binary functions on multiDimImplementations |
| COperators4MultiDimInitialize | Class used to register operators over non-pointers typesThis class is of course completely redundant with function operators4MultiDimInit |
| COperators4MultiDimInitialize< GUM_SCALAR *> | Class used to register operators over pointers typesThis class is of course completely redundant with function pointerOperators4MultiDimInit |
| 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 |
| COutOfBounds | |
| COutOfLowerBound | |
| COutOfUpperBound | |
| 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_SCALAR *> | |
| 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 |
| CPossiblyIncompatibleScoreApriori | |
| CPotential | AGrUM's Potential is a multi-dimensional array with tensor operators |
| CPriorityQueue | A priorityQueue is a heap in which each element has a mutable priorityA priority queue is quite similar to a heap except that a priority (a score) is assigned to each element in the structure |
| CPriorityQueueImplementation | The internal class for representing priority queues |
| CPRMAggregate | Defines an aggregate in a PRM |
| CPRMTypeError | |
| 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_SCALAR *> | Class used to register projections over pointers types |
| CRandomDecider | Class to make decision randomlyDoes nothing more than the interface for DecisionStrategy does |
| CRangeVariable | Defines a discrete random variable over an integer interval |
| CRational | Class template used to approximate decimal numbers by rationals |
| CReferenceError | |
| CRefPtr | Smart pointersaGrUM's smart pointers keep track of the number of times the value they point to is referenced |
| 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 |
| CScheduleCliqueStoreMultiDim | |
| CScheduleCombination | |
| CScheduleCombinationBasic | |
| CScheduleCombine | |
| CScheduleDeleteMultiDim | |
| CScheduleMultiDim | MultiDimImplementation Wrapper used for scheduling inferences |
| CScheduleOperation | |
| CScheduleProject | |
| CScheduleProjection | |
| CScheduleProjectionBasic | |
| CScheduler | |
| CSchedulerBasic | |
| CScheduleSeparatorStoreMultiDim | |
| CSDYNA | The general SDyna architecture abstract class |
| 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 setA Set is a structure that contains arbitrary elements |
| CSetInst | Class for assigning/browsing values to tuples of discrete variables |
| CSetIterator | Unsafe iterators for the Set class |
| CSetIteratorSafe | Safe iterators for the Set classDevelopers may consider using Set<x>::iterator_safe instead of SetIteratorSafe<x> |
| CSetTerminalNodePolicy | Implementation of a Terminal Node Policy that maps nodeid to a set of value |
| CShaferShenoyInference | <agrum/BN/inference/ShaferShenoyInference.h> |
| CShaferShenoyLIMIDInference | |
| CShaferShenoyMNInference | <agrum/MN/inference/ShaferShenoyMNInference.h> |
| CSignaler0 | Class for signal with 0 args |
| 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 |
| CSizeError | |
| CSmallObjectAllocator | <agrum/tools/core/smallObjectAllocator.h> |
| 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> |
| CStructuralComparator | A class for comparing graphs based on their structures |
| CStructuredPlaner | <agrum/FMDP/planning/structuredPlaner.h> |
| CSyntaxError | |
| CTaxiSimulator | A class to simulate the Taxi problem |
| 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 |
| CTimer | Class used to compute response times for benchmark purposesThis class represents a classic timer, it starts in the constructor, you can reset it with method reset() and you can get the delta time with the method step() |
| 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 |
| CTypeError | |
| CUAIBNReader | Pure virtual class for reading a BN from a file |
| CUAIBNWriter | <agrum/BN/io/UAI/UAIBNWriter.h> |
| CUAIMNReader | Pure virtual class for reading a MN from a file |
| CUAIMNWriter | <agrum/MN/io/UAI/UAIMNWriter.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 |
| CUndefinedElement | |
| CUndefinedIteratorKey | |
| CUndefinedIteratorValue | |
| CUndiGraph | Base class for undirected graphs |
| CUndiGraphListener | Abstract Base class for all undiGraph Listener |
| CUnknownLabelInDatabase | |
| CUTGenerator | Abstract class for generating Utility Tables |
| CValueSelect | |
| CValueSelect< false, A, B > | |
| CVariable | Base class for every random variable |
| CVariableElimination | <agrum/BN/inference/variableElimination.h> |
| CVariableLog2ParamComplexity | Class for computing the log2 of the parametric complexity of an r-ary multinomial variableThis class enables to compute the log in base 2 of the parametric complexity of a single r-ary multinomial variable, i.e., the log in base 2 of the C_N^r term used by NML scores in Bayesian network structure learning algorithm (see, e.g., Silander, Roos, Kontkanen and Myllymaki (2007) "Factorized Normalized Maximum " Likelihood Criterion for Learning Bayesian network Structures)" |
| CVariableNodeMap | Container used to map discrete variables with nodes |
| CVariableSelector | <agrum/FMDP/planning/FunctionGraph/variableselector.h> |
| CWeightedSampling | |
| CWrongClassElement | |
| ►Nstd | STL namespace |
| C_auxiliary_print_tuple_ | |
| ►Nticpp | |
| CAttribute | Wrapper around TiXmlAttribute |
| CBase | Wrapper around TiXmlBase |
| CComment | Wrapper around TiXmlComment |
| CDeclaration | Wrapper around TiXmlDeclaration |
| CDocument | Wrapper around TiXmlDocument |
| CElement | Wrapper around TiXmlElement |
| CException | This is a ticpp exception class |
| CIterator | Iterator for conveniently stepping through Nodes and Attributes |
| CNode | Wrapper around TiXmlNode |
| CNodeImp | Implementation of Node wrapper |
| CStylesheetReference | Wrapper around TiXmlStylesheetReference |
| CText | Wrapper around TiXmlText |
| CVisitor | Wrapper around TiXmlVisitor |
| CAPPROX | |
| CEstimator | Class for estimating tools for approximate inference |
| CImportanceInference | <agrum/BN/inference/importanceInference.h> |
| CKL | KL is the base class for KL computation betweens 2 BNs |
| CMonteCarloInference | <agrum/BN/inference/monteCarloInference.h> |
| CScoreMDL | Class for computing MDL scores |
| CTiCppRC | Base class for reference counting functionality |
| CTiCppRCImp | |
| CTiXmlAttribute | An attribute is a name-value pair |
| CTiXmlAttributeSet | |
| ►CTiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| CEntity | |
| CTiXmlComment | An XML comment |
| CTiXmlCursor | |
| CTiXmlDeclaration | In correct XML the declaration is the first entry in the file |
| CTiXmlDocument | Always the top level node |
| CTiXmlElement | The element is a container class |
| CTiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| CTiXmlNode | The parent class for everything in the Document Object Model |
| CTiXmlOutStream | |
| CTiXmlParsingData | |
| CTiXmlPrinter | Print to memory functionality |
| ►CTiXmlString | |
| CRep | |
| CTiXmlStylesheetReference | A stylesheet reference looks like this: |
| CTiXmlText | XML text |
| CTiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| CTiXmlVisitor | If you call the Accept() method, it requires being passed a TiXmlVisitor class to handle callbacks |
| CWeightedInference | <agrum/BN/inference/weightedInference.h> |
|
aGrUM 0.20.3 Mon Jun 7 2021 17:35:08 |
© PHW&CG&others - 2021 | DoXyGeN 1.8.13 |