| Cgum::KTBNGenerator< GUM_SCALAR >::_Arc_ | A (tail, head) endpoint pair, each as (base, slice) |
| Cstd::_auxiliary_print_tuple_< N > | |
| Cgum::FixedAllocator::_Chunk_ | Allocates objects of one given size |
| Cgum::learning::_GraphChangesGenerator4K2_ | |
| Cgum::learning::GraphChangesGenerator4K2< STRUCT_CONSTRAINT > | The basic class for computing the next graph changes possible in a structure learning algorithm |
| Cgum::CliqueGraph::_RunningIntersect_ | Structure used for the computation of the running intersection property |
| Cgum::KTBNInference< GUM_SCALAR >::_Series_ | A cached marginal time-series for one base: owned variable descriptors paired with their marginals, indexed by slice (single entry for an atemporal base). Descriptors are owned so tensors get a stable per-slice name rather than the reused ring-slot name they came from |
| Cgum::KTBNInference< GUM_SCALAR >::_Slot_ | One node of a window template: a base (index into baseNames) at a lag behind the window's current slice. lag == ATEMPORAL marks an atemporal base, which sits in every interface and never ages |
| Cgum::KTBNInference< GUM_SCALAR >::_Window_ | A compiled window: the junction tree of \(H_t = I_{t-1} \cup V_t\), rooted at the clique holding \(I_t\), plus everything needed to fill and message-pass it. Built once; windows 0..k-2 are the initial ones, window k-1 is the repeating one, re-entered from slice k-1 on |
| Cgum::AbstractFMDPFactory | A factory class to ease Factored Markov Decision Process construction |
| Cgum::FMDPFactory< GUM_ELEMENT > | A factory class to ease Factored Markov Decision Process construction |
| Cgum::AbstractLeaf | <agrum/FMDP/learning/datastructure/leaves/abstractLeaf.h> |
| Cgum::ComposedLeaf | <agrum/FMDP/learning/datastructure/leaves/composedLeaf.h> |
| Cgum::ConcreteLeaf< AttributeSelection, isScalar > | <agrum/FMDP/learning/datastructure/leaves/concreteLeaf.h> |
| Cgum::AbstractSimulator | <agrum/FMDP/simulation/abstractSimulator.h> |
| Cgum::FMDPSimulator | <agrum/FMDP/simulation/fmdpSimulator.h> |
| Cgum::FactorySimulator | A class to simulate the Factory problem |
| Cgum::TaxiSimulator | A class to simulate the Taxi problem |
| Cgum::ActionSet | A class to store the optimal actions |
| Cgum::AggregatorDecomposition< GUM_SCALAR > | <agrum/BN/inference/tools/aggregatorDecomposition.h> |
| Cgum::AlmostDifferent< T > | Indicate whether two elements are (almost) different or not |
| Cgum::AlmostDifferent< T * > | Indicate whether two elements are (almost) different or not |
| CAPPROX | |
| Cgum::LoopySamplingInference< GUM_SCALAR, APPROX > | <agrum/BN/inference/loopySamplingInference.h> |
| Cgum::ApproximationPolicy< GUM_SCALAR > | Mother class for all approximation policy classes |
| Cgum::ExactPolicy< GUM_SCALAR > | |
| Cgum::CNFWriter< GUM_SCALAR, ExactPolicy > | |
| Cgum::ContextualDependenciesCNFWriter< GUM_SCALAR, IApproximationPolicy > | <agrum/BN/io/cnf/ContextualDependenciesCNFWriter.h> |
| Cgum::FactorisedValuesCNFWriter< GUM_SCALAR, IApproximationPolicy > | <agrum/BN/io/cnf/FactorisedValuesCNFWriter.h> |
| Cgum::GeneralizedCNFWriter< GUM_SCALAR, IApproximationPolicy > | <agrum/BN/io/cnf/GeneralizedCNFWriter.h> |
| Cgum::CNFWriter< GUM_SCALAR, IApproximationPolicy > | Writes a IBayesNet in the BN format |
| Cgum::ApproximationPolicy< GUM_ELEMENT > | |
| Cgum::ExactPolicy< GUM_ELEMENT > | Class implementing exact approximation policy (meaning a value is approximate to itself) |
| Cgum::LinearApproximationPolicy< GUM_ELEMENT > | Class implementing linear approximation policy (meaning possible value are split out in interval) |
| Cgum::Arc | The base class for all directed edges |
| Cgum::ArcGraphPart | Classes for directed edge sets |
| Cgum::DiGraph | Base class for all oriented graphs |
| Cgum::DAG | Base class for dag |
| Cgum::MixedGraph | Base class for mixed graphs |
| Cgum::PDAG | Base class for partially directed acyclic graphs |
| Cgum::prm::gspan::DFSTree< GUM_SCALAR > | A DFSTree is used by gspan to sort lexicographically patterns discovered in an interface graph |
| Cgum::prm::gspan::Pattern | This contains all the information we want for a node in a DFSTree |
| Cgum::ArgMaxSet< GUM_SCALAR_VAL, GUM_SCALAR_SEQ > | Class to handle efficiently argMaxSet |
| Cgum::ArgumentMaximises< GUM_SCALAR > | Arg Max function object class |
| Cgum::ArgumentMaximisesAction< GUM_ELEMENT > | <agrum/FMDP/planning/actionSet.h> |
| Cgum::ASTtree< GUM_SCALAR > | Root abstract node for the AST of algebraic expressions |
| Cgum::ASTBinaryOp< GUM_SCALAR > | Base class for binary algebraic operators (e.g., +, -, ×, ÷) |
| Cgum::ASTdiv< GUM_SCALAR > | Elementwise division of two AST sub-expressions (left / right) |
| Cgum::ASTminus< GUM_SCALAR > | Difference of two AST sub-expressions (left minus right) |
| Cgum::ASTmult< GUM_SCALAR > | Elementwise product of two AST sub-expressions |
| Cgum::ASTplus< GUM_SCALAR > | Sum of two AST sub-expressions |
| Cgum::ASTjointProba< GUM_SCALAR > | Joint probability term ( \mathbb{P}(\mathrm{vars}) ) in an observational BN |
| Cgum::ASTposteriorProba< GUM_SCALAR > | Posterior probability term ( \mathbb{P}_{bn}(\mathrm{vars}\mid\mathrm{knw}) ) |
| Cgum::ASTsum< GUM_SCALAR > | Summation (marginalization) over one or more variables |
| Cgum::AVLTree< Val, Cmp > | AVL binary search tree |
| Cgum::AVLTreeIterator< Val, Cmp > | AVL binary search tree iterator |
| Cgum::AVLTreeIterator< Val, Cmp > | |
| Cgum::AVLTreeIteratorSafe< Val, Cmp > | |
| Cgum::AVLTreeReverseIteratorSafe< Val, Cmp > | |
| Cgum::AVLTreeReverseIterator< Val, Cmp > | |
| Cgum::AVLTreeIterator< Val, std::less< Val > > | |
| Cgum::AVLTreeIteratorSafe< Val, std::less< Val > > | |
| Cgum::AVLTreeReverseIteratorSafe< Val, Cmp > | AVL binary search tree safe (w.r.t |
| Cgum::AVLTreeIteratorSafe< Val, Cmp > | AVL binary search tree safe (w.r.t |
| Cgum::AVLTreeReverseIterator< Val, Cmp > | AVL binary search tree reverse iterator |
| Cgum::BarrenNodesFinder | Detect barren nodes for inference in Bayesian networks |
| Cgum::BayesBall | Implementation of Shachter's Bayes Balls algorithm |
| Cgum::BijectionImplementation< T1, T2, Gen > | A non scalar implementation of a Bijection |
| Cgum::Bijection< const DiscreteVariable *, const DiscreteVariable * > | |
| Cgum::BijectionImplementation< const gum::DiscreteVariable *, const gum::DiscreteVariable *, std::is_scalar< const gum::DiscreteVariable * >::value &&std::is_scalar< const gum::DiscreteVariable * >::value > | |
| Cgum::Bijection< const gum::DiscreteVariable *, const gum::DiscreteVariable * > | |
| Cgum::BijectionImplementation< const gum::DiscreteVariable *, const gum::MultiDimFunctionGraph< GUM_ELEMENT, ExactTerminalNodePolicy > *, std::is_scalar< const gum::DiscreteVariable * >::value &&std::is_scalar< const gum::MultiDimFunctionGraph< GUM_ELEMENT, ExactTerminalNodePolicy > * >::value > | |
| Cgum::Bijection< const gum::DiscreteVariable *, const gum::MultiDimFunctionGraph< GUM_ELEMENT, ExactTerminalNodePolicy > * > | |
| Cgum::BijectionImplementation< const gum::DiscreteVariable *, NodeId, std::is_scalar< const gum::DiscreteVariable * >::value &&std::is_scalar< NodeId >::value > | |
| Cgum::Bijection< const gum::DiscreteVariable *, NodeId > | |
| Cgum::BijectionImplementation< const gum::IScheduleMultiDim *, Idx, std::is_scalar< const gum::IScheduleMultiDim * >::value &&std::is_scalar< Idx >::value > | |
| Cgum::Bijection< const gum::IScheduleMultiDim *, Idx > | |
| Cgum::BijectionImplementation< const gum::IScheduleMultiDim *, NodeId, std::is_scalar< const gum::IScheduleMultiDim * >::value &&std::is_scalar< NodeId >::value > | |
| Cgum::Bijection< const gum::IScheduleMultiDim *, NodeId > | |
| Cgum::BijectionImplementation< GraphHash, Size, std::is_scalar< GraphHash >::value &&std::is_scalar< Size >::value > | |
| Cgum::Bijection< GraphHash, Size > | |
| Cgum::BijectionImplementation< gum::Instantiation *, gum::Instantiation *, std::is_scalar< gum::Instantiation * >::value &&std::is_scalar< gum::Instantiation * >::value > | |
| Cgum::Bijection< gum::Instantiation *, gum::Instantiation * > | |
| Cgum::BijectionImplementation< Idx, const std::string *, std::is_scalar< Idx >::value &&std::is_scalar< const std::string * >::value > | |
| Cgum::Bijection< Idx, const std::string * > | |
| Cgum::BijectionImplementation< Idx, gum::prm::gspan::LabelData *, std::is_scalar< Idx >::value &&std::is_scalar< gum::prm::gspan::LabelData * >::value > | |
| Cgum::Bijection< Idx, gum::prm::gspan::LabelData * > | |
| Cgum::BijectionImplementation< NodeId, bool, std::is_scalar< NodeId >::value &&std::is_scalar< bool >::value > | |
| Cgum::Bijection< NodeId, bool > | |
| Cgum::BijectionImplementation< NodeId, const gum::DiscreteVariable *, std::is_scalar< NodeId >::value &&std::is_scalar< const gum::DiscreteVariable * >::value > | |
| Cgum::Bijection< NodeId, const gum::DiscreteVariable * > | |
| Cgum::BijectionImplementation< NodeId, double, std::is_scalar< NodeId >::value &&std::is_scalar< double >::value > | |
| Cgum::Bijection< NodeId, double > | |
| Cgum::BijectionImplementation< NodeId, gum::prm::gspan::Pattern *, std::is_scalar< NodeId >::value &&std::is_scalar< gum::prm::gspan::Pattern * >::value > | |
| Cgum::Bijection< NodeId, gum::prm::gspan::Pattern * > | |
| Cgum::BijectionImplementation< NodeId, gum::ScheduleOperator *, std::is_scalar< NodeId >::value &&std::is_scalar< gum::ScheduleOperator * >::value > | |
| Cgum::Bijection< NodeId, gum::ScheduleOperator * > | |
| Cgum::BijectionImplementation< NodeId, GUM_ELEMENT, std::is_scalar< NodeId >::value &&std::is_scalar< GUM_ELEMENT >::value > | |
| Cgum::Bijection< NodeId, GUM_ELEMENT > | |
| Cgum::BijectionImplementation< NodeId, Size, std::is_scalar< NodeId >::value &&std::is_scalar< Size >::value > | |
| Cgum::Bijection< NodeId, Size > | |
| Cgum::BijectionImplementation< NodeId, std::size_t, std::is_scalar< NodeId >::value &&std::is_scalar< std::size_t >::value > | |
| Cgum::Bijection< NodeId, std::size_t > | |
| Cgum::BijectionImplementation< NodeId, std::string, std::is_scalar< NodeId >::value &&std::is_scalar< std::string >::value > | |
| Cgum::Bijection< NodeId, std::string > | |
| Cgum::BijectionImplementation< std::size_t, std::string, std::is_scalar< std::size_t >::value &&std::is_scalar< std::string >::value > | |
| Cgum::Bijection< std::size_t, std::string > | |
| Cgum::BijectionImplementation< std::string, NodeId, std::is_scalar< std::string >::value &&std::is_scalar< NodeId >::value > | |
| Cgum::Bijection< std::string, NodeId > | |
| Cgum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value > | |
| Cgum::Bijection< T1, T2 > | Set of pairs of elements with fast search for both elements |
| Cgum::BijectionIterator< T1, T2 > | Unsafe iterators for bijection |
| Cgum::BijectionIteratorGet< gen > | Dummy classes for discriminating scalars and non-scalars operators and -> wihtout any overhead |
| Cgum::BijectionIteratorGet< true > | |
| Cgum::BijectionIteratorSafe< T1, T2 > | Safe iterators for bijectionIterator |
| Cgum::BinaryJoinTreeConverter | |
| Cgum::BinaryJoinTreeConverterDefault | |
| Cgum::BinSearchTree< Val, Cmp, Node > | A generic binary search tree |
| Cgum::BinSearchTreeIterator< Val, Cmp, Node > | A Generic binary search tree |
| Cgum::BinTreeNode< Val > | Nodes of a binary trees |
| Cgum::BNdistance< GUM_SCALAR > | |
| Cgum::ExactBNdistance< GUM_SCALAR > | ExactBNdistance computes exactly the KL divergence betweens 2 BNs |
| Cgum::GibbsBNdistance< GUM_SCALAR > | GibbsKL computes the KL divergence betweens 2 BNs using an approximation pattern: GIBBS sampling |
| Cgum::MCBNDistance< GUM_SCALAR > | MCBNDistance computes the KL divergence betweens 2 BNs using an approximation pattern: independent (forward/topological) Monte Carlo sampling |
| CBNGumReader | Class for reading a Bayesian network from a GUM (json) file |
| Cgum::BNReader< GUM_SCALAR > | Pure virtual class for reading a BN from a file |
| Cgum::BIFReader< GUM_SCALAR > | Definition of templatized reader of BIF files for Bayesian networks |
| Cgum::BIFXMLBNReader< GUM_SCALAR > | <agrum/BN/io/BIFXML/BIFXMLBNReader.h> |
| Cgum::DSLReader< GUM_SCALAR > | Pure virtual class for reading a BN from a file |
| Cgum::GumBNReader< GUM_SCALAR > | |
| Cgum::NetReader< GUM_SCALAR > | Pure virtual class for reading a BN from a file |
| Cgum::O3prmBNReader< GUM_SCALAR > | Read an O3PRM and transform the gum::prm::PRMSystem into gum::BayesNet |
| Cgum::UAIBNReader< GUM_SCALAR > | Pure virtual class for reading a BN from a file |
| Cgum::XDSLBNReader< GUM_SCALAR > | <agrum/BN/io/XDSL/XDSLBNReader.h> |
| Cgum::BNWriter< GUM_SCALAR > | Virtual class for writing a BN to a file |
| Cgum::CNFWriter< GUM_SCALAR, ExactPolicy > | |
| Cgum::BIFWriter< GUM_SCALAR > | Writes a IBayesNet in the BIF format |
| Cgum::BIFXMLBNWriter< GUM_SCALAR > | <agrum/BN/io/BIFXML/BIFXMLBNWriter.h> |
| Cgum::CNFWriter< GUM_SCALAR, IApproximationPolicy > | Writes a IBayesNet in the BN format |
| Cgum::DSLWriter< GUM_SCALAR > | Writes a IBayesNet in the DSL format |
| Cgum::GumBNWriter< GUM_SCALAR > | Writes a IBayesNet in the GUM json format |
| Cgum::NetWriter< GUM_SCALAR > | Writes a IBayesNet in the BN format |
| Cgum::O3prmBNWriter< GUM_SCALAR > | <agrum/PRM/o3prm/O3prmBNWriter.h> |
| Cgum::UAIBNWriter< GUM_SCALAR > | Writes a Bayes net in a text file with UAI format |
| Cgum::XDSLBNWriter< GUM_SCALAR > | <agrum/BN/io/XDSLXML/XDSLBNWriter.h> |
| Cgum::CausalFormula< GUM_SCALAR > | A container for an identified causal query |
| Cgum::CausalImpact< GUM_SCALAR > | Builds a CausalFormula for a query (d-sep -> backdoor -> frontdoor -> (optional) do-calculus) |
| Cgum::CausalModel< GUM_SCALAR > | A causal model pairing a causal DAG with an optional observational BayesNet |
| Cgum::prm::StructuredInference< GUM_SCALAR >::CData | Private structure to represent data about a Class<GUM_SCALAR> |
| Cgum::DAGCycleDetector::Change | Base class indicating the possible changes |
| Cgum::DAGCycleDetector::ArcAdd | Class to indicate that we wish to add a new arc |
| Cgum::DAGCycleDetector::ArcDel | Class to indicate that we wish to remove an arc |
| Cgum::DAGCycleDetector::ArcReverse | Class to indicate that we wish to reverse an arc |
| Cgum::Chi2 | Static math utilities for the chi2 distribution |
| Cgum::ChiSquare | <agrum/FMDP/learning/core/testPolicy/chiSquare.h> |
| Cgum::prm::ClassDependencyGraph< GUM_SCALAR > | This class represent the dependencies of all classes in a PRM<GUM_SCALAR> |
| Cgum::CompleteProjectionRegister4MultiDim< GUM_ELEMENT > | A container for registering complete projection functions on multiDimImplementations, i.e., functions projecting tables over all their variables |
| Cgum::CompleteProjections4MultiDimInitialize< GUM_ELEMENT > | Class used to register complete projections over non-pointers types |
| Cgum::CompleteProjections4MultiDimInitialize< GUM_ELEMENT * > | Class used to register complete projections over pointers types |
| Cgum::ContingencyTable< GUM_ELEMENT_A, GUM_ELEMENT_B > | <agrum/FMDP/learning/core/contingencyTable.h> |
| Cgum::Counterfactual< GUM_ELEMENT > | Computes a counterfactual distribution by building a twin model, then evaluating a causal effect on that twin and adapting the result back to the original model’s variables |
| Cgum::credal::CredalNet< GUM_SCALAR > | Class template representing a Credal Network |
| Cgum::learning::CSVParser | Class for fast parsing of CSV file (never more than one line in application memory) |
| Cgum::DAGCycleDetector | A class for detecting directed cycles in DAGs when trying to apply many changes to the graph |
| Cgum::learning::IBNLearner::Database | Helper to easily read databases |
| Cgum::learning::DBCell | The class representing the original values of the cells of databases |
| Cgum::learning::DBHandler< T_DATA > | The base class for all database handlers |
| Cgum::learning::IDatabaseTable< T_DATA >::Handler | (unsafe) handler for the tabular databases |
| Cgum::learning::IDatabaseTable< T_DATA >::HandlerSafe | Safe handler of the tabular databases |
| Cgum::learning::DBRow< T_DATA > | The class for storing a record in a database |
| Cgum::learning::DBRowGenerator | The base class for all DBRow generators |
| Cgum::learning::DBRowGeneratorWithBN< double > | |
| Cgum::learning::DBRowGeneratorEM< GUM_SCALAR > | A DBRowGenerator class that returns incomplete rows as EM would do |
| Cgum::learning::DBRowGenerator4CompleteRows | A DBRowGenerator class that returns the rows that are complete (fully observed) w.r.t |
| Cgum::learning::DBRowGeneratorIdentity | A DBRowGenerator class that returns exactly the rows it gets in input |
| Cgum::learning::DBRowGeneratorWithBN< GUM_SCALAR > | Base class for DBRowGenerator classes that use a BN for computing their outputs |
| Cgum::learning::DBRowGeneratorParser | 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 |
| Cgum::learning::DBRowGeneratorSet | The class used to pack sets of generators |
| Cgum::learning::DBTranslatedValue | The union class for storing the translated values in learning databases |
| Cgum::learning::DBTranslator | The base class for all the tabular database cell translators |
| Cgum::learning::DBTranslator4ContinuousVariable | The databases' cell translators for continuous variables |
| Cgum::learning::DBTranslator4DiscretizedVariable | The databases' cell translators for discretized variables |
| Cgum::learning::DBTranslator4IntegerVariable | The databases' cell translators for integer variables |
| Cgum::learning::DBTranslator4LabelizedVariable | The databases' cell translators for labelized variables |
| Cgum::learning::DBTranslator4NumericalDiscreteVariable | The databases' cell translators for numerical Discrete variables |
| Cgum::learning::DBTranslator4RangeVariable | The databases' cell translators for range variables |
| Cgum::learning::DBTranslatorSet | Class for packing together the translators used to preprocess the datasets |
| Cgum::DecisionTensor< GUM_SCALAR > | <agrum/ID/inference/decisionTensor.h> |
| Cgum::prm::gspan::DFSCode | Reprensent a Depth First Search coding of a graph |
| Cgum::Dirichlet | A class for sampling w.r.t |
| Cgum::DoCalculus< GUM_SCALAR > | Instance-based do-calculus utilities bound to a single CausalModel |
| Cgum::DoorCriteria | Implements Backdoor and Frontdoor criteria utilities for a DAG |
| Cgum::dSeparationAlgorithm | D-separation algorithm as described in Koller & Friedman (2009) |
| Cgum::dummyHash< Key > | |
| Cgum::Edge | The base class for all undirected edges |
| Cgum::prm::gspan::EdgeCode | Represent a DFS code used by gspan |
| Cgum::prm::gspan::EdgeData< GUM_SCALAR > | Inner class to handle data about edges in graph |
| Cgum::EdgeGraphPart | Classes for undirected edge sets |
| Cgum::UndiGraph | Base class for undirected graphs |
| Cgum::CliqueGraph | Basic graph of cliques |
| Cgum::MixedGraph | Base class for mixed graphs |
| Cgum::PAG | Partial Ancestral Graph: undirected topology with endpoint marks |
| Cgum::prm::gspan::EdgeGrowth< GUM_SCALAR > | This class is used to define an edge growth of a pattern in this DFSTree |
| Cgum::ScheduleMultiDim< TABLE >::ElementType< T > | Metaprogramming to get the types of the elements stored into the ScheduleMultidims |
| Cgum::ScheduleMultiDim< TABLE >::ElementType< CONTAINER< T, Args... > > | |
| Cgum::EliminationSequenceStrategy | The base class for all elimination sequence algorithms used by triangulation algorithms |
| Cgum::OrderedEliminationSequenceStrategy | An Elimination sequence algorithm that imposes a given complete ordering on the nodes elimination sequence |
| Cgum::PartialOrderedEliminationSequenceStrategy | 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 |
| Cgum::DefaultPartialOrderedEliminationSequenceStrategy | An Elimination sequence algorithm that imposes a given partial ordering on the nodes elimination sequence |
| Cgum::UnconstrainedEliminationSequenceStrategy | 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 |
| Cgum::DefaultEliminationSequenceStrategy | An efficient unconstrained elimination sequence algorithm |
| Cgum::ErrorsContainer | This class is used contain and manipulate gum::ParseError |
| Cgum::GumBNReader< GUM_SCALAR > | |
| Cgum::GumIDReader< GUM_SCALAR > | Reads an InfluenceDiagram from a GUM (json) file |
| Cgum::GumMRFReader< GUM_SCALAR > | Reads a MarkovRandomField from a GUM (json) file |
| Cgum::EssentialGraph | Class building the essential graph from a BN |
| CEstimator | Class for estimating tools for approximate inference |
| Cgum::Estimator< GUM_SCALAR > | |
| Cstd::exception | STL class |
| Cgum::Exception | Base class for all aGrUM's exceptions |
| CArgumentError | Exception base for argument error |
| CDuplicateElement | Exception : a similar element already exists |
| CDuplicateLabel | Exception : a similar label already exists |
| COutOfBounds | Exception : out of bound |
| CCPTError | Exception base for CPT error |
| CFactoryError | Exception base for factory error |
| CFactoryInvalidState | Exception : invalid state error |
| CPRMTypeError | Exception : wrong subtype or subclass |
| CTypeError | Exception : wrong type for this operation |
| CWrongClassElement | Exception: wrong PRMClassElement for this operation |
| CFatalError | Exception : fatal (unknown ?) error |
| CFormatNotFound | Exception : a I/O format was not found |
| CGraphError | Exception base for graph error |
| CDefaultInLabel | Exception : default in label |
| CInvalidArc | Exception : there is something wrong with an arc |
| 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 |
| 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 |
| CHedgeException | Exception : "hedge" (witness of non-identifiability) is detected in do-calculus / ID computations |
| CIOError | Exception : input/output problem |
| CSyntaxError | Special exception for syntax errors in files |
| 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 |
| CLearningError | Exceptions for learning |
| CDatabaseError | Error: An unknown error occurred while accessing a database |
| CIncompatibleScorePrior | Error: The score already contains a different 'implicit' prior |
| CMissingValueInDatabase | Error: The database contains some missing values |
| CMissingVariableInDatabase | Error: A name of variable is not found in the database |
| CPossiblyIncompatibleScorePrior | Error: Due to its weight, the prior is currently compatible with the score but if you change the weight, it will become incompatible" |
| CUnknownLabelInDatabase | Error: An unknown label is found in the database |
| 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 |
| CScheduleMultiDimError | Exception base for ScheduleMultiDim errors |
| CAbstractScheduleMultiDim | Exception : The Schedule MultiDim Table is abstract |
| CDuplicateScheduleMultiDim | Exception : There exists another identical Schedule MultiDim Table |
| CUnknownScheduleMultiDim | Exception : The Schedule MultiDim Table is unknown |
| CScheduleOperationError | Exception base for ScheduleOperator errors |
| CUnavailableScheduleOperation | Exception : The Schedule Operation is not available yet |
| CUnexecutedScheduleOperation | Exception : The Schedule Operation has not been executed yet |
| CUnknownScheduleOperation | Exception : The Schedule Operation is unknown |
| CSizeError | Exception : problem with size |
| 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 |
| CUndefinedIteratorValue | Exception : generic error on iterator |
| Cgum::XmlException | Thrown by XmlDocument/XmlElement on any ticpp/tinyxml parse or access error |
| CScheduleStorageMethod::Execution | |
| Cgum::ScheduleStorage< TABLE, CONTAINER > | Class for storing multidimensional tables into containers (sets, etc.) |
| Cgum::FixedAllocator | Allocates objects of one given size |
| Cgum::FMDP< GUM_ELEMENT > | This class is used to implement factored decision process |
| Cgum::FMDPReader< GUM_ELEMENT > | Pure virtual class for reading a FMDP from a file |
| Cgum::FMDPDatReader< GUM_ELEMENT > | Definition of templatized reader of FMDPDat files for Factored Markov Decision Processes |
| Cgum::Formula | Evaluates a string as a algebraic formula |
| Cgum::FormulaPart | Represents part of a formula |
| Cgum::FusionContext< isInitial > | <agrum/FMDP/learning/datastructure/leaves/fusionContext.h> |
| Cgum::GammaLog2 | The class for computing Log2 (Gamma(x)) |
| Cgum::GibbsOperator< GUM_SCALAR > | Class containing all variables and methods required for Gibbssampling |
| Cgum::GibbsBNdistance< GUM_SCALAR > | GibbsKL computes the KL divergence betweens 2 BNs using an approximation pattern: GIBBS sampling |
| Cgum::GibbsSampling< GUM_SCALAR > | <agrum/BN/inference/gibbsSampling.h> |
| Cgum::LoopySamplingInference< GUM_SCALAR, GibbsSampling > | |
| Cgum::learning::GraphChange | |
| Cgum::learning::ArcAddition | The class for notifying learning algorithms of new arc additions |
| Cgum::learning::ArcDeletion | The class for notifying learning algorithms of arc removals |
| Cgum::learning::ArcReversal | The class for notifying learning algorithms of arc reversals |
| Cgum::learning::ArcTriangleDeletion1 | The graph change substituting a triangle node1->node2->node3 + node1->node3 into v-structure node2->node1<-node3 |
| Cgum::learning::ArcTriangleDeletion2 | The graph change substituting a triangle node1->node2->node3 + node1->node3 into v-structure node1->node2<-node3 |
| Cgum::learning::EdgeAddition | The class for notifying learning algorithms of new edge additions |
| Cgum::learning::EdgeDeletion | The class for notifying learning algorithms of edge removals |
| Cgum::learning::GraphChangesSelector4DiGraph< INVARIABLE_CONSTRAINT_TYPE, VARIABLE_CONSTRAINT_TYPE > | The mecanism to compute the next available graph changes for directed structure learning search algorithms |
| Cgum::GraphicalModel | Virtual base class for probabilistic graphical models |
| Cgum::DiscreteGraphicalModel | <agrum/base/graphicalModels/discreteGraphicalModel.h> |
| Cgum::DAGmodel | Virtual base class for PGMs using a DAG |
| Cgum::IBayesNet< GUM_SCALAR > | Class representing the minimal interface for Bayesian network with no numerical data |
| Cgum::BayesNet< double > | |
| Cgum::BayesNet< GUM_SCALAR > | Class representing a Bayesian network |
| Cgum::BayesNetFragment< GUM_SCALAR > | Portion of a BN identified by the list of nodes and a BayesNet |
| Cgum::prm::ClassBayesNet< GUM_SCALAR > | This class decorates a gum::prm::Class<GUM_SCALAR> has an IBaseBayesNet |
| Cgum::prm::InstanceBayesNet< GUM_SCALAR > | This class decorates an PRMInstance<GUM_SCALAR> as an IBaseBayesNet |
| Cgum::InfluenceDiagram< GUM_SCALAR > | Class representing an Influence Diagram |
| Cgum::UGmodel | Virtual base class for PGMs using a undirected graph |
| Cgum::IMarkovRandomField< GUM_SCALAR > | Class representing the minimal interface for Markov random field |
| Cgum::GraphicalModelInference< GUM_SCALAR > | <agrum/base/graphicalModels/graphicalModel.h> |
| Cgum::BayesNetInference< GUM_SCALAR > | <agrum/BN/inference/BayesNetInference.h> |
| Cgum::EvidenceInference< GUM_SCALAR > | <agrum/BN/inference/evidenceInference.h> |
| Cgum::LazyPropagation< GUM_SCALAR > | Implementation of a Shafer-Shenoy's-like version of lazy propagation for inference in Bayesian networks |
| Cgum::ShaferShenoyInference< GUM_SCALAR > | Implementation of Shafer-Shenoy's propagation algorithm for inference in Bayesian networks |
| Cgum::MarginalTargetedInference< GUM_SCALAR > | <agrum/BN/inference/marginalTargetedInference.h> |
| Cgum::ApproximateInference< GUM_SCALAR > | |
| Cgum::LoopyBeliefPropagation< GUM_SCALAR > | <agrum/BN/inference/loopyBeliefPropagation.h> |
| Cgum::SamplingInference< GUM_SCALAR > | <agrum/BN/inference/samplingInference.h> |
| Cgum::GibbsSampling< GUM_SCALAR > | <agrum/BN/inference/gibbsSampling.h> |
| Cgum::ImportanceSampling< GUM_SCALAR > | |
| Cgum::LoopySamplingInference< GUM_SCALAR, ImportanceSampling > | |
| Cgum::MonteCarloSampling< GUM_SCALAR > | |
| Cgum::LoopySamplingInference< GUM_SCALAR, MonteCarloSampling > | |
| Cgum::WeightedSampling< GUM_SCALAR > | |
| Cgum::LoopySamplingInference< GUM_SCALAR, WeightedSampling > | |
| Cgum::JointTargetedInference< GUM_SCALAR > | <agrum/BN/inference/jointTargetedInference.h> |
| Cgum::LazyPropagation< GUM_SCALAR > | Implementation of a Shafer-Shenoy's-like version of lazy propagation for inference in Bayesian networks |
| Cgum::ShaferShenoyInference< GUM_SCALAR > | Implementation of Shafer-Shenoy's propagation algorithm for inference in Bayesian networks |
| Cgum::VariableElimination< GUM_SCALAR > | Implementation of a Variable Elimination's-like version of lazy propagation for inference in Bayesian networks |
| Cgum::InfluenceDiagramInference< GUM_SCALAR > | <agrum/ID/inference/influenceDiagramInference.h> |
| Cgum::ShaferShenoyLIMIDInference< GUM_SCALAR > | |
| Cgum::MRFInference< GUM_SCALAR > | <agrum/MRF/inference/MRFInference.h> |
| Cgum::EvidenceMRFInference< GUM_SCALAR > | <agrum/MRF/inference/evidenceMRFInference.h> |
| Cgum::ShaferShenoyMRFInference< GUM_SCALAR > | <agrum/MRF/inference/ShaferShenoyMRFInference.h> |
| Cgum::MarginalTargetedMRFInference< GUM_SCALAR > | <agrum/MRF/inference/marginalTargetedMRFInference.h> |
| Cgum::JointTargetedMRFInference< GUM_SCALAR > | <agrum/MRF/inference/jointTargetedMRFInference.h> |
| Cgum::ShaferShenoyMRFInference< GUM_SCALAR > | <agrum/MRF/inference/ShaferShenoyMRFInference.h> |
| Cgum::learning::GreaterAbsPairOn2nd | |
| Cgum::learning::GreaterPairOn2nd | |
| Cgum::learning::GreaterTupleOnLast | |
| Cgum::prm::GSpan< GUM_SCALAR > | This class discovers pattern in a PRM<GUM_SCALAR>'s PRMSystem<GUM_SCALAR> to speed up structured inference |
| Cgum::HashFunc< key > | This class should be useless as only its specializations should be used |
| Cgum::HashFuncBase< Key > | All hash functions should inherit from this class |
| Cgum::HashFuncLargeCastKey< Key > | Generic hash functions for keys castable as Size and whose size is precisely twice that of Size |
| Cgum::HashFuncMediumCastKey< Key > | Generic hash functions for keys castable as Size and whose size is precisely that of Size |
| Cgum::HashFuncSmallCastKey< Key > | Generic hash functions for keys castable as Size and whose size is strictly smaller than that of Size |
| Cgum::HashFuncSmallKey< Key > | Generic hash functions for numeric keys smaller than or equal to Size |
| Cgum::HashFuncBase< bool > | |
| Cgum::HashFuncSmallKey< bool > | |
| Cgum::HashFunc< bool > | Hash function for booleans |
| Cgum::HashFuncBase< credal::lp::LpCol > | |
| Cgum::HashFunc< credal::lp::LpCol > | |
| Cgum::HashFuncBase< Debug > | |
| Cgum::HashFunc< Debug > | Hash function for gum::Debug |
| Cgum::HashFuncBase< Instantiation > | |
| Cgum::HashFunc< Instantiation > | Hash function for gum::Instantiation |
| Cgum::HashFuncBase< int > | |
| Cgum::HashFuncSmallKey< int > | |
| Cgum::HashFunc< int > | Hash function for integers |
| Cgum::HashFuncBase< learning::ArcAddition > | |
| Cgum::HashFunc< learning::ArcAddition > | Hash function for Arc Additions |
| Cgum::HashFuncBase< learning::ArcDeletion > | |
| Cgum::HashFunc< learning::ArcDeletion > | Hash function for Arc Deletions |
| Cgum::HashFuncBase< learning::ArcReversal > | |
| Cgum::HashFunc< learning::ArcReversal > | Hash function for Arc Reversals |
| Cgum::HashFuncBase< learning::ArcTriangleDeletion1 > | |
| Cgum::HashFunc< learning::ArcTriangleDeletion1 > | Hash function for Arc Triangle Deletions creating a v-structure in node 1 |
| Cgum::HashFuncBase< learning::ArcTriangleDeletion2 > | |
| Cgum::HashFunc< learning::ArcTriangleDeletion2 > | Hash function for Arc Triangle Deletions creating a v-structure in node 2 |
| Cgum::HashFuncBase< learning::EdgeAddition > | |
| Cgum::HashFunc< learning::EdgeAddition > | Hash function for Edge Additions |
| Cgum::HashFuncBase< learning::EdgeDeletion > | |
| Cgum::HashFunc< learning::EdgeDeletion > | Hash function for Edge Deletions |
| Cgum::HashFuncBase< learning::GraphChange > | |
| Cgum::HashFunc< learning::GraphChange > | Hash function for Graph Changes |
| Cgum::HashFuncBase< learning::IdCondSet > | |
| Cgum::HashFunc< learning::IdCondSet > | Hash function for idSets |
| Cgum::HashFuncBase< long > | |
| Cgum::HashFuncSmallKey< long > | |
| Cgum::HashFunc< long > | Hash function for long integers |
| Cgum::HashFuncBase< Set< T > > | |
| Cgum::HashFunc< Set< T > > | Hash function for sets of int |
| Cgum::HashFuncBase< std::pair< Key1, Key2 > > | |
| Cgum::HashFunc< std::pair< Key1, Key2 > > | |
| Cgum::HashFuncBase< std::shared_ptr< Type > > | |
| Cgum::HashFunc< std::shared_ptr< Type > > | Hash function for shared pointers |
| Cgum::HashFuncBase< std::string > | |
| Cgum::HashFunc< std::string > | Hash function for strings |
| Cgum::HashFuncBase< std::tuple< unsigned int, unsigned int, unsigned int > > | |
| Cgum::HashFunc< std::tuple< unsigned int, unsigned int, unsigned int > > | Hash function for tuple (unsigned int, unsigned int,unsigned int) |
| Cgum::HashFuncBase< std::vector< Idx > > | |
| Cgum::HashFunc< std::vector< Idx > > | Hash function for vectors of gum::Idx |
| Cgum::HashFuncBase< unsigned int > | |
| Cgum::HashFuncSmallKey< unsigned int > | |
| Cgum::HashFunc< unsigned int > | Hash function for unsigned integers |
| Cgum::HashFuncBase< unsigned long > | |
| Cgum::HashFuncSmallKey< unsigned long > | |
| Cgum::HashFunc< unsigned long > | Hash function for unsigned long integers |
| Cgum::HashFuncCastKey< Key > | Generic hash functions for keys castable as Size whose size is either smaller than Size, or equal to that of one or two Size |
| Cgum::HashFuncConditionalType<... > | This class enables to safely define hash functions for types that may or may not already has defined hash functions |
| Cgum::HashFuncConditionalType< Key > | |
| Cgum::HashFuncConditionalType< KEY_TYPE, FIRST_TYPE, OTHER_TYPES... > | |
| Cgum::HashFuncConditionalType< KEY_TYPE, TYPE > | |
| Cgum::HashFuncConst | Useful constants for hash functions |
| Cgum::HashTable< Key, Val > | The class for generic Hash Tables |
| Cgum::HashTableBucket< Key, Val > | A recipient for a pair of key value in a gum::HashTableList |
| Cgum::HashTableConst | Parameters specifying the default behavior of the hashtables |
| CHashTableConstIterator< Key, Val > | Unsafe Const Iterators for hashtables |
| CHashTableIterator< Key, Val > | Unsafe Iterators for hashtables |
| Cgum::HashTableConstIteratorSafe< Key, Val > | Safe Const Iterators for hashtables |
| CHashTableIteratorSafe | Safe Iterators for hashtables |
| Cgum::HashTableList< Key, Val > | A chained list used by gum::HashTable |
| Cgum::Heap< Val, Cmp > | Heap data structure |
| Cgum::IApproximationSchemeConfiguration | Approximation Scheme |
| Cgum::ApproximationScheme | Approximation Scheme |
| Cgum::ApproximateInference< GUM_SCALAR > | |
| Cgum::GibbsBNdistance< GUM_SCALAR > | GibbsKL computes the KL divergence betweens 2 BNs using an approximation pattern: GIBBS sampling |
| Cgum::MCBNDistance< GUM_SCALAR > | MCBNDistance computes the KL divergence betweens 2 BNs using an approximation pattern: independent (forward/topological) Monte Carlo sampling |
| Cgum::credal::InferenceEngine< GUM_SCALAR > | Abstract class template representing a CredalNet inference engine |
| Cgum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > > | |
| Cgum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine > | <agrum/CN/CNMonteCarloSampling.h> |
| Cgum::credal::CNLoopyPropagation< GUM_SCALAR > | <agrum/CN/CNLoopyPropagation.h> |
| Cgum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine > | Class template representing a CredalNet inference engine using one or more IBayesNet inference engines such as LazyPropagation |
| Cgum::learning::ConstraintBasedLearning | Abstract base class for constraint-based structure learning algorithms |
| Cgum::learning::CIBasedLearning | Abstract base for CI-test-based causal structure learning (PC, FCI) |
| Cgum::learning::FCI | Fast Causal Inference — PAG learning via constraint-based methods |
| Cgum::learning::PC | PC (Peter-Clark) constraint-based structure learning algorithm |
| Cgum::learning::Miic | The MIIC learning algorithm |
| Cgum::learning::EMApproximationScheme | A class for parameterizing EM's parameter learning approximations |
| Cgum::learning::DAG2BNLearner | A class that, given a structure and a parameter estimator returns a full Bayes net |
| Cgum::learning::GreedyHillClimbing | The greedy hill climbing learning algorithm (for directed graphs) |
| Cgum::learning::K2 | The K2 algorithm |
| Cgum::learning::GreedyThickThinning | The greedy thick-thinning learning algorithm (for directed graphs) |
| Cgum::learning::LocalSearchWithTabuList | The local search with tabu list learning algorithm (for directed graphs) |
| Cgum::learning::SimpleMiic | The miic learning algorithm |
| Cgum::learning::IBNLearner | A pack of learning algorithms that can easily be used |
| Cgum::learning::BNLearner< GUM_SCALAR > | A pack of learning algorithms that can easily be used |
| Cgum::IBayesNetFactory | 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) |
| Cgum::BayesNetFactory< GUM_SCALAR > | A factory class to ease BayesNet construction |
| Cgum::__sig__::IConnector< Args > | Abstract interface for signal connectors with variadic arguments |
| Cgum::__sig__::IConnector< Args... > | |
| Cgum::__sig__::Connector< TargetClass, Args > | Concrete connector binding a target object and its member function |
| Cgum::ICPTDisturber< GUM_SCALAR > | Abstract class for Modifying Conditional Probability Tables |
| Cgum::SimpleCPTDisturber< GUM_SCALAR > | <agrum/BN/generator/simpleCPTDisturber.h> |
| Cgum::MCBayesNetGenerator< GUM_SCALAR, SimpleCPTGenerator, SimpleCPTDisturber > | |
| Cgum::MaxInducedWidthMCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber > | MaxInducedWidthMCBayesNetGenerator.h <agrum/BN/generator/SimpleMCayesNetGenerator.h> |
| Cgum::MaxParentsMCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber > | <agrum/BN/generator/SimpleMCayesNetGenerator.h> |
| Cgum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber > | <agrum/BN/generator/MCayesNetGenerator.h> |
| Cgum::ICPTGenerator< GUM_SCALAR > | Abstract class for generating Conditional Probability Tables |
| Cgum::IBayesNetGenerator< GUM_SCALAR, ICPTGenerator > | Class for generating Bayesian networks |
| Cgum::SimpleCPTGenerator< GUM_SCALAR > | <agrum/BN/generator/simpleCPTGenerator.h> |
| Cgum::IBayesNetGenerator< GUM_SCALAR, SimpleCPTGenerator > | |
| Cgum::MCBayesNetGenerator< GUM_SCALAR, SimpleCPTGenerator, SimpleCPTDisturber > | |
| Cgum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber > | <agrum/BN/generator/MCayesNetGenerator.h> |
| Cgum::SimpleBayesNetGenerator< GUM_SCALAR, ICPTGenerator > | <agrum/BN/generator/simpleBayesNetGenerator.h> |
| Cgum::learning::IDatabaseTableInsert4DBCell< ENABLE_INSERT > | |
| Cgum::learning::IDatabaseTableInsert4DBCell< !std::is_same< DBCell, DBCell >::value > | |
| Cgum::learning::IDatabaseTable< DBCell > | |
| Cgum::learning::RawDatabaseTable | The table containing the raw/original data of a database |
| Cgum::learning::IDatabaseTableInsert4DBCell< !std::is_same< DBTranslatedValue, DBCell >::value > | |
| Cgum::learning::IDatabaseTable< DBTranslatedValue > | |
| Cgum::learning::DatabaseTable | The class representing a tabular database as used by learning tasks |
| Cgum::learning::IDatabaseTableInsert4DBCell< !std::is_same< T_DATA, DBCell >::value > | |
| Cgum::learning::IDatabaseTable< T_DATA > | The common class for the tabular database tables |
| Cgum::learning::IDatabaseTableInsert4DBCell< false > | |
| Cgum::learning::IDatabaseTableInsert4DBCell< true > | |
| Cgum::learning::IDBInitializer | The base class for initializing DatabaseTable and RawDatabaseTable instances from CSV files or SQL databases |
| Cgum::learning::DBInitializerFromCSV | The class for initializing DatabaseTable and RawDatabaseTable instances from CSV files |
| Cgum::learning::DBInitializerFromSQL | The class for initializing DatabaseTable and RawDatabaseTable instances from SQL databases |
| Cgum::learning::IdCondSet | A class for storing a pair of sets of NodeIds, the second one corresponding to a conditional set |
| Cgum::learning::IdCondSetIterator | The iterators for IdSets |
| Cgum::IDecisionStrategy | <agrum/FMDP/SDyna/IDecisionStrategy.h> |
| Cgum::AdaptiveRMaxPlaner | <agrum/FMDP/planning/adaptiveRMaxPlaner.h> |
| Cgum::E_GreedyDecider | <agrum/FMDP/decision/E_GreedyDecider.h> |
| Cgum::LazyDecider | Class to make decision randomly |
| Cgum::RandomDecider | Class to make decision randomly |
| Cgum::StatisticalLazyDecider | <agrum/FMDP/decision/statisticalLazyDecider.h> |
| Cgum::IDReader< GUM_SCALAR > | Pure virtual class for importing an ID from a file |
| Cgum::BIFXMLIDReader< GUM_SCALAR > | Read an influence diagram from an XML file with BIF format |
| Cgum::GumIDReader< GUM_SCALAR > | Reads an InfluenceDiagram from a GUM (json) file |
| Cgum::IDWriter< GUM_SCALAR > | Pure virtual class for exporting an ID |
| Cgum::BIFXMLIDWriter< GUM_SCALAR > | Writes an influence diagram in a XML files with BIF format |
| Cgum::GumIDWriter< GUM_SCALAR > | Writes an InfluenceDiagram in the GUM json format |
| Cgum::learning::IGraphChangesGenerator4DiGraph | |
| Cgum::learning::GraphChangesGenerator4DiGraph< STRUCT_CONSTRAINT > | The basic class for computing the next graph changes possible in a structure learning algorithm |
| Cgum::learning::GraphChangesGenerator4K2< STRUCT_CONSTRAINT > | The basic class for computing the next graph changes possible in a structure learning algorithm |
| Cgum::learning::GraphChangesGeneratorOnSubDiGraph< STRUCT_CONSTRAINT > | The basic class for computing the next graph changes possible in a structure learning algorithm |
| Cgum::learning::IGraphChangesGenerator4UndiGraph | |
| Cgum::learning::GraphChangesGenerator4UndiGraph< STRUCT_CONSTRAINT > | The basic class for computing the next graph changes possible in an undirected structure learning algorithm |
| Cgum::learning::IKTBNLearner< GUM_SCALAR > | Pure-virtual configuration interface shared by all k-TBN learners |
| Cgum::learning::KTBNAdaptiveLearner< GUM_SCALAR > | Learns a k-TBN (order k + structure + parameters) from trajectory CSVs |
| Cgum::learning::KTBNLearner< GUM_SCALAR > | Learns a k-TBN (structure and/or parameters) from trajectory CSVs |
| Cgum::ILearningStrategy | <agrum/FMDP/SDyna/ILearningStrategy.h> |
| Cgum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection > | |
| Cgum::XmlDocument::Impl | |
| CImportanceInference | <agrum/BN/inference/importanceInference.h> |
| Cgum::prm::o3prmr::ImportCommand | |
| CIncompatibleEvidence | Exception : several evidence are incompatible together (proba=0) |
| Cgum::IndexedTree< Key, Data > | The class for storing the nodes of the Arborescence |
| Cgum::InfluenceDiagramGenerator< GUM_SCALAR > | <agrum/ID/generator/influenceDiagramGenerator.h> |
| Cgum::InformationTheory< INFERENCE_ENGINE, GUM_SCALAR > | InformationTheory is a template class which aims at gathering the implementation of informational functions (entropy, mutual information, etc.) |
| Cgum::Int2Type< v > | |
| Cgum::prm::gspan::InterfaceGraph< GUM_SCALAR > | This class represent the interface graph of a given gum::prm::PRMSystem<GUM_SCALAR> |
| Cgum::InternalNode | Structure used to represent a node internal structure |
| Cgum::IOperatorStrategy< GUM_ELEMENT > | <agrum/FMDP/SDyna/IOperatorStrategy.h> |
| Cgum::MDDOperatorStrategy< GUM_ELEMENT > | <agrum/FMDP/planning/mddOperatorStrategy.h> |
| Cgum::TreeOperatorStrategy< GUM_ELEMENT > | <agrum/FMDP/planning/treeOperatorStrategy.h> |
| Cgum::IPlanningStrategy< GUM_SCALAR > | <agrum/FMDP/SDyna/IPlanningStrategy.h> |
| Cgum::IPlanningStrategy< double > | |
| Cgum::StructuredPlaner< double > | |
| Cgum::AdaptiveRMaxPlaner | <agrum/FMDP/planning/adaptiveRMaxPlaner.h> |
| Cgum::IPlanningStrategy< GUM_ELEMENT > | |
| Cgum::StructuredPlaner< GUM_ELEMENT > | <agrum/FMDP/planning/structuredPlaner.h> |
| Cgum::prm::IPRMFactory | Non-template interface-like parent for every PRM Factory |
| Cgum::prm::PRMFactory< GUM_SCALAR > | Factory which builds a PRM<GUM_SCALAR> |
| Cgum::IScheduleMultiDim | The Table-agnostic base class of scheduleMultiDim |
| Cgum::ScheduleMultiDim< TABLE1 > | |
| Cgum::ScheduleMultiDim< TABLE2 > | |
| Cgum::ScheduleMultiDim< TABLE_RES > | |
| Cgum::ScheduleMultiDim< SCHED_TABLE > | |
| Cgum::ScheduleMultiDim< TABLE > | Wrapper for multi-dimensional tables used for scheduling inferences |
| CISignaler | |
| Cgum::__sig__::BasicSignaler< Args... > | |
| Cgum::Signaler<> | |
| Cgum::Signaler< NodeId, NodeId > | |
| Cgum::Signaler< int, std::string > | |
| Cgum::Signaler< Size, double, double > | |
| Cgum::Signaler< std::string_view > | |
| Cgum::Signaler< NodeId > | |
| Cgum::Signaler< Size, double > | |
| Cgum::Signaler< gum::NodeId, gum::NodeId, std::string, std::string > | |
| Cgum::Signaler< Args > | Variadic template signaler for any number of arguments |
| Cgum::__sig__::BasicSignaler< Args > | Base class for signalers, managing connector lifecycle |
| Cgum::ITerminalNodePolicy< GUM_SCALAR > | Interface specifying the methods to be implemented by any TerminalNodePolicy |
| Cgum::ITerminalNodePolicy< bool > | |
| Cgum::ExactTerminalNodePolicy< bool > | |
| Cgum::MultiDimFunctionGraph< bool > | |
| Cgum::MultiDimFunctionGraph< bool, ExactTerminalNodePolicy > | |
| Cgum::ITerminalNodePolicy< double > | |
| Cgum::ExactTerminalNodePolicy< double > | |
| Cgum::MultiDimFunctionGraph< double > | |
| Cgum::MultiDimFunctionGraph< double, ExactTerminalNodePolicy > | |
| Cgum::ITerminalNodePolicy< GUM_ELEMENT > | |
| Cgum::ExactTerminalNodePolicy< GUM_ELEMENT > | Implementation of a Terminal Node Policy that maps nodeid directly to value |
| Cgum::MultiDimFunctionGraph< GUM_ELEMENT, ExactTerminalNodePolicy > | |
| Cgum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > | Class implementingting a function graph |
| Cgum::ITerminalNodePolicy< Size > | |
| Cgum::ExactTerminalNodePolicy< Size > | |
| Cgum::MultiDimFunctionGraph< Size > | |
| Cgum::MultiDimFunctionGraph< Size, ExactTerminalNodePolicy > | |
| Cgum::ITestPolicy< GUM_ELEMENT > | <agrum/base/multidim/core/testPolicies/ITestPolicy.h> |
| Cgum::Chi2TestPolicy< GUM_ELEMENT > | <agrum/base/multidim/core/testPolicy/Chi2TestPolicy.h> |
| Cgum::GTestPolicy< GUM_ELEMENT > | <agrum/base/multidim/core/testPolicies/GTestPolicy.h> |
| Cgum::LeastSquareTestPolicy< GUM_ELEMENT > | <agrum/base/multidim/core/testPolicy/leastSquareTestPolicy.h> |
| Cgum::IThreadNumberManager | |
| Cgum::ThreadNumberManager | A class to manage the number of threads to use in an algorithm |
| Cgum::ScheduledInference | Class containing the scheduler used by schedule-based inferences |
| Cgum::LazyPropagation< GUM_SCALAR > | Implementation of a Shafer-Shenoy's-like version of lazy propagation for inference in Bayesian networks |
| Cgum::ShaferShenoyInference< GUM_SCALAR > | Implementation of Shafer-Shenoy's propagation algorithm for inference in Bayesian networks |
| Cgum::ShaferShenoyMRFInference< GUM_SCALAR > | <agrum/MRF/inference/ShaferShenoyMRFInference.h> |
| Cgum::VariableElimination< GUM_SCALAR > | Implementation of a Variable Elimination's-like version of lazy propagation for inference in Bayesian networks |
| Cgum::Scheduler | The common interface of all the schedulers |
| Cgum::SchedulerParallel | A scheduler that executes available operators in parallel |
| Cgum::SchedulerSequential | |
| Cgum::credal::InferenceEngine< GUM_SCALAR > | Abstract class template representing a CredalNet inference engine |
| Cgum::learning::IBNLearner | A pack of learning algorithms that can easily be used |
| Cgum::learning::RecordCounter | The class that computes counting of observations from the database |
| Cgum::learning::CachedContingencyCounter | Common counting infrastructure shared by IndependenceTest and KNML |
| Cgum::learning::IndependenceTest | The base class for all the independence tests used for learning |
| Cgum::learning::IndepTestChi2 | Class for computing Chi2 independence test scores |
| Cgum::learning::IndepTestG2 | Class for computing G2 independence test scores |
| Cgum::learning::KNML | Class for computing the NML penalty used by MIIC |
| Cgum::learning::CorrectedMutualInformation | The class computing n times the corrected mutual information, as used in the MIIC algorithm |
| Cgum::learning::ParamEstimator | The base class for estimating parameters of CPTs |
| Cgum::learning::ParamEstimatorML | The class for estimating parameters of CPTs using Maximum Likelihood |
| Cgum::learning::PseudoCount | The class for giving access to pseudo count : count in the database + prior |
| Cgum::learning::Score | The base class for all the scores used for learning (BIC, BDeu, etc) |
| Cgum::learning::ScoreAIC | Class for computing AIC scores |
| Cgum::learning::ScoreBD | Class for computing Bayesian Dirichlet (BD) log2 scores |
| Cgum::learning::ScoreBDeu | Class for computing BDeu scores |
| Cgum::learning::ScoreBIC | Class for computing BIC scores |
| Cgum::learning::ScoreK2 | Class for computing K2 scores (actually their log2 value) |
| Cgum::learning::ScoreLog2Likelihood | Class for computing Log2-likelihood scores |
| Cgum::learning::ScorefNML | Class for computing fNML scores |
| Cgum::IVisitableGraphLearner | <agrum/FMDP/SDyna/IVisitableGraphLearner.h> |
| Cgum::IncrementalGraphLearner< AttributeSelection, false > | |
| Cgum::IMDDI< AttributeSelection, isScalar > | |
| Cgum::ITI< AttributeSelection, isScalar > | Learn a graphical representation of a function as a decision tree |
| Cgum::IncrementalGraphLearner< AttributeSelection, isScalar > | <agrum/FMDP/learning/datastructure/incrementalGraphLearner> |
| Cgum::StatesCounter | <agrum/FMDP/simulation/statesCounter.h> |
| Cgum::JunctionTreeStrategy | Base Class for all the algorithms producing a junction given a set of cliques/subcliques resulting from a triangulation |
| Cgum::DefaultJunctionTreeStrategy | An algorithm producing a junction given the elimination tree produced by a triangulation algorithm |
| CKL | KL is the base class for KL computation betweens 2 BNs |
| Cgum::KTBN< GUM_SCALAR > | Class representing a k-order dynamic Bayesian network (k-DBN) |
| Cgum::KTBNGenerator< GUM_SCALAR > | Draws a random k-DBN template (structure and, optionally, CPTs) |
| Cgum::KTBNInference< GUM_SCALAR > | Exact inference on a gum::KTBN with observations and interventions, by the interface algorithm |
| Cgum::KTBNModality | A parent's value in gum::KTBN::fillCPT(): a modality index or a modality label |
| Cgum::prm::gspan::LabelData | Inner class to handle data about labels in this interface graph |
| Cgum::prm::GSpan< GUM_SCALAR >::LabelSort | Private class used to sort LabelData using STL sort algorithms |
| Cgum::prm::LayerGenerator< GUM_SCALAR >::LayerData | Getters and setters |
| Cgum::LeafAggregator | <agrum/FMDP/learning/FunctionGraph/leafAggregator.h> |
| Cgum::LeafPair | <agrum/FMDP/learning/datastructure/leaves/leafPair.h> |
| Cgum::LearnerSelect< LEARNERNAME, A, B > | |
| Cgum::LearnerSelect< ITILEARNER, A, B > | |
| Cgum::Link< T > | Link of a chain list allocated using the SmallObjectAllocator |
| Cgum::LinkedList< T > | Chain list allocated using the SmallObjectAllocator |
| Cgum::List< Val > | Generic doubly linked lists |
| Cgum::ListBucket< Val > | Bucket for a chained list |
| Cgum::ListConstIterator< Val > | Unsafe but fast const iterators for Lists |
| Cgum::ListIterator< Val > | Unsafe but fast iterators for Lists |
| Cgum::ListConstIteratorSafe< Val > | Safe const iterators for Lists |
| Cgum::ListIteratorSafe< Val > | Safe iterators for Lists |
| Cgum::Listener | Every class who would catch signal from signaler should derive from Listener |
| Cgum::ApproximationSchemeListener | The ApproximationSchemeListener class |
| Cgum::learning::BNLearnerListener | A class that redirects gum_signal from algorithms to the listeners of BNLearn |
| Cgum::DiGraphListener | Abstract Base class for all diGraph Listener |
| Cgum::BayesNetFragment< GUM_SCALAR > | Portion of a BN identified by the list of nodes and a BayesNet |
| Cgum::MixedGraphListener | Abstract Base class for all mixed Graph Listener |
| Cgum::NodeGraphPartIteratorSafe | Safe iterator on the node set of a graph |
| Cgum::ProgressListener | The ProgressListener class |
| Cgum::UndiGraphListener | Abstract Base class for all undiGraph Listener |
| Cgum::credal::lp::LpCol | Class representing a variable ( a column ) of a linear program, i.e |
| Cgum::credal::lp::LpExpr | Class representing a linear expression |
| Cgum::credal::lp::LpInterface< GUM_SCALAR > | Class representing a linear program |
| Cgum::credal::lp::LpRow | Class representing a row of the linear program, i.e |
| Cgum::credal::LRSWrapper< GUM_SCALAR > | Class template acting as a wrapper for Lexicographic Reverse Search by David Avis |
| Cgum::MarkovBlanket | Class building the markov Blanket from a BN and a nodeName |
| Cgum::Maximizes< GUM_SCALAR > | Maximization function object class |
| Cgum::MeekRules | Applies Meek's orientation rules to propagate arc directions in a mixed graph |
| C_StructuralConstraintSetStatic_::minConstraints | |
| Cgum::learning::StructuralConstraintSetStatic< StructuralConstraintDiGraph > | |
| Cgum::learning::StructuralConstraintIndegree | Class for structural constraints limiting the number of parents of nodes in a directed graph |
| Cgum::learning::StructuralConstraintSliceOrder | Structural constraint imposing a partial order over nodes |
| Cgum::learning::StructuralConstraintSetStatic< CONSTRAINT1, OTHER_CONSTRAINTS > | "meta-programming" class for storing structural constraints |
| Cgum::Minimizes< GUM_SCALAR > | Minimization function object class |
| CMonteCarloInference | <agrum/BN/inference/monteCarloInference.h> |
| Cgum::MRFReader< GUM_SCALAR > | Pure virtual class for reading a MRF from a file |
| Cgum::GumMRFReader< GUM_SCALAR > | Reads a MarkovRandomField from a GUM (json) file |
| Cgum::UAIMRFReader< GUM_SCALAR > | Pure virtual class for reading a MRF from a file |
| Cgum::MRFWriter< GUM_SCALAR > | Pure virtual class for writing a MRF to a file |
| Cgum::GumMRFWriter< GUM_SCALAR > | Writes a MarkovRandomField in the GUM json format |
| Cgum::UAIMRFWriter< GUM_SCALAR > | <agrum/MRF/io/UAI/UAIMRFWriter.h> |
| Cgum::MultiDimCombination< TABLE > | A generic interface to combine efficiently several MultiDim tables |
| Cgum::MultiDimCombinationDefault< TABLE > | A class to combine efficiently several MultiDim tables |
| Cgum::MultiDimCombineAndProject< TABLE > | A generic interface to combine and project efficiently MultiDim tables |
| Cgum::MultiDimCombineAndProjectDefault< TABLE > | An efficient class for combining and projecting MultiDim tables |
| Cgum::MultiDimCompleteProjection< GUM_ELEMENT, TABLE > | A generic class to project efficiently a MultiDim table over all of its variables |
| Cgum::MultiDimFunctionGraphGenerator | Class implementing a function graph generator with template type double |
| Cgum::MultiDimFunctionGraphManager< GUM_ELEMENT, TerminalNodePolicy > | Class implementingting a function graph manager |
| Cgum::MultiDimFunctionGraphROManager< GUM_ELEMENT, TerminalNodePolicy > | |
| Cgum::MultiDimFunctionGraphTreeManager< GUM_ELEMENT, TerminalNodePolicy > | |
| Cgum::MultiDimFunctionGraphOperator< GUM_ELEMENT, FUNCTOR, TerminalNodePolicy > | Class used to perform Function Graph Operations |
| Cgum::MultiDimFunctionGraphProjector< GUM_ELEMENT, FUNCTOR, TerminalNodePolicy > | Class used to perform Function Graph projections |
| Cgum::MultiDimInterface | Interface for all classes addressing in a multiDim fashion |
| Cgum::Instantiation | Class for assigning/browsing values to tuples of discrete variables |
| Cgum::MultiDimAdressable | Abstract base class for all multi dimensionnal addressable |
| Cgum::MultiDimContainer< double > | |
| Cgum::MultiDimImplementation< double > | |
| Cgum::MultiDimFunctionGraph< double > | |
| Cgum::MultiDimFunctionGraph< double, ExactTerminalNodePolicy > | |
| Cgum::MultiDimContainer< gum::ActionSet > | |
| Cgum::MultiDimImplementation< gum::ActionSet > | |
| Cgum::MultiDimFunctionGraph< gum::ActionSet, gum::SetTerminalNodePolicy > | |
| Cgum::MultiDimContainer< GUM_SCALAR > | |
| Cgum::MultiDimDecorator< GUM_SCALAR > | |
| Cgum::Tensor< GUM_ELEMENT > | |
| Cgum::Tensor< GUM_SCALAR > | AGrUM's Tensor is a multi-dimensional array with tensor operators |
| Cgum::MultiDimImplementation< GUM_SCALAR > | |
| Cgum::MultiDimReadOnly< GUM_SCALAR > | |
| Cgum::MultiDimICIModel< GUM_SCALAR > | |
| Cgum::MultiDimLogit< GUM_SCALAR > | Logit representation |
| Cgum::MultiDimNoisyAND< GUM_SCALAR > | Noisy AND representation |
| Cgum::MultiDimNoisyORCompound< GUM_SCALAR > | Noisy OR representation |
| Cgum::MultiDimNoisyORNet< GUM_SCALAR > | Noisy OR representation |
| Cgum::aggregator::MultiDimAggregator< GUM_SCALAR > | |
| Cgum::aggregator::Amplitude< GUM_SCALAR > | Amplitude aggregator |
| Cgum::aggregator::And< GUM_SCALAR > | And aggregator |
| Cgum::aggregator::Count< GUM_SCALAR > | Count aggregator |
| Cgum::aggregator::Exists< GUM_SCALAR > | Exists aggregator |
| Cgum::aggregator::Forall< GUM_SCALAR > | Forall aggregator |
| Cgum::aggregator::Max< GUM_SCALAR > | Max aggregator |
| Cgum::aggregator::Median< GUM_SCALAR > | Median aggregator |
| Cgum::aggregator::Min< GUM_SCALAR > | Min aggregator |
| Cgum::aggregator::Or< GUM_SCALAR > | Or aggregator |
| Cgum::aggregator::Sum< GUM_SCALAR > | Sum aggregator |
| Cgum::MultiDimContainer< bool > | |
| Cgum::MultiDimImplementation< bool > | |
| Cgum::MultiDimFunctionGraph< bool > | |
| Cgum::MultiDimFunctionGraph< bool, ExactTerminalNodePolicy > | |
| Cgum::MultiDimContainer< Size > | |
| Cgum::MultiDimImplementation< Size > | |
| Cgum::MultiDimFunctionGraph< Size > | |
| Cgum::MultiDimFunctionGraph< Size, ExactTerminalNodePolicy > | |
| Cgum::MultiDimContainer< std::string > | |
| Cgum::MultiDimImplementation< std::string > | |
| Cgum::MultiDimContainer< GUM_ELEMENT > | Abstract base class for all multi dimensionnal containers |
| Cgum::MultiDimImplementation< GUM_ELEMENT > *(*)(const MultiDimImplementation< GUM_ELEMENT > *, const MultiDimImplementation< GUM_ELEMENT > *) | |
| Cgum::VariableSet &)< GUM_ELEMENT > | |
| Cgum::MultiDimImplementation< GUM_ELEMENT > *(*)(const MultiDimImplementation< GUM_ELEMENT > *, const HashTable< const DiscreteVariable *, Idx > &) | |
| Cgum::MultiDimDecorator< GUM_ELEMENT > | Decorator design pattern in order to separate implementations from multidimensional matrix concepts |
| Cgum::MultiDimImplementation< GUM_ELEMENT > | <agrum/base/multidim/multiDimImplementation.h> |
| Cgum::MultiDimFunctionGraph< GUM_ELEMENT, ExactTerminalNodePolicy > | |
| Cgum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > | Class implementingting a function graph |
| Cgum::MultiDimReadOnly< GUM_ELEMENT > | Abstract base class for all multi dimensionnal read only structure |
| Cgum::MultiDimBucket< GUM_ELEMENT > | A multidim implementation for buckets |
| Cgum::MultiDimICIModel< GUM_ELEMENT > | Abstract class for Conditional Indepency Models |
| Cgum::aggregator::MultiDimAggregator< GUM_ELEMENT > | <agrum/base/multidim/aggregators/multiDimAggregator.h> |
| Cgum::MultiDimWithOffset< GUM_ELEMENT > | Abstract class for Multidimensional matrix stored as an array in memory and with an offset associated with each slave instantiation |
| Cgum::MultiDimArray< GUM_ELEMENT > | Multidimensional matrix stored as an array in memory |
| Cgum::MultiDimBijArray< GUM_ELEMENT > | Decorator of a MultiDimArray, using a bijection over the variables |
| Cgum::MultiDimSparse< GUM_ELEMENT > | Multidimensional matrix stored as a sparse array in memory |
| Cgum::MultiDimPartialInstantiation< GUM_ELEMENT, TABLE > | A generic class to instantiate a subset of variables of a multidimensional table |
| Cgum::MultiDimProjection< TABLE > | A generic class to project efficiently a MultiDim table over a subset of its variables |
| Cgum::MultiPriorityQueue< Val, Priority, Cmp > | A MultiPriorityQueue is a heap in which each element has a mutable priority and duplicates are allowed |
| Cgum::prm::ClusteredLayerGenerator< GUM_SCALAR >::MyData | |
| Cgum::prm::LayerGenerator< GUM_SCALAR >::MyData | |
| Cgum::prm::NameGenerator | This is a name generator for classes, types, systems, instances and class elements |
| Cgum::learning::NanodbcParser | Class for parsing SQL results using Nanodbc |
| Cgum::prm::gspan::DFSTree< GUM_SCALAR >::NeighborDegreeSort | This is used to generate the max_indep_set of a Pattern |
| Cgum::prm::gspan::NodeData< GUM_SCALAR > | Inner class to handle data about nodes in graph |
| Cgum::NodeDatabase< AttributeSelection, isScalar > | <agrum/FMDP/learning/datastructure/nodeDatabase.h> |
| Cgum::NodeGraphPart | Class for node sets in graph |
| Cgum::DiGraph | Base class for all oriented graphs |
| Cgum::UndiGraph | Base class for undirected graphs |
| Cgum::NodeGraphPartIterator | Unsafe iterator on the node set of a graph |
| Cgum::NodeGraphPartIteratorSafe | Safe iterator on the node set of a graph |
| Cgum::learning::KTBNDatabaseGenerator< GUM_SCALAR >::NodeRef | Template node, precompiled for fast sampling |
| Cgum::prm::o3prm::O3Aggregate | The O3Aggregate is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Assignment | The O3Assignment is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Attribute | The O3Attribute is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3RawCPT | The O3RawCPT is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3RuleCPT | The O3RuleCPT is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Class | The O3Class is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3ClassFactory< GUM_SCALAR > | Builds gum::prm::Class from gum::prm::o3prm::O3Class |
| Cgum::prm::o3prm::O3Float | The O3Float is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Formula | The O3Formula is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Import | The O3Import is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Increment | The O3Increment is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Instance | The O3Instance is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3InstanceParameter | The O3InstanceParameter is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Integer | The O3Integer is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Interface | The O3Interface is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3InterfaceElement | The O3InterfaceElement is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3InterfaceFactory< GUM_SCALAR > | Bulds gum::prm:PRMInterface from gum::prm::o3prm::O3Interface |
| Cgum::prm::o3prm::O3IntType | The O3IntType is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Label | The O3Label is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3NameSolver< GUM_SCALAR > | Resolves names for the different O3PRM factories |
| Cgum::prm::o3prm::O3Parameter | The O3Parameter is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3Position | The O3Position is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3PRM | The O3PRM is part of the AST of the O3PRM language |
| Cgum::prm::o3prmr::O3prmrCommand | This is an abstract class |
| Cgum::prm::o3prmr::ObserveCommand< GUM_SCALAR > | |
| Cgum::prm::o3prmr::QueryCommand< GUM_SCALAR > | |
| Cgum::prm::o3prmr::SetEngineCommand | |
| Cgum::prm::o3prmr::SetGndEngineCommand | |
| Cgum::prm::o3prmr::UnobserveCommand< GUM_SCALAR > | |
| Cgum::prm::o3prmr::O3prmrContext< GUM_SCALAR > | Represent a o3prmr context, with an import, and some sequencials commands |
| Cgum::prm::o3prm::O3prmReader< GUM_SCALAR > | This class read O3PRM files and creates the corresponding gum::prm::PRM |
| Cgum::prm::o3prmr::O3prmrInterpreter | Represents a O3PRMR context |
| Cgum::prm::o3prmr::O3prmrSession< GUM_SCALAR > | This class contains a o3prmr session |
| Cgum::prm::o3prm::O3RealType | The O3RealType is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3ReferenceSlot | The O3ReferenceSlot is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3System | The O3System is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3SystemFactory< GUM_SCALAR > | Builds gum::prm::PRMSystem from gum::prm::o3prm::O3System |
| Cgum::prm::o3prm::O3Type | The O3Type is part of the AST of the O3PRM language |
| Cgum::prm::o3prm::O3TypeFactory< GUM_SCALAR > | Builds gum::prm::PRMType from gum::prm::o3prm::O3Type, gum::prm::o3prm::O3IntType and gum::prm::o3prm::O3RealType |
| Cgum::O4DGContext | Class used to manipulate context during Function Graph Operations |
| Cgum::Observation | |
| Cgum::OperatorRegister4MultiDim< GUM_ELEMENT > | A container for registering binary functions on multiDimImplementations |
| Cgum::Operators4MultiDimInitialize< GUM_ELEMENT > | Class used to register operators over non-pointers types |
| Cgum::Operators4MultiDimInitialize< GUM_ELEMENT * > | Class used to register operators over pointers types |
| Cgum::optional_ref< T > | A lightweight wrapper around a pointer providing an optional-like API for references (not supported by std::optional<T&>) |
| Cgum::prm::ParamScopeData< GUM_SCALAR > | |
| Cgum::Parent | Represent a node's parent |
| Cgum::learning::KTBNDatabaseGenerator< GUM_SCALAR >::ParentRef | Parent of a template node, precompiled for fast sampling |
| Cgum::ParseError | This class is used to represent parsing errors for the different parser implemented in aGrUM |
| Cgum::PartialInstantiation4MultiDimInitialize< GUM_ELEMENT > | A class used to register instantiation functions over non-pointers types |
| Cgum::PartialInstantiation4MultiDimInitialize< GUM_ELEMENT * > | |
| Cgum::PartialInstantiationRegister4MultiDim< GUM_ELEMENT > | A container for registering partial instantiation functions on multiDimImplementations, i.e., functions assigning values to subsets of the variables of some tables |
| Cgum::prm::gspan::DFSTree< GUM_SCALAR >::PatternData | |
| Cgum::prm::GSpan< GUM_SCALAR >::PatternSort | Private class used to sort Pattern using STL sort algorithms |
| Cgum::prm::gspan::StrictSearch< GUM_SCALAR >::PData | Private structure to represent data about a pattern |
| Cgum::prm::StructuredInference< GUM_SCALAR >::PData | Private structure to represent data about a pattern |
| Cgum::learning::Prior | Base class for all a priori |
| Cgum::learning::BDeuPrior | Internal prior for the BDeu score (N' / (r_i * q_i) |
| Cgum::learning::DirichletPriorFromBN< GUM_SCALAR > | A dirichlet priori: computes its N'_ijk from a database |
| Cgum::learning::DirichletPriorFromDatabase | A dirichlet priori: computes its N'_ijk from a database |
| Cgum::learning::NoPrior | No a priorclass: corresponds to 0 weight-sample |
| Cgum::learning::SmoothingPrior | Smooth a priori: adds a weight w to all the counts |
| Cgum::learning::K2Prior | Internal prior for the K2 score = Laplace Prior |
| Cgum::PriorityQueueImplementation< Val, Priority, Cmp, Gen > | The internal class for representing priority queues |
| Cgum::PriorityQueueImplementation< gum::Edge, float, std::less< float >, std::is_scalar< gum::Edge >::value > | |
| Cgum::PriorityQueue< gum::Edge, float > | |
| Cgum::PriorityQueueImplementation< NodeId, double, std::less< double >, std::is_scalar< NodeId >::value > | |
| Cgum::PriorityQueue< NodeId, double > | |
| Cgum::PriorityQueueImplementation< Val, int, std::less< int >, std::is_scalar< Val >::value > | |
| Cgum::PriorityQueue< Val, Priority, Cmp > | A priorityQueue is a heap in which each element has a mutable priority |
| Cgum::prm::PRM< GUM_SCALAR > | This class represents a Probabilistic Relational PRMSystem<GUM_SCALAR> |
| CPRMAggregate | Defines an aggregate in a PRM |
| Cgum::prm::PRMGenerator< GUM_SCALAR > | This class is the base class to all PRM generators |
| Cgum::prm::ClusteredLayerGenerator< GUM_SCALAR > | <agrum/PRM/generator/clusteredLayerGenerator.h> |
| Cgum::prm::LayerGenerator< GUM_SCALAR > | <agrum/PRM/generator/layerGenerator.h> |
| Cgum::prm::PRMInference< GUM_SCALAR > | This abstract class is used as base class for all inference class on PRM<GUM_SCALAR> |
| Cgum::prm::GroundedInference< GUM_SCALAR > | <agrum/PRM/groundedInference.h> |
| Cgum::prm::SVE< GUM_SCALAR > | This class is an implementation of the Structured Variable Elimination algorithm on PRM<GUM_SCALAR> |
| Cgum::prm::SVED< GUM_SCALAR > | This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR> |
| Cgum::prm::StructuredInference< GUM_SCALAR > | <agrum/PRM/structuredInference.h> |
| Cgum::prm::PRMObject | Abstract base class for any element defined in a PRM |
| Cgum::prm::PRMSystem< double > | |
| Cgum::prm::PRMClassElement< GUM_SCALAR > | Abstract class representing an element of PRM class |
| Cgum::prm::PRMAggregate< GUM_SCALAR > | |
| Cgum::prm::PRMAttribute< GUM_SCALAR > | PRMAttribute is a member of a Class in a PRM |
| Cgum::prm::PRMFormAttribute< GUM_SCALAR > | <agrum/PRM/elements/formAttribute.h> |
| Cgum::prm::PRMScalarAttribute< GUM_SCALAR > | <agrum/PRM/elements/scalarAttribute.h> |
| Cgum::prm::PRMFuncAttribute< GUM_SCALAR > | <agrum/PRM/elements/funcAttribute.h> |
| Cgum::prm::PRMParameter< GUM_SCALAR > | PRMParameter is a member of a Class in a PRM |
| Cgum::prm::PRMReferenceSlot< GUM_SCALAR > | A PRMReferenceSlot represent a relation between two PRMClassElementContainer |
| Cgum::prm::PRMSlotChain< GUM_SCALAR > | 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 |
| Cgum::prm::PRMClassElementContainer< GUM_SCALAR > | <agrum/PRM/classElementContainer.h> |
| Cgum::prm::PRMClass< GUM_SCALAR > | A PRMClass is an object of a PRM representing a fragment of a Bayesian network which can be instantiated in PRMInstance |
| Cgum::prm::PRMInterface< GUM_SCALAR > | 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 |
| Cgum::prm::PRMInstance< GUM_SCALAR > | An PRMInstance is a Bayesian network fragment defined by a Class and used in a PRMSystem |
| Cgum::prm::PRMSystem< GUM_SCALAR > | A PRMSystem is a container of PRMInstance and describe a relational skeleton |
| Cgum::prm::PRMType | This is a decoration of the DiscreteVariable class |
| Cgum::ProgressNotifier | Notification for progress using listener |
| Cgum::learning::BNDatabaseGenerator< GUM_SCALAR > | |
| Cgum::learning::KTBNDatabaseGenerator< GUM_SCALAR > | Generates a database of trajectories from a k-DBN (one CSV per trajectory) |
| Cgum::ProjectionRegister4MultiDim< GUM_ELEMENT > | A container for registering projection functions on multiDimImplementations, i.e., functions projecting tables over a subset of their variables |
| Cgum::Projections4MultiDimInitialize< GUM_ELEMENT > | Class used to register projections over non-pointers types |
| Cgum::Projections4MultiDimInitialize< GUM_ELEMENT * > | Class used to register projections over pointers types |
| Cgum::prm::o3prmr::QueryResult | |
| Cgum::Rational< GUM_SCALAR > | Class template used to approximate decimal numbers by rationals |
| Cgum::prm::PRMInstance< GUM_SCALAR >::RefConstIterator | Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations |
| Cgum::prm::PRMInstance< GUM_SCALAR >::RefIterator | Nested class to iterate over PRMReferenceSlot and PRMSlotChain<GUM_SCALAR> instantiations |
| Cgum::Regress< GUM_ELEMENT, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy > | Class used to perform Function Graph Operations in the FMDP Framework |
| Cgum::prm::StructuredInference< GUM_SCALAR >::RGData | Private structure to represent data about a reduced graph |
| Cgum::Schedule | Class containing a schedule of operations to perform on multidims |
| Cgum::ScheduleOperator | Base class for "low-level" operators used to schedule inferences |
| Cgum::ScheduleBinaryCombination< TABLE1, TABLE2, TABLE_RES > | Binary Combination operator class used for scheduling inferences |
| Cgum::ScheduleProjection< TABLE > | Projection operator class used for scheduling inferences |
| Cgum::ScheduleStorage< TABLE, CONTAINER > | Class for storing multidimensional tables into containers (sets, etc.) |
| CScoreMDL | Class for computing MDL scores |
| Cgum::learning::ScoringCache | Cache for caching scores and independence tests results |
| Cgum::SDYNA | The general SDyna architecture abstract class |
| Cgum::prm::gspan::SearchStrategy< GUM_SCALAR > | This is an abstract class used to tune search strategies in the gspan algorithm |
| Cgum::prm::gspan::FrequenceSearch< GUM_SCALAR > | 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 |
| Cgum::prm::gspan::StrictSearch< GUM_SCALAR > | This is class is an implementation of a strict strategy for the GSpan algorithm |
| Cgum::prm::gspan::TreeWidthSearch< GUM_SCALAR > | A growth is accepted if and only if the new growth has a tree width less large or equal than its father |
| Cgum::Separation | Consolidated d-separation utilities (DAG-centric) |
| Cgum::learning::CIBasedLearning::SepSetEntry_ | |
| Cgum::SequenceImplementation< Key, Gen > | The internal class for storing (ordered) sequences of objects |
| Cgum::SequenceImplementation< const gum::DiscreteVariable *, std::is_scalar< const gum::DiscreteVariable * >::value > | |
| Cgum::Sequence< const gum::DiscreteVariable * > | |
| Cgum::SequenceImplementation< const gum::IScheduleMultiDim *, std::is_scalar< const gum::IScheduleMultiDim * >::value > | |
| Cgum::Sequence< const gum::IScheduleMultiDim * > | |
| Cgum::SequenceImplementation< gum::FusionContext< false > *, std::is_scalar< gum::FusionContext< false > * >::value > | |
| Cgum::Sequence< gum::FusionContext< false > * > | |
| Cgum::SequenceImplementation< gum::prm::PRMClassElement< GUM_SCALAR > *, std::is_scalar< gum::prm::PRMClassElement< GUM_SCALAR > * >::value > | |
| Cgum::Sequence< gum::prm::PRMClassElement< GUM_SCALAR > * > | |
| Cgum::SequenceImplementation< gum::prm::PRMInstance< GUM_SCALAR > *, std::is_scalar< gum::prm::PRMInstance< GUM_SCALAR > * >::value > | |
| Cgum::Sequence< gum::prm::PRMInstance< GUM_SCALAR > * > | |
| Cgum::SequenceImplementation< GUM_SCALAR_SEQ, std::is_scalar< GUM_SCALAR_SEQ >::value > | |
| Cgum::Sequence< GUM_SCALAR_SEQ > | |
| Cgum::SequenceImplementation< Idx, std::is_scalar< Idx >::value > | |
| Cgum::Sequence< Idx > | |
| Cgum::SequenceImplementation< Key, std::is_scalar< Key >::value > | |
| Cgum::Sequence< Key > | The generic class for storing (ordered) sequences of objects |
| Cgum::SequenceImplementation< NodeId, std::is_scalar< NodeId >::value > | |
| Cgum::Sequence< NodeId > | |
| Cgum::SequenceImplementation< std::string, std::is_scalar< std::string >::value > | |
| Cgum::Sequence< std::string > | |
| Cgum::SequenceImplementation< ValueType, std::is_scalar< ValueType >::value > | |
| Cgum::Sequence< ValueType > | |
| Cgum::SequenceIteratorSafe< Key > | Safe iterators for Sequence |
| Cgum::Set< Key > | Representation of a set |
| Cgum::SetInst | Class for assigning/browsing values to tuples of discrete variables |
| Cgum::SetIterator< Key > | Unsafe iterators for the Set class |
| Cgum::SetIteratorSafe< Key > | Safe iterators for the Set class |
| Cgum::SetTerminalNodePolicy< GUM_ELEMENT > | Implementation of a Terminal Node Policy that maps nodeid to a set of value |
| Cgum::SetTerminalNodePolicy< gum::ActionSet > | |
| Cgum::MultiDimFunctionGraph< gum::ActionSet, gum::SetTerminalNodePolicy > | |
| CSharedAVLTreeIterator | |
| Cgum::SortedPriorityQueueReverseIterator< Val, Priority, Cmp > | |
| Cgum::SortedPriorityQueueReverseIterator< Val, Priority, Cmp > | Sorted priority queue reverse iterator |
| CSharedAVLTreeIteratorSafe | |
| Cgum::SortedPriorityQueueReverseIteratorSafe< Val, Priority, Cmp > | |
| Cgum::SortedPriorityQueueReverseIteratorSafe< Val, Priority, Cmp > | Sorted priority queue safe (w.r.t |
| CSharedAVLTreeReverseIterator | |
| Cgum::SortedPriorityQueueIterator< Val, Priority, Cmp > | |
| Cgum::SortedPriorityQueueIterator< Val, Priority, Cmp > | Sorted priority queue iterator |
| CSharedAVLTreeReverseIteratorSafe | |
| Cgum::SortedPriorityQueueIteratorSafe< Val, Priority, Cmp > | |
| Cgum::SortedPriorityQueueIteratorSafe< Val, Priority, Cmp > | Sorted priority queues safe (w.r.t |
| Cgum::SimplicialSet | Class enabling fast retrieval of simplicial, quasi and almost simplicial nodes |
| Cgum::prm::o3prmr::SingleResult | |
| Cgum::SmallObjectAllocator | <agrum/base/core/smallObjectAllocator.h> |
| Cgum::SortedPriorityQueue< Val, Priority, Cmp > | A priority queue in which we can iterate over the elements from the top to bottom or conversely |
| Cgum::SpanningForest | Base class for computing min cost spanning trees or forests |
| Cgum::SpanningForestPrim | The Prim algorithm for computing min cost spanning trees or forests |
| Cgum::SplayBinaryNode< Element > | Nodes of splay trees |
| Cgum::SplayTree< Element > | A splay tree |
| Cgum::StatesChecker | <agrum/FMDP/simulation/statesChecker.h> |
| Cgum::learning::StructuralConstraintEmpty | Base class for all structural constraints |
| Cgum::learning::StructuralConstraintDAG | The base class for structural constraints imposed by DAGs |
| Cgum::learning::StructuralConstraintDiGraph | The base class for structural constraints used by learning algorithms that learn a directed graph structure |
| Cgum::learning::StructuralConstraintForbiddenArcs | Structural constraint for forbidding the creation of some arcs during structure learning |
| Cgum::learning::StructuralConstraintMandatoryArcs | Structural constraint indicating that some arcs shall never be removed or reversed |
| Cgum::learning::StructuralConstraintNoChildrenNodes | Structural constraint for forbidding children for some nodes |
| Cgum::learning::StructuralConstraintNoParentNodes | Structural constraint for forbidding parents for some nodes |
| Cgum::learning::StructuralConstraintPossibleEdges | Structural constraint for forbidding the creation of some arcs except those defined in the class during structure learning |
| Cgum::learning::StructuralConstraintTabuList | The class imposing a N-sized tabu list as a structural constraints for learning algorithms |
| Cgum::learning::StructuralConstraintTotalOrder | Structural constraint imposing a total order over some nodes |
| Cgum::learning::StructuralConstraintUndiGraph | The base class for structural constraints used by learning algorithms that learn an undirected graph structure |
| Cgum::StructuralMetrics | A class for comparing graphs based on their structures |
| Cgum::prm::StructuredBayesBall< GUM_SCALAR > | <agrum/PRM/structuredBayesBall.h> |
| Cgum::TestSelect< TESTNAME, A, B, C > | |
| Cgum::TestSelect< CHI2TEST, A, B, C > | |
| Cgum::TestSelect< LEASTSQUARETEST, A, B, C > | |
| Cgum::ThreadData< T_DATA > | A wrapper that enables to store data in a way that prevents false cacheline sharing |
| 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 |
| Cgum::ThreadExecutorBase | Set the max number of threads to be used |
| Cgum::threadsOMP::ThreadExecutor | |
| Cgum::threadsSTL::ThreadExecutor | |
| Cgum::Timer | Class used to compute response times for benchmark purposes |
| Cgum::TreeOperator< GUM_ELEMENT, COMBINEOPERATOR, TerminalNodePolicy > | Class used to perform Decision Tree Operation in the FMDP Framework |
| Cgum::TreeRegress< GUM_ELEMENT, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy > | Class used to perform Decision Tree Regression in the FMDP Framework |
| Cgum::Triangulation | Interface for all the triangulation methods |
| Cgum::IncrementalTriangulation | Class that performs incremental triangulations |
| Cgum::StaticTriangulation | Base class for all non-incremental triangulation methods |
| Cgum::OrderedTriangulation | Class for graph triangulations for which we enforce a given complete ordering on the nodes eliminations |
| Cgum::PartialOrderedTriangulation | 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 |
| Cgum::UnconstrainedTriangulation | Interface for all triangulation methods without constraints on node elimination orderings |
| Cgum::DefaultTriangulation | The default triangulation algorithm used by aGrUM |
| CHashFuncCastKey::type | |
| Cgum::HashFunc< double > | Hash function for doubles |
| CHashFuncCastKey::type | |
| Cgum::HashFunc< float > | Hash function for floats |
| CHashFuncCastKey::type | |
| Cgum::HashFunc< typename HashFuncConditionalType< std::size_t, unsigned long, unsigned int, long, int >::type > | Hash function for std::size_t |
| CHashFuncCastKey::type | |
| Cgum::HashFunc< Type * > | Hash function for pointers |
| Cgum::SchedulerSequential::UnexecutedOperation | Structure to keep informations about operations that could not be executed due to memory usage limitations |
| Cgum::UTGenerator | Abstract class for generating Utility Tables |
| Cgum::SimpleUTGenerator | Class for generating Utility Tables |
| Cgum::ValueSelect< bool, A, B > | |
| Cgum::ValueSelect< false, A, B > | |
| Cgum::Variable | Base class for every random variable |
| Cgum::DiscreteVariable | Base class for discrete random variable |
| Cgum::IDiscretizedVariable | A base class for discretized variables, independent of the ticks type |
| Cgum::DiscretizedVariable< T_TICKS > | Class for discretized random variable |
| Cgum::IntegerVariable | Class IntegerVariable |
| Cgum::LabelizedVariable | Class LabelizedVariable |
| Cgum::NumericalDiscreteVariable | Class NumericalDiscreteVariable |
| Cgum::RangeVariable | Defines a discrete random variable over an integer interval |
| Cgum::IContinuousVariable | A base class for continuous variables, independent of the GUM_SCALAR type |
| Cgum::ContinuousVariable< GUM_SCALAR > | Defines a continuous random variable |
| Cgum::VariableLog2ParamComplexity | Class for computing the log2 of the parametric complexity of an r-ary multinomial variable |
| Cgum::VariableNodeMap | Container used to map discrete variables with nodes |
| Cgum::VariableSelector | <agrum/FMDP/planning/FunctionGraph/variableselector.h> |
| Cgum::credal::VarMod2BNsMap< GUM_SCALAR > | Class used to store optimum IBayesNet during some inference algorithms |
| CWeightedInference | <agrum/BN/inference/weightedInference.h> |
| Cgum::XmlDocument | An XML document, opaque over ticpp::Document |
| Cgum::XmlElement | A non-owning handle to an XML element, opaque over ticpp::Element |
| CBinSearchTreeIterator< Val, Cmp, Node > | |
| Cbool | |
| CCmp | |
| CDBVector< IsMissing > | |
| CDBVector< std::string > | |
| Cdouble | |
| Cfriend | |
| Cgreater< double > | |
| Cless< double > | |
| Cless< float > | |
| CMatrix< DBCell > | |
| CMatrix< DBTranslatedValue > | |
| CSCHED_TABLE * | |
| CSharedAVLTree< gum::learning::GraphChange, TreeCmp > | |
| Cstatic const Size | |
| CTABLE1 * | |
| CTABLE2 * | |
| CTABLE_RES * | |
| Cunsigned int | |
