Namespaces
	__debug__
	Internal namespace for aGrUM debugging tools.

	__sig__
	Internal namespace for aGrUM signaler/listener components.

	aggregator
	Aggregators are functional description of CPTs.

	complexity
	Internal namespace for complexity tools (quite empty for now)

	credal
	namespace for all credal networks entities

	formula

	learning

	prm
	namespace for all probabilistic relational models entities

	thread

Classes
class	AbstractFMDPFactory
	A factory class to ease Factored Markov Decision Process construction. More...

class	AbstractLeaf
	<agrum/FMDP/learning/datastructure/leaves/abstractLeaf.h> More...

class	AbstractSimulator
	<agrum/FMDP/simulation/abstractSimulator.h> More...

class	ActionSet
	A class to store the optimal actions. More...

class	AdaptiveRMaxPlaner
	<agrum/FMDP/planning/adaptiveRMaxPlaner.h> More...

class	AggregatorDecomposition
	<agrum/BN/inference/tools/aggregatorDecomposition.h> More...

struct	AlmostDifferent
	Indicate whether two elements are (almost) different or not. More...

struct	AlmostDifferent< T *>
	Indicate whether two elements are (almost) different or not. More...

class	ApproximateInference

class	ApproximationPolicy
	Mother class for all approximation policy classes. More...

class	ApproximationScheme
	Approximation Scheme. More...

class	ApproximationSchemeListener
	The ApproximationSchemeListener class. More...

class	Arc
	The base class for all directed edgesThis class is used as a basis for manipulating all directed edges (i.e., edges in which the order of the nodes is meaningful). More...

class	ArcGraphPart
	Classes for directed edge sets. More...

struct	ArgMaxSet
	Class to handle efficiently argMaxSet. More...

struct	ArgumentMaximises
	Arg Max function object class. More...

struct	ArgumentMaximisesAction
	<agrum/FMDP/planning/actionSet.h> More...

class	BarrenNodesFinder
	Detect barren nodes for inference in Bayesian networks. More...

class	BayesBall
	Implementation of Shachter's Bayes Balls algorithm. More...

class	BayesNet
	Class representing a Bayesian network. More...

class	BayesNetFactory
	A factory class to ease BayesNet construction. More...

class	BayesNetFragment
	Portion of a BN identified by the list of nodes and a BayesNet. More...

class	BayesNetInference
	<agrum/BN/inference/BayesNetInference.h> More...

class	BIFReader
	Definition of templatized reader of BIF files for Bayesian networks. More...

class	BIFWriter
	Writes a IBayesNet in the BIF format. More...

class	BIFXMLBNReader
	<agrum/BN/io/BIFXML/BIFXMLBNReader.h> More...

class	BIFXMLBNWriter
	<agrum/BN/io/BIFXML/BIFXMLBNWriter.h> More...

class	BIFXMLIDReader
	Read an influence diagram from an XML file with BIF format. More...

class	BIFXMLIDWriter
	Writes an influence diagram in a XML files with BIF formatThis class export an influence diagram into an XML files, using BIF format See http://www-2.cs.cmu.edu/afs/cs/user/fgcozman/www/Research/InterchangeFormat/ for information about this format. More...

class	Bijection
	Set of pairs of elements with fast search for both elements. More...

class	BijectionImplementation
	A non scalar implementation of a Bijection. More...

class	BijectionIterator
	Unsafe iterators for bijection. More...

class	BijectionIteratorGet
	Dummy classes for discriminating scalars and non-scalars operators and -> wihtout any overhead. More...

struct	BijectionIteratorGet< true >

class	BijectionIteratorSafe
	Safe iterators for bijectionIterator. More...

class	BijectionIteratorStaticEnd
	A class which creates the static iterator used by gim::Bijections. More...

class	BinaryJoinTreeConverter

class	BinaryJoinTreeConverterDefault

class	BinSearchTree
	A generic binary search tree. More...

class	BinSearchTreeIterator
	A Generic binary search tree. More...

class	BinTreeNode
	Nodes of a binary trees. More...

class	BNdistance

class	BNReader
	Pure virtual class for reading a BN from a file. More...

class	BNWriter
	Pure virtual class for writting a BN to a file. More...

class	Chi2
	Represent the chi2 distribution. More...

class	Chi2TestPolicy
	<agrum/tools/multidim/core/testPolicy/Chi2TestPolicy.h> More...

class	ChiSquare
	<agrum/FMDP/learning/core/testPolicy/chiSquare.h> More...

class	CliqueGraph
	Basic graph of cliques. More...

class	CNFWriter
	Writes a IBayesNet in the BN format. More...

class	CompleteProjectionRegister4MultiDim
	A container for registering complete projection functions on multiDimImplementations, i.e., functions projecting tables over all their variables. More...

struct	CompleteProjections4MultiDimInitialize
	a class used to register complete projections over non-pointers typesThis class is of course completely redundant with function completeProjections4MultiDimInit. More...

struct	CompleteProjections4MultiDimInitialize< GUM_SCALAR *>
	a class used to register complete projections over pointers typesThis class is of course completely redundant with function pointerCompleteProjections4MultiDimInit. More...

class	ComposedLeaf
	<agrum/FMDP/learning/datastructure/leaves/composedLeaf.h> More...

class	ConcreteLeaf
	<agrum/FMDP/learning/datastructure/leaves/concreteLeaf.h> More...

class	ContextualDependenciesCNFWriter
	<agrum/BN/io/cnf/ContextualDependenciesCNFWriter.h> More...

class	ContingencyTable
	<agrum/FMDP/learning/core/contingencyTable.h> More...

class	ContinuousVariable
	Defines a continuous random variable. More...

class	CPTError

class	CPTNoSumTo1

class	DAG
	Base class for dag. More...

class	DAGCycleDetector
	A class for detecting directed cycles in DAGs when trying to apply many changes to the graph. More...

class	DAGmodel
	Virtual base class for PGMs using a DAG. More...

class	DatabaseError

class	DecisionPotential
	<agrum/ID/inference/decisionPotential.h> More...

class	DefaultEliminationSequenceStrategy
	An efficient unconstrained elimination sequence algorithm. More...

class	DefaultInLabel

class	DefaultJunctionTreeStrategy
	An algorithm producing a junction given the elimination tree produced by a triangulation algorithm. More...

class	DefaultPartialOrderedEliminationSequenceStrategy
	An Elimination sequence algorithm that imposes a given partial ordering on the nodes elimination sequence. More...

class	DefaultTriangulation
	The default triangulation algorithm used by aGrUM. More...

class	DiGraph
	Base class for all oriented graphs. More...

class	DiGraphListener
	Abstract Base class for all diGraph Listener. More...

class	Directory
	Cross-platform directory utility. More...

class	Dirichlet
	A class for sampling w.r.t. More...

class	DiscreteVariable
	Base class for discrete random variable. More...

class	DiscretizedVariable
	Class for discretized random variable. More...

class	dSeparation
	the d-separation algorithm as described in Koller & Friedman (2009) More...

class	DSLReader
	Pure virtual class for reading a BN from a file. More...

class	DSLWriter
	Writes a IBayesNet in the DSL format. More...

class	dummyHash

class	DuplicateElement

class	DuplicateLabel

class	E_GreedyDecider
	<agrum/FMDP/decision/E_GreedyDecider.h> More...

class	Edge
	The base class for all undirected edges. More...

class	EdgeGraphPart
	Classes for undirected edge sets. More...

class	EliminationSequenceStrategy
	The base class for all elimination sequence algorithms used by triangulation algorithms. More...

class	EmptyBSTree

class	EmptySet

class	ErrorsContainer
	This class is used contain and manipulate gum::ParseError. More...

class	EssentialGraph
	Class building the essential graph from a BN. More...

class	Estimator

class	EvidenceInference
	<agrum/BN/inference/evidenceInference.h> More...

class	EvidenceMNInference
	<agrum/MN/inference/evidenceMNInference.h> More...

class	ExactBNdistance
	ExactBNdistance computes exactly the KL divergence betweens 2 BNs. More...

class	ExactPolicy
	Class implementing exact approximation policy (meaning a value is approximate to itself). More...

class	ExactTerminalNodePolicy
	Implementation of a Terminal Node Policy that maps nodeid directly to value. More...

class	Exception
	Base class for all aGrUM's exceptions. More...

class	FactorisedValuesCNFWriter
	<agrum/BN/io/cnf/FactorisedValuesCNFWriter.h> More...

class	FactoryError

class	FactoryInvalidState

class	FactorySimulator
	A class to simulate the Factory problem. More...

class	FatalError

class	FixedAllocator
	Allocates objects of one given size. More...

class	FMDP
	This class is used to implement factored decision process. More...

class	FMDPDatReader
	Definition of templatized reader of FMDPDat files for Factored Markov Decision Processes. More...

class	FMDPFactory
	A factory class to ease Factored Markov Decision Process construction. More...

class	FMDPLearner

class	FMDPReader
	Pure virtual class for reading a FMDP from a file. More...

class	FMDPSimulator
	<agrum/FMDP/simulation/fmdpSimulator.h> More...

class	FormatNotFound

class	Formula
	Evaluates a string as a algebraic formula. More...

class	FormulaPart
	Represents part of a formula. More...

class	FusionContext
	<agrum/FMDP/learning/datastructure/leaves/fusionContext.h> More...

class	GammaLog2
	The class for computing Log2 (Gamma(x)) More...

class	GeneralizedCNFWriter
	<agrum/BN/io/cnf/GeneralizedCNFWriter.h> More...

class	GibbsBNdistance
	GibbsKL computes the KL divergence betweens 2 BNs using an approximation pattern: GIBBS sampling. More...

class	GibbsOperator
	class containing all variables and methods required for Gibbssampling More...

class	GibbsSampling
	<agrum/BN/inference/gibbsSampling.h> More...

class	GraphError

class	GraphicalModel
	Virtual base class for probabilistic graphical models. More...

class	GraphicalModelInference
	<agrum/tools/graphicalModels/graphicalModel.h> More...

class	GTestPolicy
	<agrum/tools/multidim/core/testPolicies/GTestPolicy.h> More...

class	HashFunc
	Class template representing hashing function of `LpCol`. More...

class	HashFunc< bool >
	Hash function for booleans. More...

class	HashFunc< credal::lp::LpCol >

class	HashFunc< Debug >
	Hash function for gum::Debug. More...

class	HashFunc< double >
	Hash function for doubles. More...

class	HashFunc< float >
	Hash function for floats. More...

class	HashFunc< Instantiation >
	Hash function for gum::Instantiation. More...

class	HashFunc< int >
	Hash function for integers. More...

class	HashFunc< learning::ArcAddition >
	the hash function for Arc Additions More...

class	HashFunc< learning::ArcDeletion >
	the hash function for Arc Deletions More...

class	HashFunc< learning::ArcReversal >
	the hash function for Arc Reversals More...

class	HashFunc< learning::EdgeAddition >
	the hash function for Edge Additions More...

class	HashFunc< learning::EdgeDeletion >
	the hash function for Edge Deletions More...

class	HashFunc< learning::GraphChange >
	the hash function for Graph Changes More...

class	HashFunc< learning::IdCondSet< ALLOC > >
	the hash function for idSets More...

class	HashFunc< long >
	Hash function for long integers. More...

class	HashFunc< RefPtr< Type > >
	Hash function for RefPtr. More...

class	HashFunc< Set< T, Alloc > >
	the hash function for sets of int More...

class	HashFunc< std::pair< Key1, Key2 > >

class	HashFunc< std::string >
	Hash function for strings. More...

class	HashFunc< std::tuple< unsigned int, unsigned int, unsigned int > >
	the hash function for tuple (unsigned int, unsigned int,unsigned int) More...

class	HashFunc< std::vector< Idx > >
	Hash function for vectors of gum::Idx. More...

class	HashFunc< Type *>
	Hash function for pointers. More...

class	HashFunc< typename HashFuncConditionalType< std::size_t, unsigned long, unsigned int, long, int >::type >
	Hash function for std::size_t. More...

class	HashFunc< unsigned int >
	Hash function for unsigned integers. More...

class	HashFunc< unsigned long >
	Hash function for unsigned long integers. More...

class	HashFuncBase
	All hash functions should inherit from this class. More...

class	HashFuncCastKey
	Generic hash functions for keys castable as Size whose size is either smaller than Size, or equal to that of one or two Size. More...

class	HashFuncConditionalType
	This class enables to safely define hash functions for types that may or may not already has defined hash functionsThere are types that are defined differently depending on the architecture or the compiler you use. More...

struct	HashFuncConditionalType< Key >

struct	HashFuncConditionalType< KEY_TYPE, FIRST_TYPE, OTHER_TYPES... >

struct	HashFuncConditionalType< KEY_TYPE, TYPE >

class	HashFuncConst
	Useful constants for hash functions. More...

class	HashFuncLargeCastKey
	Generic hash functions for keys castable as Size and whose size is precisely twice that of Size. More...

class	HashFuncMediumCastKey
	Generic hash functions for keys castable as Size and whose size is precisely that of Size. More...

class	HashFuncSmallCastKey
	Generic hash functions for keys castable as Size and whose size is strictly smaller than that of Size. More...

class	HashFuncSmallKey
	Generic hash functions for numeric keys smaller than or equal to Size. More...

class	HashTable
	The class for generic Hash Tables. More...

class	HashTableBucket
	A recipient for a pair of key value in a gum::HashTableList. More...

class	HashTableConst
	Parameters specifying the default behavior of the hashtables. More...

class	HashTableConstIterator
	Unsafe Const Iterators for hashtablesHashTableConstIterator provides a fast but unsafe way to parse HashTables. More...

class	HashTableConstIteratorSafe
	Safe Const Iterators for hashtables. More...

class	HashTableIterator
	Unsafe Iterators for hashtablesHashTableIterator provides a fast but unsafe way to parse HashTables. More...

class	HashTableIteratorSafe
	Safe Iterators for hashtables. More...

class	HashTableIteratorStaticEnd
	A class used to create the static iterator used by HashTables. More...

class	HashTableList
	A chained list used by gum::HashTable. More...

class	Heap
	Heap data structureThis structure is a basic heap data structure, i.e., it is a container in which elements are sorted according to a weak ordering. More...

class	IApproximationSchemeConfiguration
	Approximation Scheme. More...

class	IBayesNet
	Class representing the minimal interface for Bayesian network. More...

class	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). More...

class	IBayesNetGenerator
	Class for generating Bayesian networks. More...

class	IContinuousVariable
	A base class for continuous variables, independent of the GUM_SCALAR type. More...

class	IDecisionStrategy
	<agrum/FMDP/SDyna/IDecisionStrategy.h> More...

class	IdError

class	IDiscretizedVariable
	A base class for discretized variables, independent of the ticks type. More...

class	IDReader
	Pure virtual class for importing an ID from a file. More...

class	IDWriter
	Pure virtual class for exporting an ID. More...

class	ILearningStrategy
	<agrum/FMDP/SDyna/ILearningStrategy.h> More...

class	IMarkovNet
	Class representing the minimal interface for Markov Network. More...

class	IMDDI

class	ImportanceSampling

class	IncompatibleEvidence
	Exception : several evidence are incompatible together (proba=0) More...

class	IncompatibleScoreApriori

class	IncrementalGraphLearner
	<agrum/FMDP/learning/datastructure/incrementalGraphLearner> More...

class	IncrementalTriangulation
	Class that performs incremental triangulations. More...

class	IndexedTree
	The class for storing the nodes of the Arborescence. More...

class	InfluenceDiagram
	Class representing an Influence Diagram. More...

class	InfluenceDiagramGenerator
	<agrum/ID/generator/influenceDiagramGenerator.h> More...

class	InfluenceDiagramInference
	<agrum/ID/inference/influenceDiagramInference.h> More...

class	Instantiation
	Class for assigning/browsing values to tuples of discrete variables. More...

struct	Int2Type

class	InternalNode
	Structure used to represent a node internal structure. More...

class	InvalidArc

class	InvalidArgument

class	InvalidArgumentsNumber

class	InvalidDirectedCycle

class	InvalidEdge

class	InvalidNode

class	IOError

class	IOperatorStrategy
	<agrum/FMDP/SDyna/IOperatorStrategy.h> More...

class	IPlanningStrategy
	<agrum/FMDP/SDyna/IPlanningStrategy.h> More...

class	ITerminalNodePolicy
	Interface specifying the methods to be implemented by any TerminalNodePolicy. More...

class	ITestPolicy
	<agrum/tools/multidim/core/testPolicies/ITestPolicy.h> More...

class	ITI
	Learn a graphical representation of a function as a decision tree. More...

class	IVisitableGraphLearner
	<agrum/FMDP/SDyna/IVisitableGraphLearner.h> More...

class	JointTargetedInference
	<agrum/BN/inference/jointTargetedInference.h> More...

class	JointTargetedMNInference
	<agrum/MN/inference/jointTargetedMNInference.h> More...

class	JunctionTreeStrategy
	Base Class for all the algorithms producing a junction given a set of cliques/subcliques resulting from a triangulation. More...

class	LabelizedVariable
	class LabelizedVariable More...

class	LazyDecider
	Class to make decision randomlyDoes nothing more than the interface for DecisionStrategy does. More...

class	LazyPropagation
	<agrum/BN/inference/lazyPropagation.h> More...

class	LeafAggregator
	<agrum/FMDP/learning/FunctionGraph/leafAggregator.h> More...

class	LeafPair
	<agrum/FMDP/learning/datastructure/leaves/leafPair.h> More...

struct	LearnerSelect

struct	LearnerSelect< ITILEARNER, A, B >

class	LearningError

class	LeastSquareTestPolicy
	<agrum/tools/multidim/core/testPolicy/leastSquareTestPolicy.h> More...

class	LinearApproximationPolicy
	Class implementing linear approximation policy (meaning possible value are split out in interval). More...

class	Link
	Link of a chain list allocated using the SmallObjectAllocator. More...

class	LinkedList
	Chain list allocated using the SmallObjectAllocator. More...

class	List
	Generic doubly linked lists. More...

class	ListBucket
	Bucket for a chained list. More...

class	ListConstIterator
	Unsafe but fast const iterators for Lists. More...

class	ListConstIteratorSafe
	Safe const iterators for Lists. More...

class	Listener
	Every class who would catch signal from signaler should derive from Listener. More...

class	ListIterator
	Unsafe but fast iterators for Lists. More...

class	ListIteratorSafe
	Safe iterators for Lists. More...

class	LoopyBeliefPropagation
	<agrum/BN/inference/loopyBeliefPropagation.h> More...

class	LoopySamplingInference
	<agrum/BN/inference/loopySamplingInference.h> More...

class	MarginalTargetedInference
	<agrum/BN/inference/marginalTargetedInference.h> More...

class	MarginalTargetedMNInference
	<agrum/MN/inference/marginalTargetedMNInference.h> More...

class	MarkovBlanket
	Class building the markov Blanket from a BN and a nodeName. More...

class	MarkovNetInference
	<agrum/MN/inference/MarkovNetInference.h> More...

struct	Maximizes
	Maximization function object classReturns the maximum of its two arguments. More...

class	MaxInducedWidthMCBayesNetGenerator
	maxInducedWidthMCBayesNetGenerator.h <agrum/BN/generator/SimpleMCayesNetGenerator.h> More...

class	MaxParentsMCBayesNetGenerator
	<agrum/BN/generator/SimpleMCayesNetGenerator.h> More...

class	MCBayesNetGenerator
	<agrum/BN/generator/MCayesNetGenerator.h> More...

class	MDDOperatorStrategy
	<agrum/FMDP/planning/mddOperatorStrategy.h> More...

struct	Minimizes
	Minimization function object classReturns the minimum of its two arguments. More...

class	MissingValueInDatabase

class	MissingVariableInDatabase

class	MixedGraph
	Base class for mixed graphs. More...

class	MixedGraphListener
	Abstract Base class for all mixed Graph Listener. More...

class	MNReader
	Pure virtual class for reading a MN from a file. More...

class	MNWriter
	Pure virtual class for writting a MN to a file. More...

class	MonteCarloSampling

class	MultiDimAdressable
	Abstract base class for all multi dimensionnal addressable. More...

class	MultiDimArray
	Multidimensional matrix stored as an array in memory. More...

class	MultiDimBijArray
	Decorator of a MultiDimArray, using a bijection over the variables. More...

class	MultiDimBucket
	A multidim implementation for buckets. More...

class	MultiDimCombination
	A generic interface to combine efficiently several MultiDim tables. More...

class	MultiDimCombinationDefault
	A class to combine efficiently several MultiDim tablesMultiDimCombinationDefault is a class designed to combine efficiently several multidimensional objects, that is, to compute expressions like T1 op T2 op T3 op .... More...

class	MultiDimCombineAndProject
	A generic interface to combine and project efficiently MultiDim tables. More...

class	MultiDimCombineAndProjectDefault
	An efficient class for combining and projecting MultiDim tables. More...

class	MultiDimCompleteProjection
	A generic class to project efficiently a MultiDim table over all of its variables. More...

class	MultiDimContainer
	Abstract base class for all multi dimensionnal containers. More...

class	MultiDimDecorator
	Decorator design pattern in order to separate implementations from multidimensional matrix concepts. More...

class	MultiDimFunctionGraph
	Class implementingting a function graph. More...

class	MultiDimFunctionGraphGenerator
	Class implementing a function graph generator with template type double. More...

class	MultiDimFunctionGraphManager
	Class implementingting a function graph manager. More...

class	MultiDimFunctionGraphOperator
	Class used to perform Function Graph Operations. More...

class	MultiDimFunctionGraphProjector
	Class used to perform Function Graph projections. More...

class	MultiDimFunctionGraphROManager

class	MultiDimFunctionGraphTreeManager

class	MultiDimICIModel
	abstract class for Conditional Indepency Models More...

class	MultiDimImplementation
	<agrum/tools/multidim/multiDimImplementation.h> More...

class	MultiDimInterface
	Interface for all classes addressing in a multiDim fashion. More...

class	MultiDimLogit
	Logit representation. More...

class	MultiDimNoisyAND
	Noisy AND representation. More...

class	MultiDimNoisyORCompound
	Noisy OR representation. More...

class	MultiDimNoisyORNet
	Noisy OR representation. More...

class	MultiDimPartialInstantiation
	A generic class to instantiate a subset of variables of a multidimensional table. More...

class	MultiDimProjection
	A generic class to project efficiently a MultiDim table over a subset of its variables. More...

class	MultiDimReadOnly
	Abstract base class for all multi dimensionnal read only structure. More...

class	MultiDimSparse
	Multidimensional matrix stored as a sparse array in memory. More...

class	MultiDimWithOffset
	Abstract class for Multidimensional matrix stored as an array in memory and with an offset associated with each slave instantiation. More...

class	MultiPriorityQueue
	A MultiPriorityQueue is a heap in which each element has a mutable priority and duplicates are allowedA priority queue is quite similar to a heap except that a priority (a score) is assigned to each element in the structure. More...

class	NetReader
	Pure virtual class for reading a BN from a file. More...

class	NetWriter
	Writes a IBayesNet in the BN format. More...

class	NoChild

class	NodeDatabase
	<agrum/FMDP/learning/datastructure/nodeDatabase.h> More...

class	NodeGraphPart
	Class for node sets in graph. More...

class	NodeGraphPartIterator
	Unsafe iterator on the node set of a graph. More...

class	NodeGraphPartIteratorSafe
	Safe iterator on the node set of a graph. More...

class	NoNeighbour

class	NoParent

class	NotFound

class	NotImplementedYet

class	NullElement

struct	NullStream
	Implements a stream with the same behaviour as /dev/null. More...

class	O3prmBNReader
	Read an O3PRM and transform the gum::prm::PRMSystem into gum::BayesNet. More...

class	O3prmBNWriter
	<agrum/PRM/o3prm/O3prmBNWriter.h> More...

class	O4DGContext
	Class used to manipulate context during Function Graph Operations. More...

class	Observation

class	OperationNotAllowed

class	OperatorRegister4MultiDim
	A container for registering binary functions on multiDimImplementations. More...

struct	Operators4MultiDimInitialize
	a class used to register operators over non-pointers typesThis class is of course completely redundant with function operators4MultiDimInit. More...

struct	Operators4MultiDimInitialize< GUM_SCALAR *>
	a class used to register operators over pointers typesThis class is of course completely redundant with function pointerOperators4MultiDimInit. More...

class	OrderedEliminationSequenceStrategy
	An Elimination sequence algorithm that imposes a given complete ordering on the nodes elimination sequence. More...

class	OrderedTriangulation
	class for graph triangulations for which we enforce a given complete ordering on the nodes eliminations. More...

class	OutOfBounds

class	OutOfLowerBound

class	OutOfUpperBound

class	Parent
	Represent a node's parent. More...

class	ParseError
	This class is used to represent parsing errors for the different parser implemented in aGrUM. More...

class	PartialInstantiation4MultiDimInitialize
	A class used to register instantiation functions over non-pointers types. More...

struct	PartialInstantiation4MultiDimInitialize< GUM_SCALAR *>

class	PartialInstantiationRegister4MultiDim
	A container for registering partial instantiation functions on multiDimImplementations, i.e., functions assigning values to subsets of the variables of some tables. More...

class	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. More...

class	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. More...

class	PossiblyIncompatibleScoreApriori

class	Potential
	aGrUM's Potential is a multi-dimensional array with tensor operators. More...

class	PriorityQueue
	A priorityQueue is a heap in which each element has a mutable priorityA priority queue is quite similar to a heap except that a priority (a score) is assigned to each element in the structure. More...

class	PriorityQueueImplementation
	The internal class for representing priority queues. More...

class	PRMAggregate
	Defines an aggregate in a PRM. More...

class	PRMTypeError

class	ProgressListener
	The ProgressListener class. More...

class	ProgressNotifier
	Notification for progress using listener. More...

class	ProjectionRegister4MultiDim
	A container for registering projection functions on multiDimImplementations, i.e., functions projecting tables over a subset of their variables. More...

struct	Projections4MultiDimInitialize
	a class used to register projections over non-pointers types More...

struct	Projections4MultiDimInitialize< GUM_SCALAR *>
	a class used to register projections over pointers types More...

class	RandomDecider
	Class to make decision randomlyDoes nothing more than the interface for DecisionStrategy does. More...

class	RangeVariable
	Defines a discrete random variable over an integer interval. More...

class	Rational
	Class template used to approximate decimal numbers by rationals. More...

class	ReferenceError

class	RefPtr
	Smart pointersaGrUM's smart pointers keep track of the number of times the value they point to is referenced. More...

class	Regress
	Class used to perform Function Graph Operations in the FMDP Framework. More...

class	SamplingInference
	<agrum/BN/inference/samplingInference.h> More...

class	Schedule
	Class containing a schedule of operations to perform on multidims. More...

class	ScheduleCliqueStoreMultiDim

class	ScheduleCombination

class	ScheduleCombinationBasic

class	ScheduleCombine

class	ScheduleDeleteMultiDim

class	ScheduleMultiDim
	a MultiDimImplementation Wrapper used for scheduling inferences More...

class	ScheduleOperation

class	ScheduleProject

class	ScheduleProjection

class	ScheduleProjectionBasic

class	Scheduler

class	SchedulerBasic

class	ScheduleSeparatorStoreMultiDim

class	SDYNA
	The general SDyna architecture abstract class. More...

class	Sequence
	The generic class for storing (ordered) sequences of objects. More...

class	SequenceImplementation
	The internal class for storing (ordered) sequences of objects. More...

class	SequenceIteratorSafe
	Safe iterators for Sequence. More...

class	Set
	Representation of a setA Set is a structure that contains arbitrary elements. More...

class	SetInst
	Class for assigning/browsing values to tuples of discrete variables. More...

class	SetIterator
	Unsafe iterators for the Set class. More...

class	SetIteratorSafe
	Safe iterators for the Set classDevelopers may consider using Set<x>::iterator_safe instead of SetIteratorSafe<x>. More...

class	SetTerminalNodePolicy
	Implementation of a Terminal Node Policy that maps nodeid to a set of value. More...

class	ShaferShenoyInference
	<agrum/BN/inference/ShaferShenoyInference.h> More...

class	ShaferShenoyLIMIDInference

class	ShaferShenoyMNInference
	<agrum/MN/inference/ShaferShenoyMNInference.h> More...

class	Signaler0
	class for signal with 0 args More...

class	SimpleBayesNetGenerator
	<agrum/BN/generator/simpleBayesNetGenerator.h> More...

class	SimpleCPTDisturber
	<agrum/BN/generator/simpleCPTDisturber.h> More...

class	SimpleCPTGenerator
	<agrum/BN/generator/simpleCPTGenerator.h> More...

class	SimpleUTGenerator
	Class for generating Utility Tables. More...

class	SimplicialSet
	Class enabling fast retrieval of simplicial, quasi and almost simplicial nodes. More...

class	SizeError

class	SmallObjectAllocator
	<agrum/tools/core/smallObjectAllocator.h> More...

class	SpanningForest
	Base class for computing min cost spanning trees or forests. More...

class	SpanningForestPrim
	The Prim algorithm for computing min cost spanning trees or forests. More...

class	SplayBinaryNode
	the nodes of splay trees More...

class	SplayTree
	A splay tree. More...

class	StatesChecker
	<agrum/FMDP/simulation/statesChecker.h> More...

class	StatesCounter
	<agrum/FMDP/simulation/statesCounter.h> More...

class	StaticTriangulation
	base class for all non-incremental triangulation methods More...

class	StatisticalLazyDecider
	<agrum/FMDP/decision/statisticalLazyDecider.h> More...

class	StructuralComparator
	A class for comparing graphs based on their structures. More...

class	StructuredPlaner
	<agrum/FMDP/planning/structuredPlaner.h> More...

class	SyntaxError

class	TaxiSimulator
	A class to simulate the Taxi problem. More...

struct	TestSelect

struct	TestSelect< CHI2TEST, A, B, C >

struct	TestSelect< LEASTSQUARETEST, A, B, C >

class	ThreadData
	A wrapper that enables to store data in a way that prevents false cacheline sharing. More...

class	Timer
	Class used to compute response times for benchmark purposesThis class represents a classic timer, it starts in the constructor, you can reset it with method reset() and you can get the delta time with the method step(). More...

class	TreeOperator
	Class used to perform Decision Tree Operation in the FMDP Framework. More...

class	TreeOperatorStrategy
	<agrum/FMDP/planning/treeOperatorStrategy.h> More...

class	TreeRegress
	Class used to perform Decision Tree Regression in the FMDP Framework. More...

class	Triangulation
	Interface for all the triangulation methods. More...

class	TypeError

class	UAIBNReader
	Pure virtual class for reading a BN from a file. More...

class	UAIBNWriter
	<agrum/BN/io/UAI/UAIBNWriter.h> More...

class	UAIMNReader
	Pure virtual class for reading a MN from a file. More...

class	UAIMNWriter
	<agrum/MN/io/UAI/UAIMNWriter.h> More...

class	UGmodel
	Virtual base class for PGMs using a undirected graph. More...

class	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. More...

class	UnconstrainedTriangulation
	Interface for all triangulation methods without constraints on node elimination orderings. More...

class	UndefinedElement

class	UndefinedIteratorKey

class	UndefinedIteratorValue

class	UndiGraph
	Base class for undirected graphs. More...

class	UndiGraphListener
	Abstract Base class for all undiGraph Listener. More...

class	UnknownLabelInDatabase

class	UTGenerator
	Abstract class for generating Utility Tables. More...

struct	ValueSelect

struct	ValueSelect< false, A, B >

class	Variable
	Base class for every random variable. More...

class	VariableElimination
	<agrum/BN/inference/variableElimination.h> More...

class	VariableLog2ParamComplexity
	the class for computing the log2 of the parametric complexity of an r-ary multinomial variableThis class enables to compute the log in base 2 of the parametric complexity of a single r-ary multinomial variable, i.e., the log in base 2 of the C_N^r term used by NML scores in Bayesian network structure learning algorithm (see, e.g., Silander, Roos, Kontkanen and Myllymaki (2007) "Factorized Normalized Maximum " Likelihood Criterion for Learning Bayesian network Structures)" More...

class	VariableNodeMap
	Container used to map discrete variables with nodes. More...

class	VariableSelector
	<agrum/FMDP/planning/FunctionGraph/variableselector.h> More...

class	WeightedSampling

class	WrongClassElement

Typedefs
typedef Size	NodeId
	Type for node ids. More...

template<typename GUM_SCALAR >
using	HybridMonteCarloSampling = LoopySamplingInference< GUM_SCALAR, MonteCarloSampling >

template<typename GUM_SCALAR >
using	HybridWeightedSampling = LoopySamplingInference< GUM_SCALAR, WeightedSampling >

template<typename GUM_SCALAR >
using	HybridImportanceSampling = LoopySamplingInference< GUM_SCALAR, ImportanceSampling >

template<typename GUM_SCALAR >
using	HybridGibbsSampling = LoopySamplingInference< GUM_SCALAR, GibbsSampling >

typedef HashTableConstIteratorSafe< LeafPair *, std::vector< Size > >	pair_iterator

template<typename GUM_SCALAR >
using	FactorTable = HashTable< NodeSet, const Potential< GUM_SCALAR > *>

typedef CliqueGraph	JunctionTree
	a junction tree is a clique graph satisfying the running intersection property and such that no clique is included into another one. More...

typedef CliqueGraph	JoinTree
	a join tree is a clique graph satisfying the running intersection property (but some cliques may be included into others) More...


typedef Set< NodeId >	NodeSet
	Some typdefs and define for shortcuts ... More...

typedef Set< Edge >	EdgeSet
	Some typdefs and define for shortcuts ... More...

typedef Set< Arc >	ArcSet
	Some typdefs and define for shortcuts ... More...

typedef ArcSet::const_iterator	ArcSetIterator
	Some typdefs and define for shortcuts ... More...

typedef EdgeSet::const_iterator	EdgeSetIterator
	Some typdefs and define for shortcuts ... More...

typedef NodeSet::const_iterator	NodeSetIterator
	Some typdefs and define for shortcuts ... More...


template<class VAL >
using	NodeProperty = HashTable< NodeId, VAL >
	Property on graph elements. More...

template<class VAL >
using	EdgeProperty = HashTable< Edge, VAL >
	Property on graph elements. More...

template<class VAL >
using	ArcProperty = HashTable< Arc, VAL >
	Property on graph elements. More...


typedef std::size_t	Size
	In aGrUM, hashed values are unsigned long int. More...

typedef Size	Idx
	Type for indexes. More...

Enumerations
enum	Complexity : char { Complexity::Heavy, Complexity::Difficult, Complexity::Correct }
	Complexity allows to characterize the awaited difficulty for an algorithm given a specific instance Therefore this is not a theoretical characterization but rather a pragmatic rate of that very instance. More...

enum	FindBarrenNodesType { FindBarrenNodesType::FIND_NO_BARREN_NODES, FindBarrenNodesType::FIND_BARREN_NODES }
	type of algorithm to determine barren nodes More...

enum	RelevantPotentialsFinderType { RelevantPotentialsFinderType::FIND_ALL, RelevantPotentialsFinderType::DSEP_BAYESBALL_NODES, RelevantPotentialsFinderType::DSEP_BAYESBALL_POTENTIALS, RelevantPotentialsFinderType::DSEP_KOLLER_FRIEDMAN_2009 }
	type of algorithm for determining the relevant potentials for combinations using some d-separation analysis More...

enum	FMDPfactory_state : char { FMDPfactory_state::NONE, FMDPfactory_state::VARIABLE, FMDPfactory_state::ACTION, FMDPfactory_state::TRANSITION, FMDPfactory_state::COST, FMDPfactory_state::REWARD, FMDPfactory_state::DISCOUNT }
	The enumeration of states in which the factory can be in. More...

enum	TESTNAME { GTEST = 1, CHI2TEST = 2, LEASTSQUARETEST = 3 }

enum	LEARNERNAME { IMDDILEARNER = 1, ITILEARNER = 2 }

enum	FactorySimulationLandmark : Idx { HOME = 0, WORK = 1, THEATER = 2, CLUB = 3, Factory = 4 }

enum	FactorySimulationLandmarkX : Idx { HOMEX = 0, WORKX = 0, THEATERX = 3, CLUBX = 4, STATIONX = 2 }

enum	FactorySimulationLandmarkY : Idx { HOMEY = 0, WORKY = 4, THEATERY = 0, CLUBY = 4, STATIONY = 1 }

enum	FactorySimulationAction : Idx { GoNorth = 0, GoEast = 1, GoSouth = 2, GoWest = 3, PickUp = 4, PutDown = 5, FillUp = 6 }

enum	TaxiSimulationLandmark : Idx { HOME = 0, WORK = 1, THEATER = 2, CLUB = 3, TAXI = 4 }

enum	TaxiSimulationLandmarkX : Idx { HOMEX = 0, WORKX = 0, THEATERX = 3, CLUBX = 4, STATIONX = 2 }

enum	TaxiSimulationLandmarkY : Idx { HOMEY = 0, WORKY = 4, THEATERY = 0, CLUBY = 4, STATIONY = 1 }

enum	TaxiSimulationAction : Idx { GoNorth = 0, GoEast = 1, GoSouth = 2, GoWest = 3, PickUp = 4, PutDown = 5, FillUp = 6 }

enum	BinTreeDir : char { BinTreeDir::LEFT_CHILD = 0, BinTreeDir::RIGHT_CHILD = 1, BinTreeDir::NO_PARENT = 2 }
	The direction of a given edge in a binary tree. More...

enum	VarType : char { VarType::Discretized, VarType::Labelized, VarType::Range, VarType::Continuous }

Functions
void	print_stack (std::stack< FormulaPart > s)

void	print_output (std::vector< FormulaPart > v)

std::string	func2str (FormulaPart::token_function func)

std::ostream &	operator<< (std::ostream &stream, const DiGraph &g)
	for friendly displaying the content of directed graphs More...

std::ostream &	operator<< (std::ostream &stream, const MixedGraph &g)
	for friendly displaying the content of directed graphs More...

std::ostream &	operator<< (std::ostream &s, const ArcGraphPart &a)
	for friendly displaying the content of arc set More...

std::ostream &	operator<< (std::ostream &, const EdgeGraphPart &)
	for friendly displaying the content of an edge set More...

std::ostream &	operator<< (std::ostream &, const NodeGraphPart &)
	for friendly displaying the content of node set More...

std::ostream &	operator<< (std::ostream &stream, const UndiGraph &g)
	for friendly displaying the content of undirected graphs More...

std::ostream &	operator<< (std::ostream &stream, const Edge &edge)
	to friendly display an edge More...

std::ostream &	operator<< (std::ostream &stream, const Arc &arc)
	to friendly display an arc More...

MultiDimInterface &	operator<< (MultiDimInterface &c, const DiscreteVariable &v)
	Adds a new var to the sequence of vars. More...

MultiDimInterface &	operator>> (MultiDimInterface &c, const DiscreteVariable &v)
	Removes a var from the variables of the MutliDimAdressing. More...

std::ostream &	operator<< (std::ostream &, const Instantiation &)
	Print information of the instantiation in the stream. More...

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &output, const BayesNet< GUM_SCALAR > &bn)
	Prints map's DAG in output using the Graphviz-dot format. More...

template<typename GUM_SCALAR >
NodeId	build_node (gum::BayesNet< GUM_SCALAR > &bn, std::string node, gum::Size default_domain_size)

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &output, const BayesNet< GUM_SCALAR > &bn)
	Prints map's DAG in output using the Graphviz-dot format. More...

template<typename GUM_SCALAR >
gum::Size	getMaxModality (gum::BayesNet< GUM_SCALAR > &bayesNet)

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &output, const IBayesNet< GUM_SCALAR > &bn)
	Prints map's DAG in output using the Graphviz-dot format. More...

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &output, const IBayesNet< GUM_SCALAR > &bn)
	Prints map's DAG in output using the Graphviz-dot format. More...

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	LPNewmultiPotential (const Potential< GUM_SCALAR > &t1, const Potential< GUM_SCALAR > &t2)

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	LPNewprojPotential (const Potential< GUM_SCALAR > &t1, const Set< const DiscreteVariable * > &del_vars)

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	SSNewmultiPotential (const Potential< GUM_SCALAR > &t1, const Potential< GUM_SCALAR > &t2)

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	SSNewprojPotential (const Potential< GUM_SCALAR > &t1, const Set< const DiscreteVariable * > &del_vars)

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	VENewmultiPotential (const Potential< GUM_SCALAR > &t1, const Potential< GUM_SCALAR > &t2)

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	VENewprojPotential (const Potential< GUM_SCALAR > &t1, const Set< const DiscreteVariable * > &del_vars)

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &out, const DecisionPotential< GUM_SCALAR > &array)

template<typename GUM_SCALAR >
NodeId	build_node_for_ID (gum::InfluenceDiagram< GUM_SCALAR > &infdiag, std::string node, gum::Size default_domain_size)

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &output, const IMarkovNet< GUM_SCALAR > &mn)
	Prints map's graph in output using the Graphviz-dot format. More...

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &output, const IMarkovNet< GUM_SCALAR > &bn)
	Prints map's graph in output using the Graphviz-dot format. More...

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	SSNewMNmultiPotential (const Potential< GUM_SCALAR > &t1, const Potential< GUM_SCALAR > &t2)

template<typename GUM_SCALAR >
static INLINE Potential< GUM_SCALAR > *	SSNewMNprojPotential (const Potential< GUM_SCALAR > &t1, const Set< const DiscreteVariable * > &del_vars)

template<typename GUM_SCALAR >
NodeId	build_node_for_MN (MarkovNet< GUM_SCALAR > &mn, std::string node, Size default_domain_size)

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &output, const MarkovNet< GUM_SCALAR > &mn)

template<typename T1 , typename T2 , typename Alloc >
std::ostream &	operator<< (std::ostream &, const Bijection< T1, T2, Alloc > &bijection)
	For friendly display of the content of the gum::Bijection. More...

unsigned int	_hashTableLog2_ (const Size nb)
	Returns the size in bits - 1 necessary to store the smallest power of 2 greater than or equal to nb. More...

template<typename Key , typename Val , typename Alloc >
std::ostream &	operator<< (std::ostream &s, const HashTableList< Key, Val, Alloc > &list)
	Prints the content of a gum::HashTableList in the stream. More...

template<typename Key , typename Val , typename Alloc >
std::ostream &	operator<< (std::ostream &s, const HashTableList< Key *, Val, Alloc > &list)
	Prints the content of a gum::HashTableList with pointers key in the stream. More...

template<typename Key , typename Val , typename Alloc >
std::ostream &	operator<< (std::ostream &s, const HashTable< Key, Val, Alloc > &table)
	Prints the content of a gum::HashTable in the stream. More...

template<typename Key , typename Val , typename Alloc >
std::ostream &	operator<< (std::ostream &s, const HashTable< Key *, Val, Alloc > &table)
	Prints the content of a gum::HashTable with pointers key in the stream. More...

template<typename Val , typename Cmp , typename Alloc >
std::ostream &	operator<< (std::ostream &, const Heap< Val, Cmp, Alloc > &)

template<typename Val , typename Cmp , typename Alloc >
INLINE std::ostream &	operator<< (std::ostream &stream, const Heap< Val, Cmp, Alloc > &heap)

template<typename Key , typename Data >
std::ostream &	operator<< (std::ostream &, const IndexedTree< Key, Data > &)
	Necessary for the hashtable operator <<. More...

template<typename Val , typename Alloc >
std::ostream &	operator<< (std::ostream &stream, const List< Val, Alloc > &list)
	an << operator for List More...

template<typename Val >
ListConstIterator< Val >::difference_type	operator- (const ListConstIterator< Val > &iter1, const ListConstIterator< Val > &iter2)
	For STL compliance, a distance operator. More...

template<typename Val >
ListConstIteratorSafe< Val >::difference_type	operator- (const ListConstIteratorSafe< Val > &iter1, const ListConstIteratorSafe< Val > &iter2)
	For STL compliance, a distance operator. More...

template<typename Val >
INLINE ListConstIterator< Val >::difference_type	operator- (const ListConstIterator< Val > &iter1, const ListConstIterator< Val > &iter2)
	For STL compliance, a distance operator. More...

template<typename Val >
INLINE ListConstIteratorSafe< Val >::difference_type	operator- (const ListConstIteratorSafe< Val > &iter1, const ListConstIteratorSafe< Val > &iter2)
	For STL compliance, a distance operator. More...

template<typename Val >
std::ostream &	operator<< (std::ostream &stream, const List< Val > &list)

Formula	operator- (const Formula &a)

Formula	operator+ (const Formula &a, const Formula &b)

Formula	operator- (const Formula &a, const Formula &b)

Formula	operator* (const Formula &a, const Formula &b)

Formula	operator/ (const Formula &a, const Formula &b)

std::string	to_string (const Formula &f)

std::ostream &	operator<< (std::ostream &os, const Formula &f)

template<typename Val , typename Priority , typename Cmp , typename Alloc >
INLINE std::ostream &	operator<< (std::ostream &stream, const MultiPriorityQueue< Val, Priority, Cmp, Alloc > &queue)

bool	isOMP ()
	Is OMP active ? More...

void	setNumberOfThreads (unsigned int number)
	Set the number of threads to be used. More...

unsigned int	getMaxNumberOfThreads ()
	Returns the maximum number of threads at any time. More...

unsigned int	getThreadNumber ()
	Get the calling thread id. More...

unsigned int	getNumberOfRunningThreads ()
	Get the current number of running threads. More...

unsigned int	getNumberOfLogicalProcessors ()
	Get the number of logical processors. More...

void	setNestedParallelism (bool value)
	Set nested parallelism (false bu default). More...

bool	getNestedParallelism ()
	Get nested parallelism status. More...

void	setDynamicThreadsNumber (bool value)
	Set the dynamic threads number (false by default). More...

bool	getDynamicThreadsNumber ()
	Get the dynamic thread number adjustment status. More...

template<typename Val , typename Priority , typename Cmp , typename Alloc >
std::ostream &	operator<< (std::ostream &, const PriorityQueue< Val, Priority, Cmp, Alloc > &)

template<typename Val , typename Priority , typename Cmp , typename Alloc >
INLINE std::ostream &	operator<< (std::ostream &stream, const PriorityQueue< Val, Priority, Cmp, Alloc > &queue)

template<typename Val >
void	swap (RefPtr< Val > &ptr1, RefPtr< Val > &ptr2)
	Swap the contents of two RefPtr. More...

template<typename Key , typename Alloc >
std::ostream &	operator<< (std::ostream &stream, const Sequence< Key, Alloc > &s)
	A << operator for displaying the content of the Sequence. More...

template<typename Key , typename Alloc , bool Gen>
INLINE std::ostream &	operator<< (std::ostream &stream, const SequenceImplementation< Key, Alloc, Gen > &seq)

template<typename Key , typename Alloc >
INLINE std::ostream &	operator<< (std::ostream &stream, const SequenceImplementation< Key, Alloc, true > &seq)

template<typename Key , typename Alloc >
INLINE std::ostream &	operator<< (std::ostream &stream, const Sequence< Key, Alloc > &seq)
	A << operator for displaying the content of the Sequence. More...

template<typename Key , typename Alloc >
std::ostream &	operator<< (std::ostream &, const Set< Key, Alloc > &)
	A << operator for HashTableList. More...

template<typename Element >
INLINE std::ostream &	operator<< (std::ostream &out, const SplayBinaryNode< Element > &e)
	Display the node. More...

template<typename Element >
INLINE std::ostream &	operator<< (std::ostream &out, const SplayTree< Element > &s)
	Display the tree. More...

template<class Element >
static INLINE void	removeInfo (const SplayBinaryNode< Element > e, HashTable< Element, SplayBinaryNode< Element > > &addr)

template<typename Element >
std::ostream &	operator<< (std::ostream &out, const SplayBinaryNode< Element > &e)
	Display the node. More...

std::ostream &	operator<< (std::ostream &, const VariableNodeMap &)
	for friendly displaying the content of clique graphs More...

std::ostream &	operator<< (std::ostream &, const CliqueGraph &)
	for friendly displaying the content of clique graphs More...

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &s, const MultiDimLogit< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &s, const MultiDimLogit< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &s, const MultiDimNoisyAND< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &s, const MultiDimNoisyAND< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &s, const MultiDimNoisyORCompound< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &s, const MultiDimNoisyORCompound< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &s, const MultiDimNoisyORNet< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &s, const MultiDimNoisyORNet< GUM_SCALAR > &ag)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &out, const MultiDimContainer< GUM_SCALAR > &array)

template<typename GUM_SCALAR >
void	_initPotentialOperators__ ()

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &, const MultiDimImplementation< GUM_SCALAR > &)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
INLINE MultiDimImplementation< GUM_SCALAR > &	operator<< (MultiDimImplementation< GUM_SCALAR > &array, const DiscreteVariable &v)

template<typename GUM_SCALAR >
INLINE std::ostream &	operator<< (std::ostream &out, const MultiDimImplementation< GUM_SCALAR > &array)
	For friendly displaying the content of the array. More...

template<typename GUM_SCALAR >
Potential< GUM_SCALAR >	log2 (const Potential< GUM_SCALAR > &arg)

template<typename GUM_SCALAR >
Potential< GUM_SCALAR >	abs (const Potential< GUM_SCALAR > &arg)

template<typename GUM_SCALAR >
Potential< GUM_SCALAR >	sq (const Potential< GUM_SCALAR > &arg)

template<typename GUM_SCALAR >
std::ostream &	operator<< (std::ostream &out, const Potential< GUM_SCALAR > &array)

std::ostream &	operator<< (std::ostream &, const SetInst &)
	Print information of the SetInst in the stream. More...

gum::SetInst &	operator<< (gum::SetInst &inst, const gum::DiscreteVariable &i)
	Adds a variable to inst. More...

gum::SetInst &	operator>> (gum::SetInst &inst, const gum::DiscreteVariable &i)
	Removes a variable to inst. More...

template<typename GUM_SCALAR >
void	registerCompleteProjection (const std::string &projection_name, const std::string &type_multidim, typename CompleteProjectionRegister4MultiDim< GUM_SCALAR >::CompleteProjectionPtr function)
	A function to more easily register new projection functions in MultiDims. More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectMax (const MultiDimImplementation< GUM_SCALAR > &table, Instantiation *instantiation=0)
	the function to be used to project a MultiDimImplementation using a Max More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectMin (const MultiDimImplementation< GUM_SCALAR > &table, Instantiation *instantiation=0)
	the function to be used to project a MultiDimImplementation using a Min More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectSum (const MultiDimImplementation< GUM_SCALAR > &table, Instantiation *instantiation=0)
	the function to be used to project a MultiDimImplementation using a sum More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectProduct (const MultiDimImplementation< GUM_SCALAR > &table, Instantiation *instantiation=0)
	the function to be used to project a MultiDimImplementation using a Product More...

template<typename GUM_SCALAR >
void	completeProjections4MultiDimInit ()
	the function used to register all the complete projection operators on multidimImplementations over non-pointers types. More...

template<typename GUM_SCALAR >
void	pointerCompleteProjections4MultiDimInit ()
	The function used to register all the complete projections on multidimImplementations over pointers types. More...

template<typename GUM_SCALAR >
void	registerOperator (const std::string &operation_name, const std::string &type1, const std::string &type2, typename OperatorRegister4MultiDim< GUM_SCALAR >::OperatorPtr function)
	A function to more easily register new operators in MultiDims. More...

template<typename GUM_SCALAR >
void	operators4MultiDimInit ()
	the function used to register all the operators on multidimImplementations over non-pointers types. More...

template<typename GUM_SCALAR >
void	pointerOperators4MultiDimInit ()
	the function used to register all the operators on multidimImplementations over pointers types. More...

template<typename GUM_SCALAR >
void	registerProjection (const std::string &projection_name, const std::string &type_multidim, typename ProjectionRegister4MultiDim< GUM_SCALAR >::ProjectionPtr function)
	A function to more easily register new projection functions in MultiDims. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectMax (const MultiDimImplementation< GUM_SCALAR > &table, const Set< const DiscreteVariable * > &del_vars)
	The function to be used to project a MultiDimImplementation using a Max. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectMin (const MultiDimImplementation< GUM_SCALAR > &table, const Set< const DiscreteVariable * > &del_vars)
	The function to be used to project a MultiDimImplementation using a Min. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectSum (const MultiDimImplementation< GUM_SCALAR > &table, const Set< const DiscreteVariable * > &del_vars)
	The function to be used to project a MultiDimImplementation using a Sum. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectProduct (const MultiDimImplementation< GUM_SCALAR > &table, const Set< const DiscreteVariable * > &del_vars)
	The function to be used to project a MultiDimImplementation using a Product. More...

template<typename GUM_SCALAR >
void	projections4MultiDimInit ()
	the function used to register all the projection operators on multidimImplementations over non-pointers types. More...

template<typename GUM_SCALAR >
void	pointerProjections4MultiDimInit ()
	the function used to register all the projections on multidimImplementations over pointers types. More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	partialInstantiationMultiDimArray (const MultiDimArray< GUM_SCALAR > table, const HashTable< const DiscreteVariable , Idx > &inst_vars)
	A specialized function for instantiating variables in a multiDimArray. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	partialInstantiationMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, const HashTable< const DiscreteVariable , Idx > &inst_vars)
	A specialized function for instantiating variables in a MultiDimImplementation. More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR >	partialInstantiationMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, const HashTable< const DiscreteVariable , Idx > &inst_vars)
	A specialized function for instantiating variables in a MultiDimArray. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR >	partialInstantiationMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, const HashTable< const DiscreteVariable , Idx > &inst_vars)
	A specialized function for instantiating variables in a MultiDimArray. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	partialInstantiation (const MultiDimImplementation< GUM_SCALAR > &table, const HashTable< const DiscreteVariable *, Idx > &inst_vars)
	Instantiate variables in a MultiDimImplementation. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	partialInstantiation (const MultiDimDecorator< GUM_SCALAR > &table, const HashTable< const DiscreteVariable *, Idx > &inst_vars)
	Instantiate variables in a MultiDimDecorator. More...

template<typename GUM_SCALAR >
void	partialInstantiation4MultiDimInit ()
	The function used to register all the instantiation operators on multidimImplementations over non-pointers types. More...

template<typename GUM_SCALAR >
void	pointerPartialInstantiation4MultiDimInit ()
	The function used to register all the instantiations on multidimImplementations over pointers types. More...

template<typename GUM_SCALAR >
void	registerPartialInstantiation (const std::string &instantiation_func_name, const std::string &type_multidim, typename PartialInstantiationRegister4MultiDim< GUM_SCALAR >::PartialInstantiationPtr function)
	A function to more easily register new instantiation functions in MultiDims. More...

template<typename T_VAL >
std::ostream &	operator<< (std::ostream &, const ContinuousVariable< T_VAL > &)
	for friendly displaying the content of the variable More...

std::ostream &	operator<< (std::ostream &, const DiscreteVariable &)
	for friendly displaying the content of the variable More...

std::ostream &	operator<< (std::ostream &s, const Variable &LDRV)
	for friendly displaying the content of the variable More...


unsigned int	randomGeneratorSeed ()
	Returns the aGrUM's seed used by the std::generators. More...

std::default_random_engine	getRandomGenerator (unsigned int seed=0)
	define a random_engine with correct seed More...

Idx	randomValue (const Size max=2)
	Returns a random Idx between 0 and max-1 included. More...

double	randomProba ()
	Returns a random double between 0 and 1 included (i.e. More...

template<typename GUM_SCALAR >
std::vector< GUM_SCALAR >	randomDistribution (Size n)
	Return a random discrete distribution. More...

void	initRandom (unsigned int seed=0)
	Initialize random generator seed. More...


std::string	getUniqueFileName ()
	Returns a path to a unique file name. More...

bool	endsWith (std::string const &value, std::string const &ending)
	Returns true if value ends with ending. More...

std::vector< std::string >	split (const std::string &orig, const std::string &delimiter)
	Split str using the delimiter. More...

std::string	replace (const std::string &s, const std::string &val, const std::string &new_val)
	not usable for gcc 4.8 std::vector<std::string> split( const std::string& orig, const std::string& delimiter ) { More...

std::string	toLower (std::string str)
	Returns the lowercase version of str. More...

Integers Pow utility methods
unsigned long	intPow (unsigned long base, unsigned long exponent)
	Specialized pow function with integers (faster implementation). More...

unsigned long	int2Pow (unsigned long exponent)
	Specialized base 2 pow function with integer. More...

void	superiorPow (unsigned long card, unsigned long &num_bits, unsigned long &new_card)
	Compute the superior and closest power of two of an integer. More...

Project Max Operators
template<typename GUM_SCALAR >
GUM_SCALAR	projectMaxMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator. More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectMaxMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator. More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectMaxMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator. More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectMaxMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Max operator. More...

Project Min Operators
template<typename GUM_SCALAR >
GUM_SCALAR	projectMinMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator. More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectMinMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator. More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectMinMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator. More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectMinMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	A specialized function for projecting a multiDimArray using a Min operator. More...

Project Sum Operators
template<typename GUM_SCALAR >
GUM_SCALAR	projectSumMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectSumMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectSumMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectSumMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	a specialized function for projecting a multiDimArray using a Sum operatorThe function projects a table over all its variables and, thus, returns the sum of the values stored in the table More...

Project Multiply Operators
template<typename GUM_SCALAR >
GUM_SCALAR	projectProductMultiDimArray (const MultiDimArray< GUM_SCALAR > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

template<typename GUM_SCALAR >
GUM_SCALAR	projectProductMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectProductMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

template<typename GUM_SCALAR >
GUM_SCALAR *	projectProductMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, Instantiation instantiation=0)
	a function for projecting a multiDimArray using a Product operatorThe function projects a table over all its variables and, thus, returns the product of the values stored in the table More...

Add MultiDims
template<typename T >
MultiDimArray< T > *	add2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	add2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimArray< T >	add2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T >	add2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimFunctionGraph< T > *	add2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	add2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function add2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] + t2[D,B,E] for all A,B,C,D,E. More...

Substract MultiDims
template<typename T >
MultiDimArray< T > *	subtract2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	subtract2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimArray< T >	subtract2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T >	subtract2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimFunctionGraph< T > *	subtract2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	subtract2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtraction of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function subtract2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] - t2[D,B,E] for all A,B,C,D,E. More...

Multiply MultiDims
template<typename T >
MultiDimArray< T > *	multiply2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	multiply2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimArray< T >	multiply2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T >	multiply2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimFunctionGraph< T > *	multiply2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	multiply2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of t2 from t1, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function multiply2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] * t2[D,B,E] for all A,B,C,D,E. More...

Divide MultiDims
template<typename T >
MultiDimArray< T > *	divide2MultiDimArrays (const MultiDimArray< T > t1, const MultiDimArray< T > t2)
	a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	divide2MultiDimArrays (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimArray< T >	divide2MultiDimArrays4Pointers (const MultiDimArray< T * > t1, const MultiDimArray< T > *t2)
	a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T >	divide2MultiDimArrays4Pointers (const MultiDimImplementation< T * > t1, const MultiDimImplementation< T > *t2)
	a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimFunctionGraph< T > *	divide2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	divide2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t1 by t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function divide2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = t1[A,B,C,D] / t2[D,B,E] for all A,B,C,D,E. More...

Maximise MultiDims
template<typename T >
MultiDimFunctionGraph< T > *	maximise2MultiDimFunctionGraphs (const MultiDimFunctionGraph< T > t1, const MultiDimFunctionGraph< T > t2)
	a specialized function for compare value from two multiDimFunctionGraphs and gets the maximalThe function produces a tensorial comparison between t1 and t2, that is, if t1 and t2 are multiDimFunctionGraphs over variables A,B,C,D and D,B,E respectively, function maximise2MultiDimFunctionGraphs will return a multiDimFunctionGraph T defined as T[A,B,C,D,E] = max( t1[A,B,C,D], t2[D,B,E] ) for all A,B,C,D,E. More...

template<typename T >
MultiDimImplementation< T > *	maximise2MultiDimFunctionGraphs (const MultiDimImplementation< T > t1, const MultiDimImplementation< T > t2)
	a specialized function for compare value from two multiDimFunctionGraphs and gets the maximalThe function produces a tensorial comparison between t1 and t2, that is, if t1 and t2 are multiDimFunctionGraphs over variables A,B,C,D and D,B,E respectively, function maximise2MultiDimFunctionGraphs will return a multiDimFunctionGraph T defined as T[A,B,C,D,E] = max( t1[A,B,C,D], t2[D,B,E] ) for all A,B,C,D,E. More...

Operators over MultiDim
template<typename T >
MultiDimImplementation< T > *	operator+ (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to add two MultiDimImplementations. More...

template<typename T >
MultiDimImplementation< T > *	operator- (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to subtract two MultiDimImplementations. More...

template<typename T >
MultiDimImplementation< T > *	operator* (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to multiply two MultiDimImplementations. More...

template<typename T >
MultiDimImplementation< T > *	operator/ (const MultiDimImplementation< T > &, const MultiDimImplementation< T > &)
	The function to be used to divide two MultiDimImplementations. More...

Project Max for MultiDim
template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	projectMaxMultiDimArray (const MultiDimArray< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectMaxMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR >	projectMaxMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR >	projectMaxMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Max operatorThe function projects a table over the subset of its variables NOT IN the set of variables del_vars. More...

Project Min for MultiDim
template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	projectMinMultiDimArray (const MultiDimArray< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Min operator More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectMinMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Min operator More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR >	projectMinMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Min operator More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR >	projectMinMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a Min operator More...

Project Sum for MultiDim
template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	projectSumMultiDimArray (const MultiDimArray< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a summation More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectSumMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a summation More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR >	projectSumMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a summation More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR >	projectSumMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using a summation More...

Project Product for MultiDim
template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	projectProductMultiDimArray (const MultiDimArray< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using products More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectProductMultiDimArray (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using products More...

template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR >	projectProductMultiDimArray4Pointers (const MultiDimArray< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using products More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR >	projectProductMultiDimArray4Pointers (const MultiDimImplementation< GUM_SCALAR * > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimArray using products More...

Project Function for MultiDim
template<typename GUM_SCALAR >
MultiDimArray< GUM_SCALAR > *	ProjectFuncMultiDimArray (const MultiDimArray< GUM_SCALAR > t1, const MultiDimArray< GUM_SCALAR > t2, const GUM_SCALAR(*f)(const GUM_SCALAR &, const GUM_SCALAR &))
	a specialized function for functionally projecting a multiDimArray More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	combine2MultiDimArrays (const MultiDimImplementation< GUM_SCALAR > t1, const MultiDimImplementation< GUM_SCALAR > t2, const GUM_SCALAR(*f)(const GUM_SCALAR &, const GUM_SCALAR &))
	a specialized function for functionally projecting a multiDimArray More...

Projectors For Function Graphs
template<typename GUM_SCALAR >
MultiDimFunctionGraph< GUM_SCALAR > *	projectMaxMultiDimFunctionGraph (const MultiDimFunctionGraph< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using a Max operator More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectMaxMultiDimFunctionGraph (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using a Max operator More...

template<typename GUM_SCALAR >
MultiDimFunctionGraph< GUM_SCALAR > *	projectMinMultiDimFunctionGraph (const MultiDimFunctionGraph< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using a Min operator More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectMinMultiDimFunctionGraph (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using a Min operator More...

template<typename GUM_SCALAR >
MultiDimFunctionGraph< GUM_SCALAR > *	projectSumMultiDimFunctionGraph (const MultiDimFunctionGraph< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using a summation More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectSumMultiDimFunctionGraph (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using a summation More...

template<typename GUM_SCALAR >
MultiDimFunctionGraph< GUM_SCALAR > *	projectProductMultiDimFunctionGraph (const MultiDimFunctionGraph< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using products More...

template<typename GUM_SCALAR >
MultiDimImplementation< GUM_SCALAR > *	projectProductMultiDimFunctionGraph (const MultiDimImplementation< GUM_SCALAR > table, const Set< const DiscreteVariable > &del_vars)
	a specialized function for projecting a multiDimFunctionGraph using products More...

Variables
const double	VariableLog2ParamComplexityCTable [4][1000]

constexpr std::size_t	VariableLog2ParamComplexityCTableRSize {std::size_t(4)}

constexpr std::size_t	VariableLog2ParamComplexityCTableNSize {std::size_t(1000)}

template<typename T1 , typename T2 >
using	forbidden_type = typename std::enable_if< !std::is_same< T1, T2 >::value, int >::type
	Forbidden_type<T1,T2> return the "int" type if T1 and T2 are of the same type, else nothing. More...

bool	Memcmp (const void const in_, const void const out_, unsigned long size)
	Cross-platform replacement for memcmp. More...

void	_atexit_ ()
	Used for debug purpose. More...

Detailed Description

the function to be used to partially instantiate a MultiDimDecorator

c++11 stuff, like declval ( decltype from prototype without a default constructor )

include the inlined functions if necessary

This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see http://www.gnu.org/licenses/.

This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see http://www.gnu.org/licenses/.gum is the global namespace for all aGrUM entities

Todo:: virtual for all functions that MAY be one day redefined in any derived class

This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library. If not, see http://www.gnu.org/licenses/. class for LOGIT implementation as multiDim

Author: Pierre-Henri WUILLEMIN() & Christophe GONZALES()

Typedef Documentation

◆ FactorTable

template<typename GUM_SCALAR >

using gum::FactorTable = typedef HashTable< NodeSet, const Potential< GUM_SCALAR >* >

Definition at line 43 of file IMarkovNet.h.

◆ HybridGibbsSampling

template<typename GUM_SCALAR >

using gum::HybridGibbsSampling = typedef LoopySamplingInference< GUM_SCALAR, GibbsSampling >

Definition at line 229 of file loopySamplingInference.h.

◆ HybridImportanceSampling

template<typename GUM_SCALAR >

using gum::HybridImportanceSampling = typedef LoopySamplingInference< GUM_SCALAR, ImportanceSampling >

Definition at line 227 of file loopySamplingInference.h.

◆ HybridMonteCarloSampling

template<typename GUM_SCALAR >

using gum::HybridMonteCarloSampling = typedef LoopySamplingInference< GUM_SCALAR, MonteCarloSampling >

Definition at line 223 of file loopySamplingInference.h.

◆ HybridWeightedSampling

template<typename GUM_SCALAR >

using gum::HybridWeightedSampling = typedef LoopySamplingInference< GUM_SCALAR, WeightedSampling >

Definition at line 225 of file loopySamplingInference.h.

◆ JoinTree

typedef CliqueGraph gum::JoinTree

a join tree is a clique graph satisfying the running intersection property (but some cliques may be included into others)

Definition at line 304 of file cliqueGraph.h.

◆ JunctionTree

typedef CliqueGraph gum::JunctionTree

a junction tree is a clique graph satisfying the running intersection property and such that no clique is included into another one.

Definition at line 300 of file cliqueGraph.h.

◆ pair_iterator

typedef HashTableConstIteratorSafe< LeafPair*, std::vector< Size > > gum::pair_iterator

Definition at line 52 of file fusionContext.h.

Enumeration Type Documentation

◆ BinTreeDir

enum gum::BinTreeDir : char

strong

The direction of a given edge in a binary tree.

Enumerator
LEFT_CHILD
RIGHT_CHILD
NO_PARENT

Definition at line 36 of file binTreeNode.h.

                         : char
   {
     LEFT_CHILD  = 0,
     RIGHT_CHILD = 1,
     NO_PARENT   = 2
   };

◆ Complexity

enum gum::Complexity : char

strong

Complexity allows to characterize the awaited difficulty for an algorithm given a specific instance Therefore this is not a theoretical characterization but rather a pragmatic rate of that very instance.

Enumerator
Heavy
Difficult
Correct

Definition at line 45 of file BNdistance.h.

                         : char
   {
     Heavy,
     Difficult,
     Correct
   };

◆ FactorySimulationAction

enum gum::FactorySimulationAction : Idx

Enumerator
GoNorth
GoEast
GoSouth
GoWest
PickUp
PutDown
FillUp

Definition at line 68 of file factorySimulator.h.

                                : Idx
   {
     GoNorth = 0,
     GoEast  = 1,
     GoSouth = 2,
     GoWest  = 3,
     PickUp  = 4,
     PutDown = 5,
     FillUp  = 6
   };

◆ FactorySimulationLandmark

enum gum::FactorySimulationLandmark : Idx

Enumerator
HOME
WORK
THEATER
CLUB
Factory

Definition at line 44 of file factorySimulator.h.

                                  : Idx
   {
     HOME    = 0,
     WORK    = 1,
     THEATER = 2,
     CLUB    = 3,
     Factory = 4
   };

◆ FactorySimulationLandmarkX

enum gum::FactorySimulationLandmarkX : Idx

Enumerator
HOMEX
WORKX
THEATERX
CLUBX
STATIONX

Definition at line 52 of file factorySimulator.h.

                                   : Idx
   {
     HOMEX    = 0,
     WORKX    = 0,
     THEATERX = 3,
     CLUBX    = 4,
     STATIONX = 2
   };

◆ FactorySimulationLandmarkY

enum gum::FactorySimulationLandmarkY : Idx

Enumerator
HOMEY
WORKY
THEATERY
CLUBY
STATIONY

Definition at line 60 of file factorySimulator.h.

                                   : Idx
   {
     HOMEY    = 0,
     WORKY    = 4,
     THEATERY = 0,
     CLUBY    = 4,
     STATIONY = 1
   };

◆ FindBarrenNodesType

enum gum::FindBarrenNodesType

strong

type of algorithm to determine barren nodes

When constructing messages from one clique to its neighbor, we can determine that some nodes are barren, i.e., they are the only one at the left hand side of a conditioning bar and they appear in only one potential. In such case, in a classical BN inference, there is no need to take them into account since their removal will necessarily create a constant potential. So, we can discard their potential from the computation. However, when computing p(evidence), we should not do that because the constant is important and need be computed.

Enumerator
FIND_NO_BARREN_NODES
FIND_BARREN_NODES

Definition at line 53 of file BayesNetInference.h.

   {
     FIND_NO_BARREN_NODES,   // do not try to find barren nodes
     FIND_BARREN_NODES       // use a bottom-up algorithm to detect barren nodes
   };

◆ FMDPfactory_state

enum gum::FMDPfactory_state : char

strong

The enumeration of states in which the factory can be in.

Every documentation section's name indicates from which state you can call it's methods, and in which state it places the factory.

There is an exception for the delegated CPT definition methods which do not changes the state of the factory.

Enumerator
NONE
VARIABLE
ACTION
TRANSITION
COST
REWARD
DISCOUNT

Definition at line 53 of file IfmdpFactory.h.

                                : char
   {
     NONE,
     VARIABLE,
     ACTION,
     TRANSITION,
     COST,
     REWARD,
     DISCOUNT
   };

◆ LEARNERNAME

enum gum::LEARNERNAME

Enumerator
IMDDILEARNER
ITILEARNER

Definition at line 69 of file templateStrategy.h.

   {
     IMDDILEARNER = 1,
     ITILEARNER   = 2
   };

◆ RelevantPotentialsFinderType

enum gum::RelevantPotentialsFinderType

strong

type of algorithm for determining the relevant potentials for combinations using some d-separation analysis

When constructing messages from one clique to its neighbor, we can exploit d-separation to determine that some potentials are irrelevant for the message computation. So we can discard them and, thereby, speed-up the computations.

Enumerator
FIND_ALL
DSEP_BAYESBALL_NODES
DSEP_BAYESBALL_POTENTIALS
DSEP_KOLLER_FRIEDMAN_2009

Definition at line 43 of file relevantPotentialsFinderType.h.

   {
     FIND_ALL,                    // do not perform d-separation analysis
     DSEP_BAYESBALL_NODES,        // BayesBall requisite nodes -> potentials
     DSEP_BAYESBALL_POTENTIALS,   // BayesBall requisite potentials (directly)
     DSEP_KOLLER_FRIEDMAN_2009    // Koller & Friedman 2009 requisite potentials
   };

◆ TaxiSimulationAction

enum gum::TaxiSimulationAction : Idx

Enumerator
GoNorth
GoEast
GoSouth
GoWest
PickUp
PutDown
FillUp

Definition at line 68 of file taxiSimulator.h.

                             : Idx
   {
     GoNorth = 1,
     GoEast  = 2,
     GoSouth = 3,
     GoWest  = 4,
     PickUp  = 5,
     PutDown = 6,
     FillUp  = 7
   };

◆ TaxiSimulationLandmark

enum gum::TaxiSimulationLandmark : Idx

Enumerator
HOME
WORK
THEATER
CLUB
TAXI

Definition at line 44 of file taxiSimulator.h.

                               : Idx
   {
     HOME    = 0,
     WORK    = 1,
     THEATER = 2,
     CLUB    = 3,
     TAXI    = 4
   };

◆ TaxiSimulationLandmarkX

enum gum::TaxiSimulationLandmarkX : Idx

Enumerator
HOMEX
WORKX
THEATERX
CLUBX
STATIONX

Definition at line 52 of file taxiSimulator.h.

                                : Idx
   {
     HOMEX    = 0,
     WORKX    = 0,
     THEATERX = 3,
     CLUBX    = 4,
     STATIONX = 2
   };

◆ TaxiSimulationLandmarkY

enum gum::TaxiSimulationLandmarkY : Idx

Enumerator
HOMEY
WORKY
THEATERY
CLUBY
STATIONY

Definition at line 60 of file taxiSimulator.h.

                                : Idx
   {
     HOMEY    = 0,
     WORKY    = 4,
     THEATERY = 0,
     CLUBY    = 4,
     STATIONY = 1
   };

◆ TESTNAME

enum gum::TESTNAME

Enumerator
GTEST
CHI2TEST
LEASTSQUARETEST

Definition at line 41 of file templateStrategy.h.

   {
     GTEST           = 1,
     CHI2TEST        = 2,
     LEASTSQUARETEST = 3
   };

◆ VarType

enum gum::VarType : char

strong

Enumerator
Discretized
Labelized
Range
Continuous

Definition at line 40 of file variable.h.

                      : char
   {
     Discretized,
     Labelized,
     Range,
     Continuous
   };

Function Documentation

◆ _initPotentialOperators__()

template<typename GUM_SCALAR >

void gum::_initPotentialOperators__ ( )

Definition at line 40 of file multiDimDecorator_tpl.h.

                                    {
     static bool first = true;
 
     if (first) {
       first = false;
 
       // register the operators that will be used by the decorator
       Operators4MultiDimInitialize< GUM_SCALAR > op;
       op.init();
 
       // register the projectors that will be used by the decorator
       Projections4MultiDimInitialize< GUM_SCALAR > proj;
       proj.init();
 
       // register the projectors that will be used by the decorator
       CompleteProjections4MultiDimInitialize< GUM_SCALAR > comp_proj;
       comp_proj.init();
 
       // register the partial instantiators that will be used by the decorator
       PartialInstantiation4MultiDimInitialize< GUM_SCALAR > inst;
       inst.init();
     }
   }

◆ abs()

template<typename GUM_SCALAR >

Potential< GUM_SCALAR > gum::abs ( const Potential< GUM_SCALAR > & arg )

inline

Definition at line 595 of file potential.h.

                                                                          {
     return arg.new_abs();
   }

◆ build_node()

template<typename GUM_SCALAR >

NodeId gum::build_node	(	gum::BayesNet< GUM_SCALAR > &	bn,
		std::string	node,
		gum::Size	default_domain_size
	)

Definition at line 61 of file BayesNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                             {
     std::string                name      = node;
     auto                       ds        = default_domain_size;
     long                       range_min = 0;
     long                       range_max = long(ds) - 1;
     std::vector< std::string > labels;
     std::vector< GUM_SCALAR >  ticks;
 
     if (*(node.rbegin()) == ']') {
       auto posBrack = node.find('[');
       if (posBrack != std::string::npos) {
         name               = node.substr(0, posBrack);
         const auto& s_args = node.substr(posBrack + 1, node.size() - posBrack - 2);
         const auto& args   = split(s_args, ",");
         if (args.size() == 0) {   // n[]
           GUM_ERROR(InvalidArgument, "Empty range for variable " << node)
         } else if (args.size() == 1) {   // n[4]
           ds        = static_cast< Size >(std::stoi(args[0]));
           range_min = 0;
           range_max = long(ds) - 1;
         } else if (args.size() == 2) {   // n[5,10]
           range_min = std::stol(args[0]);
           range_max = std::stol(args[1]);
           if (1 + range_max - range_min < 2) {
             GUM_ERROR(InvalidArgument, "Invalid range for variable " << node)
           }
           ds = static_cast< Size >(1 + range_max - range_min);
         } else {   // n[3.14,5,10,12]
           for (const auto& tick: args) {
             ticks.push_back(static_cast< GUM_SCALAR >(std::atof(tick.c_str())));
           }
           ds = static_cast< Size >(args.size() - 1);
         }
       }
     } else if (*(node.rbegin()) == '}') {   // node like "n{one|two|three}"
       auto posBrack = node.find('{');
       if (posBrack != std::string::npos) {
         name   = node.substr(0, posBrack);
         labels = split(node.substr(posBrack + 1, node.size() - posBrack - 2), "|");
         if (labels.size() < 2) { GUM_ERROR(InvalidArgument, "Not enough labels in node " << node) }
         if (!hasUniqueElts(labels)) {
           GUM_ERROR(InvalidArgument, "Duplicate labels in node " << node)
         }
         ds = static_cast< Size >(labels.size());
       }
     }
 
     if (ds == 0) {
       GUM_ERROR(InvalidArgument, "No value for variable " << name << ".")
     } else if (ds == 1) {
       GUM_ERROR(InvalidArgument,
                 "Only one value for variable " << name << " (2 at least are needed).")
     }
 
     // now we add the node in the BN
     NodeId idVar;
     try {
       idVar = bn.idFromName(name);
     } catch (gum::NotFound&) {
       if (!labels.empty()) {
         idVar = bn.add(LabelizedVariable(name, name, labels));
       } else if (!ticks.empty()) {
         idVar = bn.add(DiscretizedVariable< GUM_SCALAR >(name, name, ticks));
       } else {
         idVar = bn.add(RangeVariable(name, name, range_min, range_max));
       }
     }
 
     return idVar;
   }

Here is the call graph for this function:

◆ build_node_for_ID()

template<typename GUM_SCALAR >

NodeId gum::build_node_for_ID	(	gum::InfluenceDiagram< GUM_SCALAR > &	infdiag,
		std::string	node,
		gum::Size	default_domain_size
	)

Definition at line 41 of file influenceDiagram_tpl.h.

                                                                                    {
     auto                       ds        = default_domain_size;
     long                       range_min = 0;
     long                       range_max = long(ds) - 1;
     std::vector< std::string > labels;
     std::vector< GUM_SCALAR >  ticks;
     bool                       isUtil, isDeci, isChanc;
     isUtil  = false;
     isDeci  = false;
     isChanc = false;
 
     switch (*(node.begin())) {
       case '*':
         isDeci = true;
         node.erase(0, 1);
         break;
       case '$':
         isUtil = true;
         node.erase(0, 1);
         break;
       default:
         isChanc = true;
     }
 
     std::string name = node;
     if (*(node.rbegin()) == ']') {
       auto posBrack = node.find('[');
       if (posBrack != std::string::npos) {
         name               = node.substr(0, posBrack);
         const auto& s_args = node.substr(posBrack + 1, node.size() - posBrack - 2);
         const auto& args   = split(s_args, ",");
         if (args.empty()) {   // n[]
           GUM_ERROR(InvalidArgument, "Empty range for variable " << node)
         } else if (args.size() == 1) {   // n[4]
           ds        = static_cast< Size >(std::stoi(args[0]));
           range_min = 0;
           range_max = long(ds) - 1;
         } else if (args.size() == 2) {   // n[5,10]
           range_min = std::stol(args[0]);
           range_max = std::stol(args[1]);
           if (1 + range_max - range_min < 2) {
             GUM_ERROR(InvalidArgument, "Invalid range for variable " << node)
           }
           ds = static_cast< Size >(1 + range_max - range_min);
         } else {   // n[3.14,5,10,12]
           for (const auto& tick: args) {
             ticks.push_back(static_cast< GUM_SCALAR >(std::strtod(tick.c_str(), nullptr)));
           }
           ds = static_cast< Size >(args.size() - 1);
         }
       }
     } else if (*(node.rbegin()) == '}') {   // node like "n{one|two|three}"
       auto posBrack = node.find('{');
       if (posBrack != std::string::npos) {
         name   = node.substr(0, posBrack);
         labels = split(node.substr(posBrack + 1, node.size() - posBrack - 2), "|");
         if (labels.size() < 2) { GUM_ERROR(InvalidArgument, "Not enough labels in node " << node) }
         if (!hasUniqueElts(labels)) {
           GUM_ERROR(InvalidArgument, "Duplicate labels in node " << node)
         }
         ds = static_cast< Size >(labels.size());
       }
     }
 
     if (ds == 0) {
       GUM_ERROR(InvalidArgument, "No value for variable " << name << ".")
     } else if (ds == 1) {
       GUM_ERROR(InvalidArgument,
                 "Only one value for variable " << name << " (2 at least are needed).")
     }
 
     // now we add the node in the BN
     NodeId idVar;
     try {
       idVar = infdiag.idFromName(name);
     } catch (gum::NotFound&) {
       if (isChanc) {
         if (!labels.empty()) {
           idVar = infdiag.addChanceNode(LabelizedVariable(name, name, labels));
         } else if (!ticks.empty()) {
           idVar = infdiag.addChanceNode(DiscretizedVariable< GUM_SCALAR >(name, name, ticks));
         } else {
           idVar = infdiag.addChanceNode(RangeVariable(name, name, range_min, range_max));
         }
       } else if (isDeci) {
         if (!labels.empty()) {
           idVar = infdiag.addDecisionNode(LabelizedVariable(name, name, labels));
         } else if (!ticks.empty()) {
           idVar = infdiag.addDecisionNode(DiscretizedVariable< GUM_SCALAR >(name, name, ticks));
         } else {
           idVar = infdiag.addDecisionNode(RangeVariable(name, name, range_min, range_max));
         }
       } else if (isUtil) {
         idVar = infdiag.addUtilityNode(LabelizedVariable(name, name, 1));
       } else {
         GUM_ERROR(FatalError,
                   "No type (chance, decision or utility) for the node '" << node << "'.")
       }
     }
 
     return idVar;
   }

◆ build_node_for_MN()

template<typename GUM_SCALAR >

NodeId gum::build_node_for_MN	(	MarkovNet< GUM_SCALAR > &	mn,
		std::string	node,
		Size	default_domain_size
	)

Definition at line 60 of file MarkovNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                               {
     std::string                name      = node;
     auto                       ds        = default_domain_size;
     long                       range_min = 0;
     long                       range_max = long(ds) - 1;
     std::vector< std::string > labels;
     std::vector< GUM_SCALAR >  ticks;
 
     if (*(node.rbegin()) == ']') {
       auto posBrack = node.find('[');
       if (posBrack != std::string::npos) {
         name               = node.substr(0, posBrack);
         const auto& s_args = node.substr(posBrack + 1, node.size() - posBrack - 2);
         const auto& args   = split(s_args, ",");
         if (args.size() == 0) {   // n[]
           GUM_ERROR(InvalidArgument, "Empty range for variable " << node)
         } else if (args.size() == 1) {   // n[4]
           ds        = static_cast< Size >(std::stoi(args[0]));
           range_min = 0;
           range_max = long(ds) - 1;
         } else if (args.size() == 2) {   // n[5,10]
           range_min = std::stol(args[0]);
           range_max = std::stol(args[1]);
           if (1 + range_max - range_min < 2) {
             GUM_ERROR(InvalidArgument, "Invalid range for variable " << node)
           }
           ds = static_cast< Size >(1 + range_max - range_min);
         } else {   // n[3.14,5,10,12]
           for (const auto& tick: args) {
             ticks.push_back(static_cast< GUM_SCALAR >(std::atof(tick.c_str())));
           }
           ds = static_cast< Size >(args.size() - 1);
         }
       }
     } else if (*(node.rbegin()) == '}') {   // node like "n{one|two|three}"
       auto posBrack = node.find('{');
       if (posBrack != std::string::npos) {
         name   = node.substr(0, posBrack);
         labels = split(node.substr(posBrack + 1, node.size() - posBrack - 2), "|");
         if (labels.size() < 2) { GUM_ERROR(InvalidArgument, "Not enough labels in node " << node) }
         if (!hasUniqueElts(labels)) {
           GUM_ERROR(InvalidArgument, "Duplicate labels in node " << node)
         }
         ds = static_cast< Size >(labels.size());
       }
     }
 
     if (ds == 0) {
       GUM_ERROR(InvalidArgument, "No value for variable " << name << ".")
     } else if (ds == 1) {
       GUM_ERROR(InvalidArgument,
                 "Only one value for variable " << name << " (2 at least are needed).");
     }
 
     // now we add the node in the BN
     NodeId idVar;
     try {
       idVar = mn.idFromName(name);
     } catch (NotFound&) {
       if (!labels.empty()) {
         idVar = mn.add(LabelizedVariable(name, name, labels));
       } else if (!ticks.empty()) {
         idVar = mn.add(DiscretizedVariable< GUM_SCALAR >(name, name, ticks));
       } else {
         idVar = mn.add(RangeVariable(name, name, range_min, range_max));
       }
     }
 
     return idVar;
   }

Here is the call graph for this function:

◆ combine2MultiDimArrays()

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::combine2MultiDimArrays	(	const MultiDimImplementation< GUM_SCALAR > *	t1,
		const MultiDimImplementation< GUM_SCALAR > *	t2,
		const GUM_SCALAR(*)(const GUM_SCALAR &, const GUM_SCALAR &)	f
	)

a specialized function for functionally projecting a multiDimArray

The function produces a tensorial functional combination of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function combine2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = f ( t1[A,B,C,D],t2[D,B,E] ) for all A,B,C,D,E.

Returns: function combine2MultiDimArrays allocates on the heap the new T multiDimArray and returns it.

◆ func2str()

std::string gum::func2str ( FormulaPart::token_function func )

Definition at line 59 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                      {
     switch (func) {
       case FormulaPart::token_function::exp: {
         return "exp";
       }
       case FormulaPart::token_function::log: {
         return "log";
       }
       case FormulaPart::token_function::ln: {
         return "ln";
       }
       case FormulaPart::token_function::pow: {
         return "pow";
       }
       case FormulaPart::token_function::sqrt: {
         return "sqrt";
       }
       case FormulaPart::token_function::nil: {
         return "nil";
       }
       default: {
         GUM_ERROR(OperationNotAllowed, "unknown function")
       }
     }
   }

Here is the call graph for this function:

◆ getMaxModality()

template<typename GUM_SCALAR >

gum::Size gum::getMaxModality ( gum::BayesNet< GUM_SCALAR > & bayesNet )

Definition at line 40 of file MCBayesNetGenerator_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                               {
     gum::Size maxMod = 0;
 
     for (auto node: bayesNet.nodes())
       if (maxMod < bayesNet.variable(node).domainSize())
         maxMod = bayesNet.variable(node).domainSize();
 
     return maxMod;
   }

Here is the call graph for this function:

◆ log2()

template<typename GUM_SCALAR >

Potential< GUM_SCALAR > gum::log2 ( const Potential< GUM_SCALAR > & arg )

inline

Definition at line 590 of file potential.h.

                                                                           {
     return arg.new_log2();
   }

◆ LPNewmultiPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::LPNewmultiPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Potential< GUM_SCALAR > &	t2
	)

static

Definition at line 47 of file lazyPropagation.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                 {
     return new Potential< GUM_SCALAR >(t1 * t2);
   }

Here is the call graph for this function:

◆ LPNewprojPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::LPNewprojPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Set< const DiscreteVariable * > &	del_vars
	)

static

Definition at line 55 of file lazyPropagation.h.

References gum::Set< Key, Alloc >::emplace().

                                                                         {
     return new Potential< GUM_SCALAR >(t1.margSumOut(del_vars));
   }

Here is the call graph for this function:

◆ operator*()

INLINE Formula gum::operator*	(	const Formula &	a,
		const Formula &	b
	)

Definition at line 464 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                         {
     return Formula(std::to_string(a.result() * b.result()));
   }

Here is the call graph for this function:

◆ operator+()

INLINE Formula gum::operator+	(	const Formula &	a,
		const Formula &	b
	)

Definition at line 454 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                         {
     return Formula(std::to_string(a.result() + b.result()));
   }

Here is the call graph for this function:

◆ operator-() [1/6]

template<typename Val >

INLINE ListConstIterator< Val >::difference_type gum::operator-	(	const ListConstIterator< Val > &	iter1,
		const ListConstIterator< Val > &	iter2
	)

For STL compliance, a distance operator.

Definition at line 335 of file list_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                              {
     typename ListConstIterator< Val >::difference_type res = 0;
 
     for (ListConstIterator< Val > iter3 = iter2; iter1 != iter3; ++iter3, ++res) {}
 
     return res;
   }

Here is the call graph for this function:

◆ operator-() [2/6]

INLINE Formula gum::operator- ( const Formula & a )

Definition at line 451 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

451 { return Formula(std::to_string(-1 * a.result())); }

gum::to_string

std::string to_string(const Formula &f)

Definition: formula_inl.h:474

Here is the call graph for this function:

◆ operator-() [3/6]

INLINE Formula gum::operator-	(	const Formula &	a,
		const Formula &	b
	)

Definition at line 459 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                         {
     return Formula(std::to_string(a.result() - b.result()));
   }

Here is the call graph for this function:

◆ operator-() [4/6]

template<typename Val >

INLINE ListConstIteratorSafe< Val >::difference_type gum::operator-	(	const ListConstIteratorSafe< Val > &	iter1,
		const ListConstIteratorSafe< Val > &	iter2
	)

For STL compliance, a distance operator.

Definition at line 926 of file list_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                           {
     typename ListConstIteratorSafe< Val >::difference_type res = 0;
     ListConstIteratorSafe< Val >                           iter3{iter2};
 
     for (; iter1 != iter3; ++iter3, ++res) {}
 
     return res;
   }

Here is the call graph for this function:

◆ operator-() [5/6]

template<typename Val >

ListConstIterator< Val >::difference_type gum::operator-	(	const ListConstIterator< Val > &	iter1,
		const ListConstIterator< Val > &	iter2
	)

For STL compliance, a distance operator.

Definition at line 335 of file list_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                              {
     typename ListConstIterator< Val >::difference_type res = 0;
 
     for (ListConstIterator< Val > iter3 = iter2; iter1 != iter3; ++iter3, ++res) {}
 
     return res;
   }

Here is the call graph for this function:

◆ operator-() [6/6]

template<typename Val >

ListConstIteratorSafe< Val >::difference_type gum::operator-	(	const ListConstIteratorSafe< Val > &	iter1,
		const ListConstIteratorSafe< Val > &	iter2
	)

For STL compliance, a distance operator.

Definition at line 926 of file list_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                           {
     typename ListConstIteratorSafe< Val >::difference_type res = 0;
     ListConstIteratorSafe< Val >                           iter3{iter2};
 
     for (; iter1 != iter3; ++iter3, ++res) {}
 
     return res;
   }

Here is the call graph for this function:

◆ operator/()

INLINE Formula gum::operator/	(	const Formula &	a,
		const Formula &	b
	)

Definition at line 469 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                         {
     return Formula(std::to_string(a.result() / b.result()));
   }

Here is the call graph for this function:

◆ operator<<() [1/53]

template<typename Element >

INLINE std::ostream& gum::operator<<	(	std::ostream &	out,
		const SplayBinaryNode< Element > &	e
	)

Display the node.

Friendly to display.

Definition at line 787 of file splay_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
     if (e.fg) out << *e.fg << ",";
 
     out << e.elt;
 
     if (e.fd) out << "," << *e.fd;
 
     return out;
   }

Here is the call graph for this function:

◆ operator<<() [2/53]

template<typename Val , typename Cmp , typename Alloc >

std::ostream& gum::operator<<	(	std::ostream &	,
		const Heap< Val, Cmp, Alloc > &
	)

Definition at line 335 of file heap_tpl.h.

                                                                                          {
     stream << heap.toString();
     return stream;
   }

◆ operator<<() [3/53]

template<typename Val , typename Priority , typename Cmp , typename Alloc >

std::ostream& gum::operator<<	(	std::ostream &	,
		const PriorityQueue< Val, Priority, Cmp, Alloc > &
	)

Definition at line 1178 of file priorityQueue_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
     stream << queue.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [4/53]

std::ostream& gum::operator<<	(	std::ostream &	s,
		const Variable &	LDRV
	)

for friendly displaying the content of the variable

◆ operator<<() [5/53]

template<typename Element >

INLINE std::ostream & gum::operator<<	(	std::ostream &	out,
		const SplayTree< Element > &	s
	)

Display the tree.

Friendly to display.

Definition at line 800 of file splay_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
     out << "|[";
 
     if (s.root) out << *s.root;
 
     out << "]|";
 
     return out;
   }

Here is the call graph for this function:

◆ operator<<() [6/53]

template<typename Val , typename Alloc >

std::ostream& gum::operator<<	(	std::ostream &	stream,
		const List< Val, Alloc > &	list
	)

an << operator for List

◆ operator<<() [7/53]

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const DiGraph &	g
	)

for friendly displaying the content of directed graphs

Definition at line 83 of file diGraph.cpp.

                                                                {
     stream << g.toString();
     return stream;
   }

◆ operator<<() [8/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimLogit< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 108 of file multiDimLogit_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [9/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimNoisyAND< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 115 of file multiDimNoisyAND_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                          {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [10/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimNoisyORNet< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 116 of file multiDimNoisyORNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [11/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimNoisyORCompound< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 120 of file multiDimNoisyORCompound_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [12/53]

template<typename GUM_SCALAR >

INLINE MultiDimImplementation< GUM_SCALAR >& gum::operator<<	(	MultiDimImplementation< GUM_SCALAR > &	array,
		const DiscreteVariable &	v
	)

Definition at line 124 of file multiDimImplementation_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                             {
     array.add(v);
     return array;
   }

Here is the call graph for this function:

◆ operator<<() [13/53]

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const NodeGraphPart &	set
	)

for friendly displaying the content of node set

Definition at line 126 of file nodeGraphPart.cpp.

                                                                        {
     stream << set.toString();
     return stream;
   }

◆ operator<<() [14/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimLogit< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 108 of file multiDimLogit_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [15/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimNoisyORNet< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 116 of file multiDimNoisyORNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [16/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimNoisyORCompound< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 120 of file multiDimNoisyORCompound_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [17/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	s,
		const MultiDimNoisyAND< GUM_SCALAR > &	ag
	)

For friendly displaying the content of the array.

Definition at line 115 of file multiDimNoisyAND_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                          {
     return s << ag.toString();
   }

Here is the call graph for this function:

◆ operator<<() [18/53]

std::ostream& gum::operator<<	(	std::ostream &	,
		const DiscreteVariable &
	)

for friendly displaying the content of the variable

◆ operator<<() [19/53]

std::ostream& gum::operator<<	(	std::ostream &	,
		const VariableNodeMap &
	)

for friendly displaying the content of clique graphs

◆ operator<<() [20/53]

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const UndiGraph &	g
	)

for friendly displaying the content of undirected graphs

Definition at line 175 of file undiGraph.cpp.

                                                                  {
     stream << g.toString();
     return stream;
   }

◆ operator<<() [21/53]

template<typename T_VAL >

std::ostream& gum::operator<<	(	std::ostream &	,
		const ContinuousVariable< T_VAL > &
	)

for friendly displaying the content of the variable

◆ operator<<() [22/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	out,
		const DecisionPotential< GUM_SCALAR > &	array
	)

Definition at line 187 of file decisionPotential.h.

                                                                                         {
     out << array.toString();
     return out;
   }

◆ operator<<() [23/53]

template<typename Key , typename Data >

std::ostream& gum::operator<<	(	std::ostream &	,
		const IndexedTree< Key, Data > &
	)

Necessary for the hashtable operator <<.

◆ operator<<() [24/53]

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const EdgeGraphPart &	set
	)

for friendly displaying the content of an edge set

Definition at line 225 of file edgeGraphPart.cpp.

                                                                        {
     stream << set.toString();
     return stream;
   }

◆ operator<<() [25/53]

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const MixedGraph &	g
	)

for friendly displaying the content of directed graphs

Definition at line 232 of file mixedGraph.cpp.

                                                                   {
     stream << g.toString();
     return stream;
   }

◆ operator<<() [26/53]

std::ostream & gum::operator<<	(	std::ostream &	aStream,
		const Instantiation &	i
	)

Print information of the instantiation in the stream.

Definition at line 247 of file instantiation.cpp.

                                                                       {
     aStream << i.toString();
     return aStream;
   }

◆ operator<<() [27/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	output,
		const IMarkovNet< GUM_SCALAR > &	mn
	)

Prints map's graph in output using the Graphviz-dot format.

Definition at line 294 of file IMarkovNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                         {
     output << bn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [28/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	output,
		const IBayesNet< GUM_SCALAR > &	bn
	)

Prints map's DAG in output using the Graphviz-dot format.

Definition at line 359 of file IBayesNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                        {
     output << bn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [29/53]

std::ostream & gum::operator<<	(	std::ostream &	s,
		const ArcGraphPart &	a
	)

for friendly displaying the content of arc set

Parameters

s	the stream to which we display the content of a
a	the ArcGraphPart to be displayed

Definition at line 292 of file arcGraphPart.cpp.

                                                                       {
     stream << set.toString();
     return stream;
   }

◆ operator<<() [30/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	output,
		const IMarkovNet< GUM_SCALAR > &	bn
	)

Prints map's graph in output using the Graphviz-dot format.

Definition at line 294 of file IMarkovNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                         {
     output << bn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [31/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	out,
		const MultiDimContainer< GUM_SCALAR > &	array
	)

Definition at line 302 of file multiDimContainer_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                         {
     out << array.toString();
     return out;
   }

Here is the call graph for this function:

◆ operator<<() [32/53]

std::ostream& gum::operator<<	(	std::ostream &	,
		const CliqueGraph &
	)

for friendly displaying the content of clique graphs

◆ operator<<() [33/53]

template<typename Val , typename Cmp , typename Alloc >

INLINE std::ostream& gum::operator<<	(	std::ostream &	stream,
		const Heap< Val, Cmp, Alloc > &	heap
	)

Definition at line 335 of file heap_tpl.h.

                                                                                          {
     stream << heap.toString();
     return stream;
   }

◆ operator<<() [34/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	output,
		const IBayesNet< GUM_SCALAR > &	bn
	)

Prints map's DAG in output using the Graphviz-dot format.

Definition at line 359 of file IBayesNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                        {
     output << bn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [35/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	output,
		const MarkovNet< GUM_SCALAR > &	mn
	)

Definition at line 365 of file MarkovNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                        {
     output << mn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [36/53]

std::ostream& gum::operator<<	(	std::ostream &	stream,
		const Edge &	edge
	)

to friendly display an edge

◆ operator<<() [37/53]

std::ostream& gum::operator<<	(	std::ostream &	stream,
		const Arc &	arc
	)

to friendly display an arc

◆ operator<<() [38/53]

INLINE std::ostream & gum::operator<<	(	std::ostream &	os,
		const Formula &	f
	)

Definition at line 477 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                            {
     os << f.result();
     return os;
   }

Here is the call graph for this function:

◆ operator<<() [39/53]

template<typename GUM_SCALAR >

INLINE std::ostream& gum::operator<<	(	std::ostream &	output,
		const BayesNet< GUM_SCALAR > &	bn
	)

Prints map's DAG in output using the Graphviz-dot format.

Definition at line 591 of file BayesNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
     output << bn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [40/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	out,
		const Potential< GUM_SCALAR > &	array
	)

Definition at line 593 of file potential_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
     out << array.toString();
     return out;
   }

Here is the call graph for this function:

◆ operator<<() [41/53]

template<typename Key , typename Alloc , bool Gen>

INLINE std::ostream& gum::operator<<	(	std::ostream &	stream,
		const SequenceImplementation< Key, Alloc, Gen > &	seq
	)

Definition at line 595 of file sequence_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                         {
     stream << seq.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [42/53]

template<typename Val , typename Priority , typename Cmp , typename Alloc >

INLINE std::ostream& gum::operator<<	(	std::ostream &	stream,
		const MultiPriorityQueue< Val, Priority, Cmp, Alloc > &	queue
	)

Definition at line 657 of file multiPriorityQueue_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                 {
     stream << queue.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [43/53]

template<typename GUM_SCALAR >

std::ostream& gum::operator<<	(	std::ostream &	output,
		const BayesNet< GUM_SCALAR > &	bn
	)

Prints map's DAG in output using the Graphviz-dot format.

Definition at line 591 of file BayesNet_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
     output << bn.toString();
     return output;
   }

Here is the call graph for this function:

◆ operator<<() [44/53]

template<typename Element >

std::ostream& gum::operator<<	(	std::ostream &	out,
		const SplayBinaryNode< Element > &	e
	)

Display the node.

Friendly to display.

Definition at line 787 of file splay_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
     if (e.fg) out << *e.fg << ",";
 
     out << e.elt;
 
     if (e.fd) out << "," << *e.fd;
 
     return out;
   }

Here is the call graph for this function:

◆ operator<<() [45/53]

std::ostream& gum::operator<<	(	std::ostream &	,
		const SetInst &
	)

Print information of the SetInst in the stream.

◆ operator<<() [46/53]

gum::SetInst& gum::operator<<	(	gum::SetInst &	inst,
		const gum::DiscreteVariable &	i
	)

Adds a variable to inst.

Parameters

inst	The SetInst to which a variable is added.
i	The variable to add.

Returns: Returns a reference over inst.

Exceptions

DuplicateElement If i is already in the SetInst.

◆ operator<<() [47/53]

template<typename Key , typename Alloc >

INLINE std::ostream& gum::operator<<	(	std::ostream &	stream,
		const SequenceImplementation< Key, Alloc, true > &	seq
	)

Definition at line 978 of file sequence_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                          {
     stream << seq.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [48/53]

template<typename Key , typename Alloc >

INLINE std::ostream& gum::operator<<	(	std::ostream &	stream,
		const Sequence< Key, Alloc > &	seq
	)

A << operator for displaying the content of the Sequence.

Definition at line 1140 of file sequence_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                        {
     stream << seq.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [49/53]

template<typename Val , typename Priority , typename Cmp , typename Alloc >

INLINE std::ostream& gum::operator<<	(	std::ostream &	stream,
		const PriorityQueue< Val, Priority, Cmp, Alloc > &	queue
	)

Definition at line 1178 of file priorityQueue_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
     stream << queue.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [50/53]

template<typename Key , typename Alloc >

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const Set< Key, Alloc > &	set
	)

A << operator for HashTableList.

Definition at line 812 of file set_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                            {
     stream << set.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [51/53]

template<typename Key , typename Alloc >

std::ostream& gum::operator<<	(	std::ostream &	stream,
		const Sequence< Key, Alloc > &	s
	)

A << operator for displaying the content of the Sequence.

Definition at line 1140 of file sequence_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                        {
     stream << seq.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [52/53]

template<typename T1 , typename T2 , typename Alloc >

std::ostream & gum::operator<<	(	std::ostream &	stream,
		const Bijection< T1, T2, Alloc > &	bijection
	)

For friendly display of the content of the gum::Bijection.

Parameters

bijection The gum::Bijection to display.

Template Parameters

T1	The first type of elements in the gum::Bjection.
T2	The second type of elements in the gum::Bjection.
Alloc	The allocator used for allocating memory.

Returns: The stream in which the gum::Bijection is displayed.

Definition at line 1192 of file bijection_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                   {
     stream << b.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator<<() [53/53]

template<typename Val >

std::ostream& gum::operator<<	(	std::ostream &	stream,
		const List< Val > &	list
	)

Definition at line 2043 of file list_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                       {
     stream << list.toString();
     return stream;
   }

Here is the call graph for this function:

◆ operator>>()

gum::SetInst& gum::operator>>	(	gum::SetInst &	inst,
		const gum::DiscreteVariable &	i
	)

Removes a variable to inst.

Parameters

inst	The SetInst to which a variable is removed.
i	The variable to remove.

Returns: Returns a reference over inst.

Exceptions

NotFound Raised if i is not found in inst.

◆ partialInstantiation() [1/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::partialInstantiation	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		const HashTable< const DiscreteVariable *, Idx > &	inst_vars
	)

Instantiate variables in a MultiDimImplementation.

Parameters

table	The table to instantiate.
inst_vars	The variables instantiation.

Returns: Returns the partial instantiation of table as a new MultiDimImplementation.

◆ partialInstantiation() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::partialInstantiation	(	const MultiDimDecorator< GUM_SCALAR > &	table,
		const HashTable< const DiscreteVariable *, Idx > &	inst_vars
	)

Instantiate variables in a MultiDimDecorator.

Parameters

table	The table to instantiate.
inst_vars	The variables instantiation.

Returns: Returns the partial instantiation of table as a new MultiDimImplementation.

◆ partialInstantiation4MultiDimInit()

template<typename GUM_SCALAR >

void gum::partialInstantiation4MultiDimInit ( )

The function used to register all the instantiation operators on multidimImplementations over non-pointers types.

Definition at line 94 of file partialInstantiation4MultiDim_tpl.h.

                                            {
     static bool first_init = true;
 
     if (first_init) {
       first_init = false;
 
       std::string MultiDimArrayString("MultiDimArray");
       std::string MultiDimDecisionDiagramString("MultiDimDecisionDiagram");
       std::string BaseNameString("MultiDimImplementation");
 
       // register base functions for multiDimArrays
       registerPartialInstantiation< GUM_SCALAR >("i",
                                                  MultiDimArrayString,
                                                  &partialInstantiationMultiDimArray);
 
       // register default basename functions
       registerPartialInstantiation< GUM_SCALAR >("i",
                                                  BaseNameString,
                                                  &partialInstantiationMultiDimImplementation);
     }
   }

◆ partialInstantiationMultiDimArray() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR >* gum::partialInstantiationMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		const HashTable< const DiscreteVariable *, Idx > &	inst_vars
	)

A specialized function for instantiating variables in a multiDimArray.

Warning: In practice, do not use this function but rather operator/function partialInstantiation on multiDimDecorators. This operator will take care to select this function if it is appropriate for your instantiation.

The function instantiates some variables in a multiDimArray. For instance, if table is a MultiDimArray defined over A,B,C,D and if inst_vars = {<A=a1>,<C=c2>}, then the function returns a table over B,D defined as table (a1,B,c2,D).

Parameters

table	The table to instantiate.
inst_vars	The variables instantiation.

Returns: Returns the partial instantiation of table as a new MultiDimArray.

◆ partialInstantiationMultiDimArray() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::partialInstantiationMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const HashTable< const DiscreteVariable *, Idx > &	inst_vars
	)

A specialized function for instantiating variables in a MultiDimImplementation.

Warning: In practice, do not use this function but rather operator/function partialInstantiation on multiDimDecorators. This operator will take care to select this function if it is appropriate for your instantiation.

The function instantiates some variables in a multiDimArray. For instance, if table is a MultiDimArray defined over A,B,C,D and if inst_vars = {<A=a1>,<C=c2>}, then the function returns a table over B,D defined as table (a1,B,c2,D).

Parameters

table	The table to instantiate.
inst_vars	The variables instantiation.

Returns: Returns the partial instantiation of table as a new MultiDimImplementation.

◆ partialInstantiationMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR* >* gum::partialInstantiationMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		const HashTable< const DiscreteVariable *, Idx > &	inst_vars
	)

A specialized function for instantiating variables in a MultiDimArray.

Warning: In practice, do not use this function but rather operator/function partialInstantiation on multiDimDecorators. This operator will take care to select this function if it is appropriate for your instantiation.

The function instantiates some variables in a multiDimArray. For instance, if table is a MultiDimArray defined over A,B,C,D and if inst_vars = {<A=a1>,<C=c2>}, then the function returns a table over B,D defined as table (a1,B,c2,D).

Parameters

table	The table to instantiate.
inst_vars	The variables instantiation.

Returns: Returns the partial instantiation of table as a new MultiDimArray.

◆ partialInstantiationMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR* >* gum::partialInstantiationMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		const HashTable< const DiscreteVariable *, Idx > &	inst_vars
	)

A specialized function for instantiating variables in a MultiDimArray.

Warning: In practice, do not use this function but rather operator/function partialInstantiation on multiDimDecorators. This operator will take care to select this function if it is appropriate for your instantiation.

The function instantiates some variables in a multiDimArray. For instance, if table is a MultiDimArray defined over A,B,C,D and if inst_vars = {<A=a1>,<C=c2>}, then the function returns a table over B,D defined as table (a1,B,c2,D).

Parameters

table	The table to instantiate.
inst_vars	The variables instantiation.

Returns: Returns the partial instantiation of table as a new MultiDimImplementation.

◆ pointerPartialInstantiation4MultiDimInit()

template<typename GUM_SCALAR >

void gum::pointerPartialInstantiation4MultiDimInit ( )

The function used to register all the instantiations on multidimImplementations over pointers types.

Definition at line 118 of file partialInstantiation4MultiDim_tpl.h.

                                                   {
     static bool first_init = true;
 
     if (first_init) {
       first_init = false;
 
       std::string MultiDimArrayString("MultiDimArray");
       std::string BaseNameString("MultiDimImplementation");
 
       // register base functions for multiDimArrays
       registerPartialInstantiation< GUM_SCALAR* >("i",
                                                   MultiDimArrayString,
                                                   &partialInstantiationMultiDimArray4Pointers);
 
       // register default basename functions
       registerPartialInstantiation< GUM_SCALAR* >(
          "i",
          BaseNameString,
          &partialInstantiationMultiDimImplementation4Pointers);
     }
   }

◆ pointerProjections4MultiDimInit()

template<typename GUM_SCALAR >

void gum::pointerProjections4MultiDimInit ( )

the function used to register all the projections on multidimImplementations over pointers types.

◆ print_output()

void gum::print_output ( std::vector< FormulaPart > v )

Definition at line 51 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                 {
     std::cout << "Output: ";
     for (const auto& elt: v) {
       std::cout << elt.str() << " ";
     }
     std::cout << std::endl;
   }

Here is the call graph for this function:

◆ print_stack()

void gum::print_stack ( std::stack< FormulaPart > s )

Definition at line 35 of file formula.cpp.

References gum::Set< Key, Alloc >::emplace().

                                               {
     std::cout << std::endl;
     std::list< FormulaPart > l;
     while (!s.empty()) {
       l.push_front(s.top());
       s.pop();
     }
 
     std::cout << "Stack: ";
     for (const auto& elt: l) {
       std::cout << elt.str() << " ";
     }
     std::cout << std::endl;
   }

Here is the call graph for this function:

◆ ProjectFuncMultiDimArray()

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR >* gum::ProjectFuncMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	t1,
		const MultiDimArray< GUM_SCALAR > *	t2,
		const GUM_SCALAR(*)(const GUM_SCALAR &, const GUM_SCALAR &)	f
	)

a specialized function for functionally projecting a multiDimArray

The function produces a tensorial functional combination of t1 and t2, that is, if t1 and t2 are multiDimArrays over variables A,B,C,D and D,B,E respectively, function combine2MultiDimArrays will return a multiDimArray T defined as T[A,B,C,D,E] = f ( t1[A,B,C,D],t2[D,B,E] ) for all A,B,C,D,E.

Returns: function combine2MultiDimArrays allocates on the heap the new T multiDimArray and returns it.

◆ projections4MultiDimInit()

template<typename GUM_SCALAR >

void gum::projections4MultiDimInit ( )

the function used to register all the projection operators on multidimImplementations over non-pointers types.

◆ projectMax() [1/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::projectMax	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		Instantiation *	instantiation = `0`
	)

the function to be used to project a MultiDimImplementation using a Max

◆ projectMax() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectMax	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

The function to be used to project a MultiDimImplementation using a Max.

◆ projectMaxMultiDimFunctionGraph() [1/2]

template<typename GUM_SCALAR >

MultiDimFunctionGraph< GUM_SCALAR >* gum::projectMaxMultiDimFunctionGraph	(	const MultiDimFunctionGraph< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using a Max operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Max_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraph allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMaxMultiDimFunctionGraph() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectMaxMultiDimFunctionGraph	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using a Max operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Max_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraph allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectMax on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMin() [1/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::projectMin	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		Instantiation *	instantiation = `0`
	)

the function to be used to project a MultiDimImplementation using a Min

◆ projectMin() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectMin	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

The function to be used to project a MultiDimImplementation using a Min.

◆ projectMinMultiDimArray() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR >* gum::projectMinMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Min operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Min_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectMinMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Min operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Min_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR* >* gum::projectMinMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Min operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Min_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR* >* gum::projectMinMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a Min operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Min_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimFunctionGraph() [1/2]

template<typename GUM_SCALAR >

MultiDimFunctionGraph< GUM_SCALAR >* gum::projectMinMultiDimFunctionGraph	(	const MultiDimFunctionGraph< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using a Min operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Min_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectMinMultiDimFunctionGraph() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectMinMultiDimFunctionGraph	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using a Min operator

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Min_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectMin on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProduct() [1/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::projectProduct	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		Instantiation *	instantiation = `0`
	)

the function to be used to project a MultiDimImplementation using a Product

◆ projectProduct() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectProduct	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

The function to be used to project a MultiDimImplementation using a Product.

◆ projectProductMultiDimArray() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR >* gum::projectProductMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using products

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Prod_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectProductMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using products

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Prod_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR* >* gum::projectProductMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using products

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Prod_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR* >* gum::projectProductMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using products

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Prod_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimFunctionGraph() [1/2]

template<typename GUM_SCALAR >

MultiDimFunctionGraph< GUM_SCALAR >* gum::projectProductMultiDimFunctionGraph	(	const MultiDimFunctionGraph< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using products

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Prod_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectProductMultiDimFunctionGraph() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectProductMultiDimFunctionGraph	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using products

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Prod_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectProduct on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSum() [1/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::projectSum	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		Instantiation *	instantiation = `0`
	)

the function to be used to project a MultiDimImplementation using a sum

◆ projectSum() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectSum	(	const MultiDimImplementation< GUM_SCALAR > &	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

The function to be used to project a MultiDimImplementation using a Sum.

◆ projectSumMultiDimArray() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR >* gum::projectSumMultiDimArray	(	const MultiDimArray< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a summation

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Sum_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectSumMultiDimArray	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a summation

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Sum_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray4Pointers() [1/2]

template<typename GUM_SCALAR >

MultiDimArray< GUM_SCALAR* >* gum::projectSumMultiDimArray4Pointers	(	const MultiDimArray< GUM_SCALAR * > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a summation

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Sum_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimArray4Pointers() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR* >* gum::projectSumMultiDimArray4Pointers	(	const MultiDimImplementation< GUM_SCALAR * > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimArray using a summation

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimArray defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Sum_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimArrays allocates on the heap the new T multiDimArray and returns it

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimFunctionGraph() [1/2]

template<typename GUM_SCALAR >

MultiDimFunctionGraph< GUM_SCALAR >* gum::projectSumMultiDimFunctionGraph	(	const MultiDimFunctionGraph< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using a summation

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Sum_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ projectSumMultiDimFunctionGraph() [2/2]

template<typename GUM_SCALAR >

MultiDimImplementation< GUM_SCALAR >* gum::projectSumMultiDimFunctionGraph	(	const MultiDimImplementation< GUM_SCALAR > *	table,
		const Set< const DiscreteVariable * > &	del_vars
	)

a specialized function for projecting a multiDimFunctionGraph using a summation

The function projects a table over the subset of its variables NOT IN the set of variables del_vars. For instance, if table is a MultiDimFunctionGraph defined over A,B,C,D and if del_vars = {A,C}, then the function returns a table over B,D defined as Sum_{A,C} table (A,B,C,D).

Returns: function ProjectMaxMultiDimFunctionGraphs allocates on the heap the new T multiDimFunctionGraph and returns it

Warning: In practice, do not use this function but rather operator/function projectSum on MultiDimImplementation. This operator will take care to select this function if it is appropriate for your projection.

◆ registerOperator()

template<typename GUM_SCALAR >

void gum::registerOperator	(	const std::string &	operation_name,
		const std::string &	type1,
		const std::string &	type2,
		typename OperatorRegister4MultiDim< GUM_SCALAR >::OperatorPtr	function
	)

A function to more easily register new operators in MultiDims.

◆ registerPartialInstantiation()

template<typename GUM_SCALAR >

void gum::registerPartialInstantiation	(	const std::string &	instantiation_func_name,
		const std::string &	type_multidim,
		typename PartialInstantiationRegister4MultiDim< GUM_SCALAR >::PartialInstantiationPtr	function
	)

A function to more easily register new instantiation functions in MultiDims.

◆ registerProjection()

template<typename GUM_SCALAR >

void gum::registerProjection	(	const std::string &	projection_name,
		const std::string &	type_multidim,
		typename ProjectionRegister4MultiDim< GUM_SCALAR >::ProjectionPtr	function
	)

A function to more easily register new projection functions in MultiDims.

◆ removeInfo()

template<class Element >

static INLINE void gum::removeInfo	(	const SplayBinaryNode< Element > *	e,
		HashTable< Element, SplayBinaryNode< Element > * > &	addr
	)

static

Definition at line 655 of file splay_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                          {
     GUM_ASSERT(addr.exists(e->getElement()));
     addr.erase(e->getElement());
 
     if (e->getFg()) removeInfo(e->getFg(), addr);
 
     if (e->getFd()) removeInfo(e->getFd(), addr);
   }

Here is the call graph for this function:

◆ sq()

template<typename GUM_SCALAR >

Potential< GUM_SCALAR > gum::sq ( const Potential< GUM_SCALAR > & arg )

inline

Definition at line 600 of file potential.h.

                                                                         {
     return arg.new_sq();
   }

◆ SSNewMNmultiPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::SSNewMNmultiPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Potential< GUM_SCALAR > &	t2
	)

static

Definition at line 43 of file ShaferShenoyMNInference.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                   {
     return new Potential< GUM_SCALAR >(t1 * t2);
   }

Here is the call graph for this function:

◆ SSNewMNprojPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::SSNewMNprojPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Set< const DiscreteVariable * > &	del_vars
	)

static

Definition at line 51 of file ShaferShenoyMNInference.h.

References gum::Set< Key, Alloc >::emplace().

                                                                           {
     return new Potential< GUM_SCALAR >(t1.margSumOut(del_vars));
   }

Here is the call graph for this function:

◆ SSNewmultiPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::SSNewmultiPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Potential< GUM_SCALAR > &	t2
	)

static

Definition at line 44 of file ShaferShenoyInference.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                 {
     return new Potential< GUM_SCALAR >(t1 * t2);
   }

Here is the call graph for this function:

◆ SSNewprojPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::SSNewprojPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Set< const DiscreteVariable * > &	del_vars
	)

static

Definition at line 52 of file ShaferShenoyInference.h.

References gum::Set< Key, Alloc >::emplace().

                                                                         {
     return new Potential< GUM_SCALAR >(t1.margSumOut(del_vars));
   }

Here is the call graph for this function:

◆ to_string()

INLINE std::string gum::to_string ( const Formula & f )

Definition at line 474 of file formula_inl.h.

References gum::Set< Key, Alloc >::emplace().

474 { return std::to_string(f.result()); }

gum::to_string

std::string to_string(const Formula &f)

Definition: formula_inl.h:474

Here is the call graph for this function:

◆ VENewmultiPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::VENewmultiPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Potential< GUM_SCALAR > &	t2
	)

static

Definition at line 46 of file variableElimination.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                                 {
     return new Potential< GUM_SCALAR >(t1 * t2);
   }

Here is the call graph for this function:

◆ VENewprojPotential()

template<typename GUM_SCALAR >

static INLINE Potential< GUM_SCALAR >* gum::VENewprojPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Set< const DiscreteVariable * > &	del_vars
	)

static

Definition at line 54 of file variableElimination.h.

References gum::Set< Key, Alloc >::emplace().

                                                                         {
     return new Potential< GUM_SCALAR >(t1.margSumOut(del_vars));
   }

Here is the call graph for this function:

Variable Documentation

◆ VariableLog2ParamComplexityCTable

const double gum::VariableLog2ParamComplexityCTable

Definition at line 37 of file variableLog2ParamComplexity.cpp.

◆ VariableLog2ParamComplexityCTableNSize

constexpr std::size_t gum::VariableLog2ParamComplexityCTableNSize {std::size_t(1000)}

Definition at line 50 of file variableLog2ParamComplexity.h.

◆ VariableLog2ParamComplexityCTableRSize

constexpr std::size_t gum::VariableLog2ParamComplexityCTableRSize {std::size_t(4)}

Definition at line 47 of file variableLog2ParamComplexity.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ FactorTable

◆ HybridGibbsSampling

◆ HybridImportanceSampling

◆ HybridMonteCarloSampling

◆ HybridWeightedSampling

◆ JoinTree

◆ JunctionTree

◆ pair_iterator

Enumeration Type Documentation

◆ BinTreeDir

◆ Complexity

◆ FactorySimulationAction

◆ FactorySimulationLandmark

◆ FactorySimulationLandmarkX

◆ FactorySimulationLandmarkY

◆ FindBarrenNodesType

◆ FMDPfactory_state

◆ LEARNERNAME

◆ RelevantPotentialsFinderType

◆ TaxiSimulationAction

◆ TaxiSimulationLandmark

◆ TaxiSimulationLandmarkX

◆ TaxiSimulationLandmarkY

◆ TESTNAME

◆ VarType

Function Documentation

◆ _initPotentialOperators__()

◆ abs()

◆ build_node()

◆ build_node_for_ID()

◆ build_node_for_MN()

◆ combine2MultiDimArrays()

◆ func2str()

◆ getMaxModality()

◆ log2()

◆ LPNewmultiPotential()

◆ LPNewprojPotential()

◆ operator*()

◆ operator+()

◆ operator-() [1/6]

◆ operator-() [2/6]

◆ operator-() [3/6]

◆ operator-() [4/6]

◆ operator-() [5/6]

◆ operator-() [6/6]

◆ operator/()

◆ operator<<() [1/53]

◆ operator<<() [2/53]

◆ operator<<() [3/53]

◆ operator<<() [4/53]

◆ operator<<() [5/53]

◆ operator<<() [6/53]

◆ operator<<() [7/53]

◆ operator<<() [8/53]

◆ operator<<() [9/53]

◆ operator<<() [10/53]

◆ operator<<() [11/53]

◆ operator<<() [12/53]

◆ operator<<() [13/53]

◆ operator<<() [14/53]

◆ operator<<() [15/53]

◆ operator<<() [16/53]

◆ operator<<() [17/53]

◆ operator<<() [18/53]

◆ operator<<() [19/53]

◆ operator<<() [20/53]

◆ operator<<() [21/53]

◆ operator<<() [22/53]

◆ operator<<() [23/53]

◆ operator<<() [24/53]

◆ operator<<() [25/53]

◆ operator<<() [26/53]