►Ngum | Gum is the global namespace for all aGrUM entities |
►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/multidim/aggregators/multiDimAggregator.h> |
COr | Or 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 apriori |
CAprioriDirichletFromDatabase | A dirichlet priori: computes its N'_ijk from a database |
CAprioriDirichletType | |
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 |
CCache43ptInfo | |
CCache4IndepTest | |
CCache4PartEntropy | Cache for caching partial entropy in PartEntropy classCaching previously computed scores is very important for learning algorithms because computing a score requires parsing the database and this is the most time consuming operation in learning |
CCache4Score | Cache for caching 3 points mutual information in 3off2Caching previously computed scores is very important for learning algorithms because computing independence tests requires parsing the database and this is the most time consuming operation in learning |
CCorrectedMutualInformation | Class CorrectedMutualInformation, used in the 3off2 algorithm |
CCounter | The counting class for all the scores used for learning (BIC, BDeu, etc) as well as for all the independence tests |
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 |
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 |
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 |
CIdSet | Transforms an unordered set of ids into an (increasingly) ordered one |
CIGraphChangesGenerator4DiGraph | |
CIGraphChangesGenerator4UndiGraph | |
CIndependenceTest | Abstract class for all the independence testsThe class should be used as follows: first, to speed-up computations, you should consider computing all the independence tests you need in one pass |
CIndepTestChi2 | Class for computing Chi2 independence test scoresThe class should be used as follows: first, to speed-up computations, you should consider computing all the independence tests you need in one pass |
CIndepTestG2 | Class for computing G2 independence test scores The class should be used as follows: first, to speed-up computations,
you should consider computing all the independence tests you need in one
pass. |
CK2 | The K2 algorithm |
CKNML | Class for computing Chi2 independence test scores |
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 |
CParamEstimator | The base class for estimating parameters of CPTsThe class should be used as follows: first, to speed-up computations, you should consider computing all the parameters you need in one pass |
CParamEstimatorML | The class for estimating parameters of CPTs using Maximum LikelihoodThe class should be used as follows: first, to speed-up computations, you should consider computing all the parameters you need in one pass |
CPartialEntropy | |
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 |
CRecordCounterThread | This class computes the number of observations of tuples of variables in the database A RecordCounterThread just computes the number of records observed for each value of its target nodes in the database (a target node usually represents either a single Discrete Variable or a pair of Discrete Variables) |
CRecordCounterThreadBase | The database-independent class for preparing the computation of the number of observations of tuples of variables in a database |
CScore | The base class for all the scores used for learning (BIC, BDeu, etc)The class should be used as follows: first, to speed-up computations, you should consider computing all the scores you need in one pass |
CScoreAIC | Class for computing AIC scores |
CScoreBD | The class for computing Bayesian Dirichlet (BD) log2 scores |
CScoreBDeu | The class for computing BDeu scores (actually their log2 value) |
CScoreBIC | The class for computing BIC scores |
CScoreInternalApriori | Base class for all the score's internal apriorisSome scores include an apriori |
CScoreInternalBDeuApriori | Internal apriori for the BDeu score (N' / (r_i * q_i)Some scores include an apriori |
CScoreInternalK2Apriori | Internal apriori for the K2 score: Laplace AprioriSome scores include an apriori |
CScoreInternalNoApriori | Internal apriori for the scores without apriori (e.g., BD)Some scores include an apriori |
CScoreK2 | The class for computing K2 scores (actually their log2 value) |
CScoreLog2Likelihood | Class for computing log2-likelihood scores |
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 |
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> |
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 |
CBNReader | Pure virtual class for reading a BN from a file |
CBNWriter | Pure virtual class for writting a BN to a file |
CBruteForceKL | BruteForceKL computes exactly the KL divergence betweens 2 BNs |
CChi2 | Represent the chi2 distribution |
CChi2TestPolicy | <agrum/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 |
CCliqueProperties | |
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 | |
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> |
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> |
CGibbsKL | 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 | |
CGTestPolicy | <agrum/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::IdSet< Alloc > > | Hash function for idSets |
CHashFunc< long > | Hash function for long integers |
CHashFunc< RefPtr< Type > > | Hash function for RefPtr |
CHashFunc< Set< double, Alloc > > | Hash function for sets of double |
CHashFunc< Set< float, Alloc > > | Hash function for sets of float |
CHashFunc< Set< int, Alloc > > | Hash function for sets of int |
CHashFunc< Set< long, Alloc > > | Hash function for sets of long |
CHashFunc< Set< unsigned int, Alloc > > | Hash function for sets of unsigned int |
CHashFunc< Set< unsigned long, Alloc > > | Hash function for sets of unsigned long |
CHashFunc< std::pair< double, double > > | Hash function for pairs of double |
CHashFunc< std::pair< double, long int > > | Hash function for pairs of double and long int |
CHashFunc< std::pair< double, long unsigned int > > | Hash function for pairs of double and long unsigned int |
CHashFunc< std::pair< float, float > > | Hash function for pairs of float |
CHashFunc< std::pair< int, int > > | Hash function for pairs of integers |
CHashFunc< std::pair< learning::IdSet< Alloc >, Idx > > | Hash function for pairs (idSet,Idx) |
CHashFunc< std::pair< long unsigned int, double > > | Modification : adding mirrored pair key of the one above Though the question should be asked of whether we enforce only one version for pair key or whether we authorize mirrored version If one version is enforced sdyna.cpp must be modified! |
CHashFunc< std::pair< long, long > > | Hash function for pairs of long integers |
CHashFunc< std::pair< std::string, std::string > > | Hash function for pairs of strings |
CHashFunc< std::pair< unsigned int, unsigned int > > | Hash function for pairs of unsigned integers |
CHashFunc< std::pair< unsigned long, unsigned long > > | Hash function for pairs of unsigned long integers |
CHashFunc< std::string > | Hash function for strings |
CHashFunc< std::tuple< learning::IdSet< Alloc >, Idx, Idx > > | Hash function for pairs (idSet,pair<Idx,Idx>) |
CHashFunc< std::tuple< learning::IdSet< Alloc >, Idx, Idx, Idx > > | Hash function for pairs (idSet,tuple<Idx,Idx,Idx>) |
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 |
CHashFuncAllCastKeyPair | Generic hash functions for pairs of keys whose sizes are precisely twice that of unsigned longs and which can be cast into unsigned longs |
CHashFuncBase | All hash functions should inherit from this class |
CHashFuncCastKey | Generic hash functions for keys castable as unsigned longs whose size is either smaller than unsigned long, or equal to that of one or two unsigned longs |
CHashFuncCastKeyPair | Generic hash functions for keys castable as unsigned longs whose size is either smaller than unsigned long, or equal to that of one or two unsigned longs |
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< HASH_TYPE > | |
CHashFuncConditionalType< HASH_TYPE, FIRST_TYPE, OTHER_TYPES... > | |
CHashFuncConditionalType< HASH_TYPE, TYPE > | |
CHashFuncConst | Constants for hash functions |
CHashFuncLargeCastKey | Generic hash functions for keys castable as unsigned longs and whose size is precisely twice that of unsigned longs |
CHashFuncMediumCastKey | Generic hash functions for keys castable as unsigned longs and whose size is precisely that of unsigned longs |
CHashFuncSmallCastKey | Generic hash functions for keys castable as unsigned longs and whose size is strictly smaller than that of unsigned longs |
CHashFuncSmallKey | Generic hash functions for keys smaller than or equal to long integers |
CHashFuncSmallKeyPair | Generic hash functions for pairs of, at most, two long integer keys |
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 |
CIDecisionStrategy | <agrum/FMDP/SDyna/IDecisionStrategy.h> |
CIdError | |
CIDReader | Pure virtual class for importing an ID from a file |
CIDWriter | Pure virtual class for exporting an ID |
CIInfluenceDiagramInference | <agrum/ID/inference/IInfluenceDiagramInference.h> |
CILearningStrategy | <agrum/FMDP/SDyna/ILearningStrategy.h> |
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/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> |
CJunctionTreeStrategy | Base Class for all the algorithms producing a junction given a set of cliques/subcliques resulting from a triangulation |
CKL | KL is the base class for KL computation betweens 2 BNs |
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/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> |
CMarkovBlanket | Class building the markov Blanket from a BN and a nodeName |
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 |
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/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 |
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 | |
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> |
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/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 > | |
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 | |
CUAIReader | Pure virtual class for reading a BN from a file |
CUAIWriter | <agrum/BN/io/UAI/UAIWriter.h> |
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> |
CVariableNodeMap | Container used to map discrete variables with nodes |
CVariableSelector | <agrum/FMDP/planning/FunctionGraph/variableselector.h> |
CWeightedSampling | |
CWrongClassElement | |
CWrongType | |
►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> |
CMonteCarloInference | <agrum/BN/inference/monteCarloInference.h> |
CSAmplingInference | <agrum/BN/inference/samplingInference.h> |
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> |