 |
aGrUM 2.3.2
a C++ library for (probabilistic) graphical models
|
|
aGrUM 2.3.2
a C++ library for (probabilistic) graphical models
|
| 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/base/multidim/aggregators/multiDimAggregator.h> |
| COr | Or aggregator |
| CSum | Sum aggregator |
| Ncredal | Namespace for all credal networks entities |
| Nlp | Namespace for constraint-based description of credal sets |
| CLpInterface | Class representing a linear program |
| CLpCol | Class representing a variable ( a column ) of a linear program, i.e |
| CLpExpr | Class representing a linear expression |
| CLpRow | Class representing a row of the linear program, i.e |
| CCredalNet | Class template representing a Credal Network |
| CCNLoopyPropagation | <agrum/CN/CNLoopyPropagation.h> |
| CCNMonteCarloSampling | <agrum/CN/CNMonteCarloSampling.h> |
| CInferenceEngine | Abstract class template representing a CredalNet inference engine |
| CMultipleInferenceEngine | Class template representing a CredalNet inference engine using one or more IBayesNet inference engines such as LazyPropagation |
| CLRSWrapper | Class template acting as a wrapper for Lexicographic Reverse Search by David Avis |
| CVarMod2BNsMap | Class used to store optimum IBayesNet during some inference algorithms |
| Nprm | Namespace for all probabilistic relational models entities |
| Ngspan | |
| CDFSCode | Reprensent a Depth First Search coding of a graph |
| CSearchStrategy | This is an abstract class used to tune search strategies in the gspan algorithm |
| CDFSTree | A DFSTree is used by gspan to sort lexicographically patterns discovered in an interface graph |
| CPatternData | |
| CNeighborDegreeSort | This is used to generate the max_indep_set of a Pattern |
| CEdgeCode | Represent a DFS code used by gspan |
| CEdgeGrowth | This class is used to define an edge growth of a pattern in this DFSTree |
| CLabelData | Inner class to handle data about labels in this interface graph |
| CNodeData | Inner class to handle data about nodes in graph |
| CEdgeData | Inner class to handle data about edges in graph |
| CInterfaceGraph | This class represent the interface graph of a given gum::prm::PRMSystem<GUM_SCALAR> |
| CPattern | This contains all the information we want for a node in a 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 |
| 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 | |
| CO3ClassFactory | Builds gum::prm::Class from gum::prm::o3prm::O3Class |
| CO3InterfaceFactory | Bulds gum::prm:PRMInterface from gum::prm::o3prm::O3Interface |
| CO3NameSolver | Resolves names for the different O3PRM factories |
| CO3Position | The O3Position is part of the AST of the O3PRM language |
| CO3Formula | The O3Formula is part of the AST of the O3PRM language |
| CO3Float | The O3Float is part of the AST of the O3PRM language |
| CO3Integer | The O3Integer is part of the AST of the O3PRM language |
| CO3Label | The O3Label is part of the AST of the O3PRM language |
| CO3Type | The O3Type is part of the AST of the O3PRM language |
| CO3IntType | The O3IntType is part of the AST of the O3PRM language |
| CO3RealType | The O3RealType is part of the AST of the O3PRM language |
| CO3InterfaceElement | The O3InterfaceElement is part of the AST of the O3PRM language |
| CO3Interface | The O3Interface is part of the AST of the O3PRM language |
| CO3Parameter | The O3Parameter is part of the AST of the O3PRM language |
| CO3ReferenceSlot | The O3ReferenceSlot is part of the AST of the O3PRM language |
| CO3Attribute | The O3Attribute is part of the AST of the O3PRM language |
| CO3RawCPT | The O3RawCPT is part of the AST of the O3PRM language |
| CO3RuleCPT | The O3RuleCPT is part of the AST of the O3PRM language |
| CO3Aggregate | The O3Aggregate is part of the AST of the O3PRM language |
| CO3Class | The O3Class is part of the AST of the O3PRM language |
| CO3Assignment | The O3Assignment is part of the AST of the O3PRM language |
| CO3Increment | The O3Increment is part of the AST of the O3PRM language |
| CO3InstanceParameter | The O3InstanceParameter is part of the AST of the O3PRM language |
| CO3Instance | The O3Instance is part of the AST of the O3PRM language |
| CO3System | The O3System is part of the AST of the O3PRM language |
| CO3Import | The O3Import 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 |
| CO3SystemFactory | Builds gum::prm::PRMSystem from gum::prm::o3prm::O3System |
| CO3TypeFactory | Builds gum::prm::PRMType from gum::prm::o3prm::O3Type, gum::prm::o3prm::O3IntType and gum::prm::o3prm::O3RealType |
| No3prmr | |
| CO3prmrCommand | This is an abstract class |
| CImportCommand | |
| CSetEngineCommand | |
| CSetGndEngineCommand | |
| CObserveCommand | |
| CUnobserveCommand | |
| CQueryCommand | |
| CO3prmrSession | This class contains a o3prmr session |
| CO3prmrContext | Represent a o3prmr context, with an import, and some sequencials commands |
| CSingleResult | |
| CQueryResult | |
| CO3prmrInterpreter | Represents a O3PRMR context |
| 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> |
| CPRMAggregate | |
| CPRMAttribute | PRMAttribute is a member of a Class in a PRM |
| 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 |
| CPRMClass | A PRMClass is an object of a PRM representing a fragment of a Bayesian network which can be instantiated in PRMInstance |
| CParamScopeData | |
| CPRMClassElement | Abstract class representing an element of PRM class |
| CPRMClassElementContainer | <agrum/PRM/classElementContainer.h> |
| CPRMFormAttribute | <agrum/PRM/elements/formAttribute.h> |
| CPRMFuncAttribute | <agrum/PRM/elements/funcAttribute.h> |
| CPRMInstance | An PRMInstance is a Bayesian network fragment defined by a Class and used in a PRMSystem |
| CRefIterator | Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations |
| CRefConstIterator | Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations |
| CPRMObject | Abstract base class for any element defined in a PRM |
| 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 |
| CPRMReferenceSlot | A PRMReferenceSlot represent a relation between two PRMClassElementContainer |
| CPRMSystem | A PRMSystem is a container of PRMInstance and describe a relational skeleton |
| CPRMParameter | PRMParameter is a member of a Class in a PRM |
| CPRMScalarAttribute | <agrum/PRM/elements/scalarAttribute.h> |
| CPRMFactory | Factory which builds a PRM<GUM_SCALAR> |
| CPRMType | This is a decoration of the DiscreteVariable class |
| CClusteredLayerGenerator | <agrum/PRM/generator/clusteredLayerGenerator.h> |
| CMyData | |
| 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 |
| CPRMGenerator | This class is the base class to all PRM generators |
| 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 |
| CGroundedInference | <agrum/PRM/groundedInference.h> |
| CPRMInference | This abstract class is used as base class for all inference class on PRM<GUM_SCALAR> |
| CStructuredBayesBall | <agrum/PRM/structuredBayesBall.h> |
| CStructuredInference | <agrum/PRM/structuredInference.h> |
| CRGData | Private structure to represent data about a reduced graph |
| CPData | Private structure to represent data about a pattern |
| CCData | Private structure to represent data about a Class<GUM_SCALAR> |
| CSVE | This class is an implementation of the Structured Variable Elimination algorithm on PRM<GUM_SCALAR> |
| CSVED | This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR> |
| CInstanceBayesNet | This class decorates an PRMInstance<GUM_SCALAR> as an IBaseBayesNet |
| CIPRMFactory | Non-template interface-like parent for every PRM Factory |
| CPRM | This class represents a Probabilistic Relational PRMSystem<GUM_SCALAR> |
| NthreadsOMP | |
| CThreadExecutor | |
| NthreadsSTL | |
| CThreadExecutor | |
| Nlearning | Include the inlined functions if necessary |
| CCSVParser | Class for fast parsing of CSV file (never more than one line in application memory) |
| CDatabaseTable | The class representing a tabular database as used by learning tasks |
| CDBCell | The class representing the original values of the cells of databases |
| CDBHandler | The base class for all database handlers |
| CDBInitializerFromCSV | The class for initializing DatabaseTable and RawDatabaseTable instances from CSV files |
| CDBInitializerFromSQL | The class for initializing DatabaseTable and RawDatabaseTable instances from SQL databases |
| CDBRow | The class for storing a record in a database |
| CDBRowGenerator | The base class for all DBRow generators |
| CDBRowGenerator4CompleteRows | A DBRowGenerator class that returns the rows that are complete (fully observed) w.r.t |
| CDBRowGeneratorEM | A DBRowGenerator class that returns incomplete rows as EM would do |
| CDBRowGeneratorIdentity | A DBRowGenerator class that returns exactly the rows it gets in input |
| CDBRowGeneratorParser | Class used to read a row in the database and to transform it into a set of DBRow instances that can be used for learning |
| CDBRowGeneratorSet | The class used to pack sets of generators |
| CDBRowGeneratorWithBN | Base class for DBRowGenerator classes that use a BN for computing their outputs |
| CDBTranslatedValue | The union class for storing the translated values in learning databases |
| CDBTranslator | The base class for all the tabular database cell translators |
| CDBTranslator4ContinuousVariable | The databases' cell translators for continuous variables |
| CDBTranslator4DiscretizedVariable | The databases' cell translators for discretized variables |
| CDBTranslator4IntegerVariable | The databases' cell translators for integer variables |
| CDBTranslator4LabelizedVariable | The databases' cell translators for labelized variables |
| CDBTranslator4NumericalDiscreteVariable | The databases' cell translators for numerical Discrete variables |
| CDBTranslator4RangeVariable | The databases' cell translators for range variables |
| CDBTranslatorSet | Class for packing together the translators used to preprocess the datasets |
| CIDatabaseTableInsert4DBCell | |
| CIDatabaseTableInsert4DBCell< true > | |
| CIDatabaseTableInsert4DBCell< false > | |
| CIDatabaseTable | The common class for the tabular database tables |
| CHandler | (unsafe) handler for the tabular databases |
| CHandlerSafe | Safe handler of the tabular databases |
| CIDBInitializer | The base class for initializing DatabaseTable and RawDatabaseTable instances from CSV files or SQL databases |
| CNanodbcParser | Class for parsing SQL results using Nanodbc |
| CRawDatabaseTable | The table containing the raw/original data of a database |
| CIdCondSetIterator | The iterators for IdSets |
| CIdCondSet | A class for storing a pair of sets of NodeIds, the second one corresponding to a conditional set |
| 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 |
| CKNML | Class for computing the NML penalty used by MIIC |
| CPseudoCount | The class for giving access to pseudo count : count in the database + prior |
| CRecordCounter | The class that computes counting of observations from the database |
| CScoringCache | Cache for caching scores and independence tests results |
| 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 |
| CIBNLearner | A pack of learning algorithms that can easily be used |
| CDatabase | Helper to easily read databases |
| CStructuralConstraintEmpty | Base class for all structural constraints |
| 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 |
| CStructuralConstraintForbiddenArcs | Structural constraint for forbidding the creation of some arcs during structure learning |
| CStructuralConstraintIndegree | Class for structural constraints limiting the number of parents of nodes in a directed graph |
| CStructuralConstraintMandatoryArcs | Structural constraint indicating that some arcs shall never be removed or reversed |
| CStructuralConstraintNoChildrenNodes | Structural constraint for forbidding children for some nodes |
| CStructuralConstraintNoParentNodes | Structural constraint for forbidding parents for some nodes |
| CStructuralConstraintPossibleEdges | Structural constraint for forbidding the creation of some arcs except those defined in the class during structure learning |
| CStructuralConstraintSetStatic | "meta-programming" class for storing structural constraints |
| CStructuralConstraintSliceOrder | Structural constraint imposing a partial order over nodes |
| CStructuralConstraintTabuList | The class imposing a N-sized tabu list as a structural constraints for learning algorithms |
| CStructuralConstraintUndiGraph | The base class for structural constraints used by learning algorithms that learn an undirected graph structure |
| CCorrectedMutualInformation | The class computing n times the corrected mutual information, as used in the MIIC algorithm |
| CGreedyHillClimbing | The greedy hill climbing learning algorithm (for directed graphs) |
| CK2 | The K2 algorithm |
| CLocalSearchWithTabuList | The local search with tabu list learning algorithm (for directed graphs) |
| CGreaterPairOn2nd | |
| CGreaterAbsPairOn2nd | |
| CGreaterTupleOnLast | |
| CMiic | The Miic learning algorithm |
| CDAG2BNLearner | A class that, given a structure and a parameter estimator returns a full Bayes net |
| CEMApproximationScheme | A class for parameterizing EM's parameter learning approximations |
| CParamEstimator | The base class for estimating parameters of CPTs |
| CParamEstimatorML | The class for estimating parameters of CPTs using Maximum Likelihood |
| CBDeuPrior | Internal prior for the BDeu score (N' / (r_i * q_i) |
| CDirichletPriorFromBN | A dirichlet priori: computes its N'_ijk from a database |
| CDirichletPriorFromDatabase | A dirichlet priori: computes its N'_ijk from a database |
| CK2Prior | Internal prior for the K2 score = Laplace Prior |
| CNoPrior | No a priorclass: corresponds to 0 weight-sample |
| CPrior | Base class for all a priori |
| CSmoothingPrior | Smooth a priori: adds a weight w to all the counts |
| 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 |
| CSimpleMiic | The miic learning algorithm |
| CGraphChange | |
| CArcAddition | The class for notifying learning algorithms of new arc additions |
| CArcDeletion | The class for notifying learning algorithms of arc removals |
| CArcReversal | The class for notifying learning algorithms of arc reversals |
| CEdgeAddition | The class for notifying learning algorithms of new edge additions |
| CEdgeDeletion | The class for notifying learning algorithms of edge removals |
| CGraphChangesGenerator4DiGraph | The basic class for computing the next graph changes possible in a structure learning algorithm |
| C_GraphChangesGenerator4K2_ | |
| 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 |
| CIGraphChangesGenerator4DiGraph | |
| CIGraphChangesGenerator4UndiGraph | |
| CApproximationPolicy | Mother class for all approximation policy classes |
| CApproximationScheme | Approximation Scheme |
| CApproximationSchemeListener | The ApproximationSchemeListener class |
| CExactPolicy | Class implementing exact approximation policy (meaning a value is approximate to itself) |
| CIApproximationSchemeConfiguration | Approximation Scheme |
| CLinearApproximationPolicy | Class implementing linear approximation policy (meaning possible value are split out in interval) |
| CArgMaxSet | Class to handle efficiently argMaxSet |
| CAVLTree | AVL binary search tree |
| CAVLTreeIterator | AVL binary search tree iterator |
| CAVLTreeIteratorSafe | AVL binary search tree safe (w.r.t |
| CAVLTreeReverseIterator | AVL binary search tree reverse iterator |
| CAVLTreeReverseIteratorSafe | AVL binary search tree safe (w.r.t |
| CBijectionImplementation | A non scalar implementation of a Bijection |
| CBijectionIteratorGet | Dummy classes for discriminating scalars and non-scalars operators and -> wihtout any overhead |
| CBijectionIteratorGet< true > | |
| CBijectionIteratorSafe | Safe iterators for bijectionIterator |
| CBijectionIterator | Unsafe iterators for bijection |
| CBijection | Set of pairs of elements with fast search for both elements |
| CBinSearchTree | A generic binary search tree |
| CBinSearchTreeIterator | A Generic binary search tree |
| CBinTreeNode | Nodes of a binary trees |
| CParseError | This class is used to represent parsing errors for the different parser implemented in aGrUM |
| CErrorsContainer | This class is used contain and manipulate gum::ParseError |
| CException | Base class for all aGrUM's exceptions |
| CMaximizes | Maximization function object class |
| CMinimizes | Minimization function object class |
| CArgumentMaximises | Arg Max function object class |
| CHashFuncConst | Useful constants for hash functions |
| CHashFuncBase | All hash functions should inherit from this class |
| CHashFuncSmallKey | Generic hash functions for numeric keys smaller than or equal to Size |
| CHashFuncSmallCastKey | Generic hash functions for keys castable as Size and whose size is strictly smaller than that of Size |
| CHashFuncMediumCastKey | Generic hash functions for keys castable as Size and whose size is precisely that of Size |
| CHashFuncLargeCastKey | Generic hash functions for keys castable as Size and whose size is precisely twice that of Size |
| 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 |
| CdummyHash | |
| CHashFuncConditionalType | This class enables to safely define hash functions for types that may or may not already has defined hash functions |
| CHashFuncConditionalType< Key > | |
| CHashFuncConditionalType< KEY_TYPE, TYPE > | |
| CHashFuncConditionalType< KEY_TYPE, FIRST_TYPE, OTHER_TYPES... > | |
| CHashFunc | This class should be useless as only its specializations should be used |
| CHashFunc< std::pair< Key1, Key2 > > | |
| CHashFunc< bool > | Hash function for booleans |
| CHashFunc< int > | Hash function for integers |
| CHashFunc< unsigned int > | Hash function for unsigned integers |
| CHashFunc< long > | Hash function for long integers |
| CHashFunc< unsigned long > | Hash function for unsigned long integers |
| CHashFunc< typename HashFuncConditionalType< std::size_t, unsigned long, unsigned int, long, int >::type > | Hash function for std::size_t |
| CHashFunc< float > | Hash function for floats |
| CHashFunc< double > | Hash function for doubles |
| CHashFunc< Type * > | Hash function for pointers |
| CHashFunc< std::string > | Hash function for strings |
| CHashFunc< std::vector< Idx > > | Hash function for vectors of gum::Idx |
| CHashFunc< Debug > | Hash function for gum::Debug |
| CHashFunc< RefPtr< Type > > | Hash function for RefPtr |
| CHashTableConst | Parameters specifying the default behavior of the hashtables |
| CHashTableBucket | A recipient for a pair of key value in a gum::HashTableList |
| CHashTableList | A chained list used by gum::HashTable |
| CHashTable | The class for generic Hash Tables |
| CHashTableConstIteratorSafe | Safe Const Iterators for hashtables |
| CHeap | Heap data structure |
| CIndexedTree | The class for storing the nodes of the Arborescence |
| CIThreadNumberManager | |
| CListBucket | Bucket for a chained list |
| CList | Generic doubly linked lists |
| CListConstIterator | Unsafe but fast const iterators for Lists |
| CListIterator | Unsafe but fast iterators for Lists |
| CListConstIteratorSafe | Safe const iterators for Lists |
| CListIteratorSafe | Safe iterators for Lists |
| CChi2 | Represent the chi2 distribution |
| CDirichlet | A class for sampling w.r.t |
| CFormulaPart | Represents part of a formula |
| CFormula | Evaluates a string as a algebraic formula |
| CGammaLog2 | The class for computing Log2 (Gamma(x)) |
| CRational | Class template used to approximate decimal numbers by rationals |
| CVariableLog2ParamComplexity | Class for computing the log2 of the parametric complexity of an r-ary multinomial variable |
| CMultiPriorityQueue | A MultiPriorityQueue is a heap in which each element has a mutable priority and duplicates are allowed |
| CPriorityQueue | A priorityQueue is a heap in which each element has a mutable priority |
| CPriorityQueueImplementation | The internal class for representing priority queues |
| CProgressNotifier | Notification for progress using listener |
| CProgressListener | The ProgressListener class |
| CRefPtr | Smart pointers |
| CSequenceImplementation | The internal class for storing (ordered) sequences of objects |
| CSequence | The generic class for storing (ordered) sequences of objects |
| CSequenceIteratorSafe | Safe iterators for Sequence |
| CSet | Representation of a set |
| CSetIteratorSafe | Safe iterators for the Set class |
| CSetIterator | Unsafe iterators for the Set class |
| CHashFunc< Set< T > > | Hash function for sets of int |
| CListener | Every class who would catch signal from signaler should derive from Listener |
| CSignaler0 | Class for signal with 0 args |
| CFixedAllocator | Allocates objects of one given size |
| C_Chunk_ | Allocates objects of one given size |
| CSmallObjectAllocator | <agrum/base/core/smallObjectAllocator.h> |
| CSortedPriorityQueueIterator | Sorted priority queue iterator |
| CSortedPriorityQueueIteratorSafe | Sorted priority queues safe (w.r.t |
| CSortedPriorityQueueReverseIterator | Sorted priority queue reverse iterator |
| CSortedPriorityQueueReverseIteratorSafe | Sorted priority queue safe (w.r.t |
| CSortedPriorityQueue | A priority queue in which we can iterate over the elements from the top to bottom or conversely |
| CSplayBinaryNode | Nodes of splay trees |
| CSplayTree | A splay tree |
| CThreadData | A wrapper that enables to store data in a way that prevents false cacheline sharing |
| CThreadExecutorBase | Set the max number of threads to be used |
| CThreadNumberManager | A class to manage the number of threads to use in an algorithm |
| CTimer | Class used to compute response times for benchmark purposes |
| CNullStream | Implements a stream with the same behaviour as /dev/null |
| CAlmostDifferent | Indicate whether two elements are (almost) different or not |
| CAlmostDifferent< T * > | Indicate whether two elements are (almost) different or not |
| CInformationTheory | InformationTheory is a template class which aims at gathering the implementation of informational functions (entropy, mutual information, etc.) |
| CDAGmodel | Virtual base class for PGMs using a DAG |
| CGraphicalModel | Virtual base class for probabilistic graphical models |
| CGraphicalModelInference | <agrum/base/graphicalModels/graphicalModel.h> |
| CIScheduleMultiDim | The Table-agnostic base class of scheduleMultiDim |
| CSchedule | Class containing a schedule of operations to perform on multidims |
| CScheduleBinaryCombination | Binary Combination operator class used for scheduling inferences |
| CScheduledInference | Class containing the scheduler used by schedule-based inferences |
| CScheduleMultiDim | Wrapper for multi-dimensional tables used for scheduling inferences |
| CElementType | Metaprogramming to get the types of the elements stored into the ScheduleMultidims |
| CElementType< CONTAINER< T, Args... > > | |
| CScheduleOperator | Base class for "low-level" operators used to schedule inferences |
| CScheduleProjection | Projection operator class used for scheduling inferences |
| CScheduler | The common interface of all the schedulers |
| CSchedulerParallel | A scheduler that executes available operators in parallel |
| CSchedulerSequential | |
| CUnexecutedOperation | Structure to keep informations about operations that could not be executed due to memory usage limitations |
| CScheduleStorage | Class for storing multidimensional tables into containers (sets, etc.) |
| CUGmodel | Virtual base class for PGMs using a undirected graph |
| CVariableNodeMap | Container used to map discrete variables with nodes |
| CBinaryJoinTreeConverter | |
| CBinaryJoinTreeConverterDefault | |
| CDAGCycleDetector | A class for detecting directed cycles in DAGs when trying to apply many changes to the graph |
| CChange | Base class indicating the possible changes |
| CArcAdd | Class to indicate that we wish to add a new arc |
| CArcDel | Class to indicate that we wish to remove an arc |
| CArcReverse | Class to indicate that we wish to reverse an arc |
| CMeekRules | |
| CSimplicialSet | Class enabling fast retrieval of simplicial, quasi and almost simplicial nodes |
| CSpanningForest | Base class for computing min cost spanning trees or forests |
| CSpanningForestPrim | The Prim algorithm for computing min cost spanning trees or forests |
| CDefaultTriangulation | The default triangulation algorithm used by aGrUM |
| CDefaultEliminationSequenceStrategy | An efficient unconstrained elimination sequence algorithm |
| CDefaultPartialOrderedEliminationSequenceStrategy | An Elimination sequence algorithm that imposes a given partial ordering on the nodes elimination sequence |
| CEliminationSequenceStrategy | The base class for all elimination sequence algorithms used by triangulation algorithms |
| COrderedEliminationSequenceStrategy | An Elimination sequence algorithm that imposes a given complete ordering on the nodes elimination sequence |
| 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 |
| 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 |
| CIncrementalTriangulation | Class that performs incremental triangulations |
| CDefaultJunctionTreeStrategy | An algorithm producing a junction given the elimination tree produced by a triangulation algorithm |
| CJunctionTreeStrategy | Base Class for all the algorithms producing a junction given a set of cliques/subcliques resulting from a triangulation |
| COrderedTriangulation | Class for graph triangulations for which we enforce a given complete ordering on the nodes eliminations |
| 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 |
| CStaticTriangulation | Base class for all non-incremental triangulation methods |
| CTriangulation | Interface for all the triangulation methods |
| CUnconstrainedTriangulation | Interface for all triangulation methods without constraints on node elimination orderings |
| CCliqueGraph | Basic graph of cliques |
| C_RunningIntersect_ | Structure used for the computation of the running intersection property |
| CDAG | Base class for dag |
| CDiGraph | Base class for all oriented graphs |
| CEdge | The base class for all undirected edges |
| CArc | The base class for all directed edges |
| CMixedGraph | Base class for mixed graphs |
| CArcGraphPart | Classes for directed edge sets |
| CEdgeGraphPart | Classes for undirected edge sets |
| CDiGraphListener | Abstract Base class for all diGraph Listener |
| CMixedGraphListener | Abstract Base class for all mixed Graph Listener |
| CUndiGraphListener | Abstract Base class for all undiGraph Listener |
| CNodeGraphPartIterator | Unsafe iterator on the node set of a graph |
| CNodeGraphPartIteratorSafe | Safe iterator on the node set of a graph |
| CNodeGraphPart | Class for node sets in graph |
| CPDAG | Base class for partially directed acyclic graphs |
| CUndiGraph | Base class for undirected graphs |
| CMultiDimICIModel | Abstract class for Conditional Indepency Models |
| CMultiDimLogit | Logit representation |
| CMultiDimNoisyAND | Noisy AND representation |
| CMultiDimNoisyORCompound | Noisy OR representation |
| CMultiDimNoisyORNet | Noisy OR representation |
| CMultiDimAdressable | Abstract base class for all multi dimensionnal addressable |
| CMultiDimBijArray | Decorator of a MultiDimArray, using a bijection over the variables |
| CMultiDimArray | Multidimensional matrix stored as an array in memory |
| CMultiDimBucket | A multidim implementation for buckets |
| CMultiDimImplementation | <agrum/base/multidim/multiDimImplementation.h> |
| CMultiDimContainer | Abstract base class for all multi dimensionnal containers |
| CMultiDimDecorator | Decorator design pattern in order to separate implementations from multidimensional matrix concepts |
| CMultiDimFunctionGraphManager | Class implementingting a function graph manager |
| CMultiDimFunctionGraphROManager | |
| CMultiDimFunctionGraphTreeManager | |
| CMultiDimFunctionGraph | Class implementingting a function graph |
| CMultiDimFunctionGraphGenerator | Class implementing a function graph generator with template type double |
| CMultiDimInterface | Interface for all classes addressing in a multiDim fashion |
| CMultiDimPartialInstantiation | A generic class to instantiate a subset of variables of a multidimensional table |
| 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 |
| CInstantiation | Class for assigning/browsing values to tuples of discrete variables |
| CHashFunc< Instantiation > | Hash function for gum::Instantiation |
| CSetInst | Class for assigning/browsing values to tuples of discrete variables |
| CTensor | AGrUM's Tensor is a multi-dimensional array with tensor operators |
| CParent | Represent a node's parent |
| CInternalNode | Structure used to represent a node internal structure |
| CLink | Link of a chain list allocated using the SmallObjectAllocator |
| CLinkedList | Chain list allocated using the SmallObjectAllocator |
| CMultiDimFunctionGraphOperator | Class used to perform Function Graph Operations |
| CMultiDimFunctionGraphProjector | Class used to perform Function Graph projections |
| CO4DGContext | Class used to manipulate context during Function Graph Operations |
| CRegress | Class used to perform Function Graph Operations in the FMDP Framework |
| CTreeOperator | Class used to perform Decision Tree Operation in the FMDP Framework |
| CTreeRegress | Class used to perform Decision Tree Regression in the FMDP Framework |
| CExactTerminalNodePolicy | Implementation of a Terminal Node Policy that maps nodeid directly to value |
| CITerminalNodePolicy | Interface specifying the methods to be implemented by any TerminalNodePolicy |
| CSetTerminalNodePolicy | Implementation of a Terminal Node Policy that maps nodeid to a set of value |
| CCompleteProjectionRegister4MultiDim | A container for registering complete projection functions on multiDimImplementations, i.e., functions projecting tables over all their variables |
| CCompleteProjections4MultiDimInitialize | Class used to register complete projections over non-pointers types |
| CCompleteProjections4MultiDimInitialize< GUM_SCALAR * > | Class used to register complete projections over pointers types |
| CMultiDimCombination | A generic interface to combine efficiently several MultiDim tables |
| CMultiDimCombinationDefault | A class to combine efficiently several MultiDim tables |
| CMultiDimCombineAndProject | A generic interface to combine and project efficiently MultiDim tables |
| CMultiDimCombineAndProjectDefault | An efficient class for combining and projecting MultiDim tables |
| CMultiDimCompleteProjection | A generic class to project efficiently a MultiDim table over all of its variables |
| CMultiDimProjection | A generic class to project efficiently a MultiDim table over a subset of its variables |
| COperatorRegister4MultiDim | A container for registering binary functions on multiDimImplementations |
| COperators4MultiDimInitialize | Class used to register operators over non-pointers types |
| COperators4MultiDimInitialize< GUM_SCALAR * > | Class used to register operators over pointers types |
| 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 |
| 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 |
| CHashFunc< learning::IdCondSet > | Hash function for idSets |
| CContinuousVariable | Defines a continuous random variable |
| CDiscreteVariable | Base class for discrete random variable |
| CDiscretizedVariable | Class for discretized random variable |
| CIContinuousVariable | A base class for continuous variables, independent of the GUM_SCALAR type |
| CIDiscretizedVariable | A base class for discretized variables, independent of the ticks type |
| CIntegerVariable | Class IntegerVariable |
| CLabelizedVariable | Class LabelizedVariable |
| CNumericalDiscreteVariable | Class NumericalDiscreteVariable |
| CRangeVariable | Defines a discrete random variable over an integer interval |
| CVariable | Base class for every random variable |
| CBarrenNodesFinder | Detect barren nodes for inference in Bayesian networks |
| CBayesBall | Implementation of Shachter's Bayes Balls algorithm |
| CBNdistance | |
| CExactBNdistance | ExactBNdistance computes exactly the KL divergence betweens 2 BNs |
| CGibbsBNdistance | GibbsKL computes the KL divergence betweens 2 BNs using an approximation pattern: GIBBS sampling |
| CdSeparationAlgorithm | D-separation algorithm as described in Koller & Friedman (2009) |
| CEssentialGraph | Class building the essential graph from a BN |
| CMarkovBlanket | Class building the markov Blanket from a BN and a nodeName |
| CStructuralComparator | A class for comparing graphs based on their structures |
| CBayesNetFactory | A factory class to ease BayesNet construction |
| CBayesNet | Class representing a Bayesian network |
| CBayesNetFragment | Portion of a BN identified by the list of nodes and a BayesNet |
| CIBayesNetGenerator | Class for generating Bayesian networks |
| CMaxInducedWidthMCBayesNetGenerator | MaxInducedWidthMCBayesNetGenerator.h <agrum/BN/generator/SimpleMCayesNetGenerator.h> |
| CMaxParentsMCBayesNetGenerator | <agrum/BN/generator/SimpleMCayesNetGenerator.h> |
| CMCBayesNetGenerator | <agrum/BN/generator/MCayesNetGenerator.h> |
| CSimpleBayesNetGenerator | <agrum/BN/generator/simpleBayesNetGenerator.h> |
| CSimpleCPTDisturber | <agrum/BN/generator/simpleCPTDisturber.h> |
| CSimpleCPTGenerator | <agrum/BN/generator/simpleCPTGenerator.h> |
| CIBayesNet | Class representing the minimal interface for Bayesian network with no numerical data |
| CIBayesNetFactory | IBayesNetFactory is the non-template interface for BayesNetFactory : many ways to build a BN do not depend on the specification of the GUM_SCALAR template argument (for instance for BN readers) |
| CGibbsSampling | <agrum/BN/inference/gibbsSampling.h> |
| CImportanceSampling | |
| CLazyPropagation | Implementation of a Shafer-Shenoy's-like version of lazy propagation for inference in Bayesian networks |
| CLoopyBeliefPropagation | <agrum/BN/inference/loopyBeliefPropagation.h> |
| CLoopySamplingInference | <agrum/BN/inference/loopySamplingInference.h> |
| CMonteCarloSampling | |
| CShaferShenoyInference | Implementation of Shafer-Shenoy's propagation algorithm for inference in Bayesian networks |
| CAggregatorDecomposition | <agrum/BN/inference/tools/aggregatorDecomposition.h> |
| CApproximateInference | |
| CJointTargetedInference | <agrum/BN/inference/jointTargetedInference.h> |
| CMarginalTargetedInference | <agrum/BN/inference/marginalTargetedInference.h> |
| CEvidenceInference | <agrum/BN/inference/evidenceInference.h> |
| CBayesNetInference | <agrum/BN/inference/BayesNetInference.h> |
| CEstimator | |
| CGibbsOperator | Class containing all variables and methods required for Gibbssampling |
| CSamplingInference | <agrum/BN/inference/samplingInference.h> |
| CVariableElimination | Implementation of a Variable Elimination's-like version of lazy propagation for inference in Bayesian networks |
| CWeightedSampling | |
| 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> |
| CBNReader | Pure virtual class for reading a BN from a file |
| CBNWriter | Virtual class for writing a BN to a file |
| CCNFWriter | Writes a IBayesNet in the BN format |
| CContextualDependenciesCNFWriter | <agrum/BN/io/cnf/ContextualDependenciesCNFWriter.h> |
| CFactorisedValuesCNFWriter | <agrum/BN/io/cnf/FactorisedValuesCNFWriter.h> |
| CGeneralizedCNFWriter | <agrum/BN/io/cnf/GeneralizedCNFWriter.h> |
| CDSLReader | Pure virtual class for reading a BN from a file |
| CDSLWriter | Writes a IBayesNet in the DSL format |
| CNetReader | Pure virtual class for reading a BN from a file |
| CNetWriter | Writes a IBayesNet in the BN format |
| CUAIBNReader | Pure virtual class for reading a BN from a file |
| CUAIBNWriter | Writes an bayes net in a text file with UAI format |
| CXDSLBNReader | <agrum/BN/io/XDSL/XDSLBNReader.h> |
| CXDSLBNWriter | <agrum/BN/io/XDSLXML/XDSLBNWriter.h> |
| CHashFunc< learning::GraphChange > | Hash function for Graph Changes |
| 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< credal::lp::LpCol > | |
| CE_GreedyDecider | <agrum/FMDP/decision/E_GreedyDecider.h> |
| CLazyDecider | Class to make decision randomly |
| CRandomDecider | Class to make decision randomly |
| CStatisticalLazyDecider | <agrum/FMDP/decision/statisticalLazyDecider.h> |
| CFMDP | This class is used to implement factored decision process |
| CFMDPFactory | A factory class to ease Factored Markov Decision Process construction |
| CAbstractFMDPFactory | A factory class to ease Factored Markov Decision Process construction |
| CFMDPDatReader | Definition of templatized reader of FMDPDat files for Factored Markov Decision Processes |
| CFMDPReader | Pure virtual class for reading a FMDP from a file |
| CChiSquare | <agrum/FMDP/learning/core/testPolicy/chiSquare.h> |
| CContingencyTable | <agrum/FMDP/learning/core/contingencyTable.h> |
| CInt2Type | |
| CTestSelect | |
| CTestSelect< CHI2TEST, A, B, C > | |
| CTestSelect< LEASTSQUARETEST, A, B, C > | |
| CValueSelect | |
| CValueSelect< false, A, B > | |
| CLearnerSelect | |
| CLearnerSelect< ITILEARNER, A, B > | |
| CChi2TestPolicy | <agrum/base/multidim/core/testPolicy/Chi2TestPolicy.h> |
| CGTestPolicy | <agrum/base/multidim/core/testPolicies/GTestPolicy.h> |
| CITestPolicy | <agrum/base/multidim/core/testPolicies/ITestPolicy.h> |
| CLeastSquareTestPolicy | <agrum/base/multidim/core/testPolicy/leastSquareTestPolicy.h> |
| CHashFunc< std::tuple< unsigned int, unsigned int, unsigned int > > | Hash function for tuple (unsigned int, unsigned int,unsigned int) |
| CIMDDI | |
| CIncrementalGraphLearner | <agrum/FMDP/learning/datastructure/incrementalGraphLearner> |
| CITI | Learn a graphical representation of a function as a decision tree |
| CIVisitableGraphLearner | <agrum/FMDP/SDyna/IVisitableGraphLearner.h> |
| CAbstractLeaf | <agrum/FMDP/learning/datastructure/leaves/abstractLeaf.h> |
| CComposedLeaf | <agrum/FMDP/learning/datastructure/leaves/composedLeaf.h> |
| CConcreteLeaf | <agrum/FMDP/learning/datastructure/leaves/concreteLeaf.h> |
| CFusionContext | <agrum/FMDP/learning/datastructure/leaves/fusionContext.h> |
| CLeafAggregator | <agrum/FMDP/learning/FunctionGraph/leafAggregator.h> |
| CLeafPair | <agrum/FMDP/learning/datastructure/leaves/leafPair.h> |
| CNodeDatabase | <agrum/FMDP/learning/datastructure/nodeDatabase.h> |
| CVariableSelector | <agrum/FMDP/planning/FunctionGraph/variableselector.h> |
| CFMDPLearner | |
| CObservation | |
| CArgumentMaximisesAction | <agrum/FMDP/planning/actionSet.h> |
| CActionSet | A class to store the optimal actions |
| CAdaptiveRMaxPlaner | <agrum/FMDP/planning/adaptiveRMaxPlaner.h> |
| CIOperatorStrategy | <agrum/FMDP/SDyna/IOperatorStrategy.h> |
| CMDDOperatorStrategy | <agrum/FMDP/planning/mddOperatorStrategy.h> |
| CStructuredPlaner | <agrum/FMDP/planning/structuredPlaner.h> |
| CTreeOperatorStrategy | <agrum/FMDP/planning/treeOperatorStrategy.h> |
| CSDYNA | The general SDyna architecture abstract class |
| CIDecisionStrategy | <agrum/FMDP/SDyna/IDecisionStrategy.h> |
| CILearningStrategy | <agrum/FMDP/SDyna/ILearningStrategy.h> |
| CIPlanningStrategy | <agrum/FMDP/SDyna/IPlanningStrategy.h> |
| CAbstractSimulator | <agrum/FMDP/simulation/abstractSimulator.h> |
| CFactorySimulator | A class to simulate the Factory problem |
| CFMDPSimulator | <agrum/FMDP/simulation/fmdpSimulator.h> |
| CStatesChecker | <agrum/FMDP/simulation/statesChecker.h> |
| CStatesCounter | <agrum/FMDP/simulation/statesCounter.h> |
| CTaxiSimulator | A class to simulate the Taxi problem |
| CInfluenceDiagramGenerator | <agrum/ID/generator/influenceDiagramGenerator.h> |
| CSimpleUTGenerator | Class for generating Utility Tables |
| CUTGenerator | Abstract class for generating Utility Tables |
| CShaferShenoyLIMIDInference | |
| CDecisionTensor | <agrum/ID/inference/decisionTensor.h> |
| CInfluenceDiagramInference | <agrum/ID/inference/influenceDiagramInference.h> |
| CInfluenceDiagram | Class representing an Influence Diagram |
| CBIFXMLIDReader | Read an influence diagram from an XML file with BIF format |
| CBIFXMLIDWriter | Writes an influence diagram in a XML files with BIF format |
| CIDReader | Pure virtual class for importing an ID from a file |
| CIDWriter | Pure virtual class for exporting an ID |
| CIMarkovRandomField | Class representing the minimal interface for Markov random field |
| CShaferShenoyMRFInference | <agrum/MRF/inference/ShaferShenoyMRFInference.h> |
| CEvidenceMRFInference | <agrum/MRF/inference/evidenceMRFInference.h> |
| CJointTargetedMRFInference | <agrum/MRF/inference/jointTargetedMRFInference.h> |
| CMarginalTargetedMRFInference | <agrum/MRF/inference/marginalTargetedMRFInference.h> |
| CMRFInference | <agrum/MRF/inference/MRFInference.h> |
| CMRFReader | Pure virtual class for reading a MRF from a file |
| CMRFWriter | Pure virtual class for writting a MRF to a file |
| CUAIMRFReader | Pure virtual class for reading a MRF from a file |
| CUAIMRFWriter | <agrum/MRF/io/UAI/UAIMRFWriter.h> |
| CO3prmBNReader | Read an O3PRM and transform the gum::prm::PRMSystem into gum::BayesNet |
| CO3prmBNWriter | <agrum/PRM/o3prm/O3prmBNWriter.h> |
| Nstd | STL namespace |
| C_auxiliary_print_tuple_ | |
| Nticpp | ticpp is a TinyXML wrapper that uses a lot more C++ ideals |
| CException | This is a ticpp exception class |
| CVisitor | Wrapper around TiXmlVisitor |
| CBase | Wrapper around TiXmlBase |
| CAttribute | Wrapper around TiXmlAttribute |
| CNode | Wrapper around TiXmlNode |
| CIterator | Iterator for conveniently stepping through Nodes and Attributes |
| CNodeImp | Implementation of Node wrapper |
| CComment | Wrapper around TiXmlComment |
| CText | Wrapper around TiXmlText |
| CDocument | Wrapper around TiXmlDocument |
| CElement | Wrapper around TiXmlElement |
| CDeclaration | Wrapper around TiXmlDeclaration |
| CStylesheetReference | Wrapper around TiXmlStylesheetReference |
| CAbstractScheduleMultiDim | Exception : The Schedule MultiDim Table is abstract |
| CAPPROX | |
| CArgumentError | Exception base for argument error |
| CCPTError | Exception base for CPT error |
| CDatabaseError | Error: An unknown error occurred while accessing a database |
| CDefaultInLabel | Exception : default in label |
| CDuplicateElement | Exception : a similar element already exists |
| CDuplicateLabel | Exception : a similar label already exists |
| CDuplicateScheduleMultiDim | Exception : There exists another identical Schedule MultiDim Table |
| CEstimator | Class for estimating tools for approximate inference |
| CFactoryError | Exception base for factory error |
| CFactoryInvalidState | Exception : invalid state error |
| CFatalError | Exception : fatal (unknown ?) error |
| CFormatNotFound | Exception : a I/O format was not found |
| CGraphError | Exception base for graph error |
| CHashTableConstIterator | Unsafe Const Iterators for hashtables |
| CHashTableIterator | Unsafe Iterators for hashtables |
| CHashTableIteratorSafe | Safe Iterators for hashtables |
| CImportanceInference | <agrum/BN/inference/importanceInference.h> |
| CIncompatibleEvidence | Exception : several evidence are incompatible together (proba=0) |
| CIncompatibleScorePrior | Error: The score already contains a different 'implicit' prior |
| CInvalidArc | Exception : there is something wrong with an arc |
| CInvalidArgument | Exception: at least one argument passed to a function is not what was expected |
| CInvalidArgumentsNumber | Exception: the number of arguments passed to a function is not what was expected |
| CInvalidDirectedCycle | Exception : existence of a directed cycle in a graph |
| CInvalidEdge | Exception : there is something wrong with an edge |
| CInvalidNode | Exception : node does not exist |
| CIOError | Exception : input/output problem |
| CKL | KL is the base class for KL computation betweens 2 BNs |
| CLearningError | Exceptions for learning |
| CMissingValueInDatabase | Error: The database contains some missing values |
| CMissingVariableInDatabase | Error: A name of variable is not found in the database |
| CMonteCarloInference | <agrum/BN/inference/monteCarloInference.h> |
| CNoChild | Exception : no child for a given node was found |
| CNoNeighbour | Exception : no neighbour to a given node was found |
| CNoParent | Exception : no parent for a given node was found |
| CNotFound | Exception : the element we looked for cannot be found |
| CNotImplementedYet | Exception : there is something wrong with an implementation |
| CNullElement | Exception : a pointer or a reference on a nullptr (0) object |
| COperationNotAllowed | Exception : operation not allowed |
| COutOfBounds | Exception : out of bound |
| CPossiblyIncompatibleScorePrior | Error: Due to its weight, the prior is currently compatible with the score but if you change the weight, it will become incompatible" |
| CPRMAggregate | Defines an aggregate in a PRM |
| CPRMTypeError | Exception : wrong subtype or subclass |
| CScheduleMultiDimError | Exception base for ScheduleMultiDim errors |
| CScheduleOperationError | Exception base for ScheduleOperator errors |
| CScoreMDL | Class for computing MDL scores |
| CSizeError | Exception : problem with size |
| CSyntaxError | Special exception for syntax errors in files |
| CThreadExecutor | The class enables to uses openMP to execute callables in parallel |
| CThreadExecutor | The class enables to launch std::threads to execute callables in parallel |
| 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 |
| CTypeError | Exception : wrong type for this operation |
| CUnavailableScheduleOperation | Exception : The Schedule Operation is not available yet |
| CUndefinedElement | Exception : a looked-for element could not be found |
| CUndefinedIteratorKey | Exception : iterator does not point to any valid key |
| CUndefinedIteratorValue | Exception : generic error on iterator |
| CUnexecutedScheduleOperation | Exception : The Schedule Operation has not been executed yet |
| CUnknownLabelInDatabase | Error: An unknown label is found in the database |
| CUnknownScheduleMultiDim | Exception : The Schedule MultiDim Table is unknown |
| CUnknownScheduleOperation | Exception : The Schedule Operation is unknown |
| CWeightedInference | <agrum/BN/inference/weightedInference.h> |
| CWrongClassElement | Exception: wrong PRMClassElement for this operation |
|
aGrUM 2.3.2 |
© PHW&CG&others - 2022 | DoXyGeN 1.16.1 |