aGrUM  0.14.3
gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > Class Template Reference

Class implementingting a function graph. More...

#include <multiDimFunctionGraph.h>

+ Inheritance diagram for gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >:
+ Collaboration diagram for gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >:

Public Member Functions

template<>
const float defaultValue
 
template<>
const double defaultValue
 
Unallowed inherited methods
virtual void set (const Instantiation &i, const GUM_SCALAR &value) const
 
virtual void fill (const GUM_SCALAR &d) const
 
virtual void populate (const std::vector< GUM_SCALAR > &v) const
 
virtual void populate (std::initializer_list< GUM_SCALAR > v) const
 
virtual void copyFrom (const MultiDimContainer< GUM_SCALAR > &src, Instantiation *p_i=(Instantiation *) 0) const
 
virtual void copy (const MultiDimContainer< GUM_SCALAR > &src)
 
Inherited methods
virtual MultiDimContainer< GUM_SCALAR > * newFactory () const
 Creates an empty clone of this MultiDimContainer. More...
 
virtual GUM_SCALAR get (const Instantiation &i) const
 Returns the value pointed by i. More...
 
virtual const std::string & name () const
 Returns the real name of the multiDim implementation. More...
 
virtual void add (const DiscreteVariable &v)
 Adds a new var to the variables of the multidimensional matrix. More...
 
virtual void erase (const DiscreteVariable &v)
 Removes a var from the variables of the multidimensional matrix. More...
 
virtual Size realSize () const
 Returns the real number of parameters used for this table. More...
 
virtual void changeNotification (const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval)
 Listen to changes in a given Instantiation. More...
 
virtual void setFirstNotification (const Instantiation &i)
 Listen to setFirst in a given Instantiation. More...
 
virtual void setLastNotification (const Instantiation &i)
 Listen to setLast in a given Instantiation. More...
 
virtual void setIncNotification (const Instantiation &i)
 Listen to increment in a given Instantiation. More...
 
virtual void setDecNotification (const Instantiation &i)
 Listen to increment in each recorded Instantiation. More...
 
virtual void setChangeNotification (const Instantiation &i)
 Listen to an assignment of a value in a Instantiation. More...
 
virtual const std::string toString (const Instantiation *i) const
 Display the internal representation of i. More...
 
Copy methods.
void copy (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &src)
 Removes all variables in this MultiDimFunctionGraph and copy the content of src, variables included. More...
 
void copyAndReassign (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &src, const Bijection< const DiscreteVariable *, const DiscreteVariable * > &reassign)
 Copies src diagrams structure into this diagrams. More...
 
void copyAndMultiplyByScalar (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &src, GUM_SCALAR gamma)
 Copies src diagrams and multiply every value by the given scalar. More...
 
void clear ()
 Clears the function graph. More...
 
Accessors / Modifiers
const std::string & basename () const
 Returns the base class name of this MultiDimImplementation. More...
 
float compressionRate () const
 The compression ratio of the table (depending on the type of implementation). More...
 
MultiDimInterface implementation
virtual Idx nbrDim () const override
 Returns the number of vars in the multidimensional container. More...
 
virtual Size domainSize () const override
 Returns the product of the variables domain size. More...
 
virtual const Sequence< const DiscreteVariable *> & variablesSequence () const override
 Returns a const ref to the sequence of DiscreteVariable*. More...
 
virtual const DiscreteVariablevariable (Idx i) const override
 Returns a const ref to the ith var. More...
 
virtual const DiscreteVariablevariable (const std::string &name) const override
 Returns the variable with the name. More...
 
virtual Idx pos (const DiscreteVariable &v) const override
 Returns the index of a variable. More...
 
virtual bool contains (const DiscreteVariable &v) const override
 Returns true if var is in *this. More...
 
virtual bool empty () const override
 Returns true if no var is in *this. More...
 
MultiDimAdressable implementation
virtual bool registerSlave (Instantiation &slave) override
 Register i as a slave of this MultiDimAdressable. More...
 
virtual bool unregisterSlave (Instantiation &slave) override
 Unregister i as a slave of this MultiDimAdressable. More...
 
MultiDimContainer implementation
virtual void beginMultipleChanges () override
 Call this method before doing important changes in this MultiDimContainer. More...
 
virtual void endMultipleChanges () override
 Call this method after doing important changes in this MultiDimContainer. More...
 
virtual void endMultipleChanges (const GUM_SCALAR &) override
 Call this method after doing important changes in this MultiDimContainer. More...
 
Accessors / Modifiers
GUM_SCALAR operator[] (const Instantiation &i) const
 An [] operator using a Instantiation as argument. More...
 
Copy methods.
virtual void copyFrom (const MultiDimContainer< GUM_SCALAR > &src) const
 Basic copy of a MultiDimContainer. More...
 
virtual void extractFrom (const MultiDimContainer< GUM_SCALAR > &src, const Instantiation &mask)
 Basic extraction of a MultiDimContainer. More...
 
virtual MultiDimAdressablegetMasterRef ()
 In order to insure the dereference for decorators, we need to virtualize the access to master pointer. More...
 
virtual const MultiDimAdressablegetMasterRef () const
 In order to insure the dereference for decorators, we need to virtualize the access to master pointer. More...
 
Various methods.
virtual const std::string toString () const
 Returns a representation of this MultiDimContainer. More...
 
bool operator== (const MultiDimContainer< GUM_SCALAR > &p) const
 Test if this MultiDimContainer is equal to p. More...
 
bool operator!= (const MultiDimContainer< GUM_SCALAR > &p) const
 Test if this MultiDimContainer is different of p. More...
 
virtual void apply (std::function< GUM_SCALAR(GUM_SCALAR) > f) const
 Apply a function on every element of the container. More...
 
virtual GUM_SCALAR reduce (std::function< GUM_SCALAR(GUM_SCALAR, GUM_SCALAR) > f, GUM_SCALAR base) const
 compute lfold for this container More...
 
Accessors / Modifiers
void replace (const DiscreteVariable &x, const DiscreteVariable &y)
 Replace variables in this multidim. More...
 

Static Public Attributes

static const GUM_SCALAR defaultValue
 Only for proper initialization of a certain returned value. More...
 

Protected Member Functions

virtual void _replace (const DiscreteVariable *x, const DiscreteVariable *y)
 
GUM_SCALAR & _get (const Instantiation &inst) const
 
virtual const MultiDimImplementation< GUM_SCALAR > * content () const final
 Returns the implementation for this object (may be *this). More...
 
virtual MultiDimImplementation< GUM_SCALAR > * content () final
 Returns the implementation for this object (may be *this). More...
 
Fast large modifications in structures
virtual void _commitMultipleChanges ()
 Synchronize content after MultipleChanges. More...
 
virtual void _commitMultipleChanges (const GUM_SCALAR &value)
 Synchronize content after MultipleChanges. More...
 
bool _isInMultipleChangeMethod () const
 Get the actual change method of this MultiDimImplementation. More...
 
bool _isCommitNeeded () const
 Get the actual state of *this. More...
 
const List< Instantiation *> & _slaves () const
 Returns a constant reference over the list of slaved instantiations. More...
 
virtual void _invert (Idx p1, Idx p2)
 Inverts variables at position p1 and p2. More...
 

Constructors, destructor and copy

 MultiDimFunctionGraph (bool isReduced=true)
 Default constructor. More...
 
 MultiDimFunctionGraph (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &from)
 Copy constructor. More...
 
MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > & operator= (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &from)
 Copy Operator. More...
 
 ~MultiDimFunctionGraph ()
 Class destructor. More...
 

Accessors and modifiers

std::string toDot (bool withBackArcs=false) const
 Returns a const reference to the manager of this diagram. More...
 
const NodeGraphPartmodel () const
 Returns a const reference to the manager of this diagram. More...
 
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * manager ()
 Returns a const reference to the manager of this diagram. More...
 
const NodeIdroot () const
 Returns the id of the root node from the diagram. More...
 
bool isTerminalNode (const NodeId &node) const
 Indicates if given node is terminal or not. More...
 
bool isInternalNode (const NodeId &node) const
 Indicates if given node is terminal or not. More...
 
const GUM_SCALAR & nodeValue (NodeId n) const
 Returns value associated to given node. More...
 
const InternalNodenode (NodeId n) const
 Returns internalNode structure associated to that nodeId. More...
 
const LinkedList< NodeId > * varNodeListe (const DiscreteVariable *var) const
 Returns the list of node associated to given variable. More...
 
const std::string & tableName () const
 Returns the name of the table represented by this structure. More...
 
void setTableName (const std::string &name)
 Sets the name of the table represented by this structure. More...
 
bool isReducedAndOrdered () const
 Returns true if this MultiDimFunctionGraph is reduced and Ordered. More...
 
static MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * getReducedAndOrderedInstance ()
 Returns a reduced and ordered instance. More...
 
static MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * getTreeInstance ()
 Returns an arborescent instance. More...
 

Detailed Description

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
class gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >

Class implementingting a function graph.

Warning
Doxygen does not like spanning command on multiple line, so we could not configure it with the correct include directive. Use the following code snippet to include this file.
Template Parameters
GUM_SCALARThe type of scalars stored in this multidimensional table.
TerminalNodePolicyThe terminal node policy to use in this MultiDimFunctionGraph.

Definition at line 78 of file multiDimFunctionGraph.h.

Constructor & Destructor Documentation

◆ MultiDimFunctionGraph() [1/2]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::MultiDimFunctionGraph ( bool  isReduced = true)
private

Default constructor.

Parameters
isReducedIf true, then this MultiDimFunctionGraph is reduced.

Definition at line 34 of file multiDimFunctionGraph_tpl.h.

34  :
35  MultiDimImplementation< GUM_SCALAR >(),
36  __name("MultiDimFunctionGraph"), __tableName("NO NAME"), __model(500, true),
37  __manager(nullptr), __root(0), __internalNodeMap(500, true, false),
38  __var2NodeIdMap(500, true, false), __isReduced(isReduced) {
39  GUM_CONSTRUCTOR(MultiDimFunctionGraph);
40  __manager = nullptr;
41  // Pop up a first node so that id 0 is unavailable
42  __model.addNode();
43  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
NodeId __root
The root node of the function graph.
MultiDimFunctionGraph(bool isReduced=true)
Default constructor.
NodeGraphPart __model
Indicates available nodeIds.
virtual NodeId addNode()
insert a new node and return its id
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * __manager
A reference to the manager that edits this function graph.
std::string __name
The name of the data structure.
HashTable< const DiscreteVariable *, LinkedList< NodeId > *> __var2NodeIdMap
Mapping between var and node.
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
std::string __tableName
The name of the data structure.

◆ MultiDimFunctionGraph() [2/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::MultiDimFunctionGraph ( const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &  from)

Copy constructor.

Parameters
fromThe MultiDimFunctionGraph to copy.

Definition at line 48 of file multiDimFunctionGraph_tpl.h.

49  :
50  MultiDimImplementation< GUM_SCALAR >(),
51  __name("MultiDimFunctionGraph"), __tableName("No NAME"), __model(500, true),
52  __manager(nullptr), __root(0), __internalNodeMap(500, true, false),
53  __var2NodeIdMap(500, true, false), __isReduced(from.isReducedAndOrdered()) {
54  GUM_CONS_CPY(MultiDimFunctionGraph);
55  copy(from);
56  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
NodeId __root
The root node of the function graph.
MultiDimFunctionGraph(bool isReduced=true)
Default constructor.
NodeGraphPart __model
Indicates available nodeIds.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * __manager
A reference to the manager that edits this function graph.
std::string __name
The name of the data structure.
HashTable< const DiscreteVariable *, LinkedList< NodeId > *> __var2NodeIdMap
Mapping between var and node.
virtual void copy(const MultiDimContainer< GUM_SCALAR > &src)
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
std::string __tableName
The name of the data structure.

◆ ~MultiDimFunctionGraph()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::~MultiDimFunctionGraph ( )

Class destructor.

Definition at line 70 of file multiDimFunctionGraph_tpl.h.

70  {
71  // Manager deletion
72  GUM_DESTRUCTOR(MultiDimFunctionGraph);
73  if (__manager != nullptr) delete __manager;
74  this->clear();
75  }
MultiDimFunctionGraph(bool isReduced=true)
Default constructor.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * __manager
A reference to the manager that edits this function graph.
void clear()
Clears the function graph.

Member Function Documentation

◆ _commitMultipleChanges() [1/2]

template<typename GUM_SCALAR >
INLINE void gum::MultiDimImplementation< GUM_SCALAR >::_commitMultipleChanges ( )
protectedvirtualinherited

Synchronize content after MultipleChanges.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >, gum::MultiDimArray< GUM_SCALAR >, gum::MultiDimBijArray< GUM_SCALAR >, and gum::MultiDimSparse< GUM_SCALAR >.

Definition at line 252 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges().

252  {
253  // empty!
254  }
+ Here is the caller graph for this function:

◆ _commitMultipleChanges() [2/2]

template<typename GUM_SCALAR>
INLINE void gum::MultiDimImplementation< GUM_SCALAR >::_commitMultipleChanges ( const GUM_SCALAR &  value)
protectedvirtualinherited

Synchronize content after MultipleChanges.

Parameters
valueDefault value for uninitialized values.

Reimplemented in gum::MultiDimArray< GUM_SCALAR >.

Definition at line 257 of file multiDimImplementation_tpl.h.

258  {
259  // empty!
260  }

◆ _get()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE GUM_SCALAR & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::_get ( const Instantiation inst) const
protectedvirtual
Warning
This will raise an OperationNotAllowed as you should not use this method as MultiDimFunctionGraph use its own internal structure for storing data.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 657 of file multiDimFunctionGraph_tpl.h.

658  {
659  GUM_ERROR(OperationNotAllowed,
660  "You can't edit a function by other mean than the manager");
661  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ _invert()

template<typename GUM_SCALAR >
INLINE void gum::MultiDimImplementation< GUM_SCALAR >::_invert ( Idx  p1,
Idx  p2 
)
protectedvirtualinherited

Inverts variables at position p1 and p2.

Call this from subclass when you want to invert position of two variables in the MultiDimImplementation.

Parameters
p1The first position.
p2The second position.

Definition at line 316 of file multiDimImplementation_tpl.h.

316  {
317  __vars.swap(p1, p2);
318  }
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).

◆ _isCommitNeeded()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimImplementation< GUM_SCALAR >::_isCommitNeeded ( ) const
protectedinherited

Get the actual state of *this.

Returns
Returns true if a commit is needed.

Definition at line 271 of file multiDimImplementation_tpl.h.

◆ _isInMultipleChangeMethod()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimImplementation< GUM_SCALAR >::_isInMultipleChangeMethod ( ) const
protectedinherited

Get the actual change method of this MultiDimImplementation.

Returns
Returns true if in multiple changes.

Definition at line 265 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimArray< GUM_SCALAR >::add(), and gum::MultiDimArray< GUM_SCALAR >::erase().

+ Here is the caller graph for this function:

◆ _replace()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::_replace ( const DiscreteVariable x,
const DiscreteVariable y 
)
protectedvirtual
Warning
This will raise an OperationNotAllowed as this method has not yet been implemented.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 651 of file multiDimFunctionGraph_tpl.h.

652  {
653  GUM_ERROR(OperationNotAllowed, "Not Implemented Yet")
654  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ _slaves()

template<typename GUM_SCALAR >
INLINE const List< Instantiation *> & gum::MultiDimImplementation< GUM_SCALAR >::_slaves ( ) const
protectedinherited

Returns a constant reference over the list of slaved instantiations.

Returns
Returns a constant reference over the list of slaved instantiations.

Definition at line 278 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer().

278  {
279  return __slaveInstantiations;
280  }
List< Instantiation *> __slaveInstantiations
List of instantiations of the tuples (sequences) of variables.
+ Here is the caller graph for this function:

◆ add()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::add ( const DiscreteVariable v)
virtual

Adds a new var to the variables of the multidimensional matrix.

See also
operator<<(MultiDimInterface& c, const DiscreteVariable& v)
Warning
Note that the variable passed in argument is not duplicated, that is, only a pointer toward the variable is kept by the MultiDimInterface.
Parameters
vThe new var.
Exceptions
DuplicateElementRaised if the variable already belongs to the sequence of variables.
OperationNotAllowedRaised if this object is non mutable.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 134 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::ITI< AttributeSelection, isScalar >::__insertNodeInFunctionGraph(), gum::ITI< AttributeSelection, isScalar >::__insertTerminalNode(), gum::IMDDI< AttributeSelection, isScalar >::__rebuildFunctionGraph(), gum::StructuredPlaner< double >::_addReward(), gum::ITI< AttributeSelection, isScalar >::_insertSetOfVars(), gum::StructuredPlaner< double >::_makeArgMax(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::insertSetOfVars(), gum::IMDDI< AttributeSelection, isScalar >::insertSetOfVars(), gum::IncrementalGraphLearner< AttributeSelection, isScalar >::insertSetOfVars(), gum::StatesCounter::reset(), and gum::StatesChecker::reset().

135  {
136  if (!this->variablesSequence().exists(&v))
138 
139  if (!this->__var2NodeIdMap.exists(&v))
140  __var2NodeIdMap.insert(&v, new LinkedList< NodeId >());
141  }
HashTable< const DiscreteVariable *, LinkedList< NodeId > *> __var2NodeIdMap
Mapping between var and node.
virtual void add(const DiscreteVariable &v) override
Adds a new var to the variables of the multidimensional matrix.
virtual const Sequence< const DiscreteVariable *> & variablesSequence() const override
Returns a const ref to the sequence of DiscreteVariable*.
+ Here is the caller graph for this function:

◆ apply()

template<typename GUM_SCALAR >
void gum::MultiDimContainer< GUM_SCALAR >::apply ( std::function< GUM_SCALAR(GUM_SCALAR) >  f) const
virtualinherited

Apply a function on every element of the container.

Parameters
fthe function to apply

Reimplemented in gum::MultiDimDecorator< GUM_SCALAR >, and gum::MultiDimArray< GUM_SCALAR >.

Definition at line 193 of file multiDimContainer_tpl.h.

References gum::Instantiation::end(), and gum::Instantiation::setFirst().

194  {
195  Instantiation i(*this);
196  for (i.setFirst(); !i.end(); ++i) {
197  set(i, f(get(i)));
198  }
199  }
+ Here is the call graph for this function:

◆ basename()

template<typename GUM_SCALAR >
const std::string & gum::MultiDimImplementation< GUM_SCALAR >::basename ( ) const
inherited

Returns the base class name of this MultiDimImplementation.

This method is used for chosing a proposer operator when no specialized operator have been defined.

Definition at line 296 of file multiDimImplementation_tpl.h.

296  {
297  static const std::string str = "MultiDimImplementation";
298  return str;
299  }

◆ beginMultipleChanges()

template<typename GUM_SCALAR >
INLINE void gum::MultiDimImplementation< GUM_SCALAR >::beginMultipleChanges ( )
overridevirtualinherited

Call this method before doing important changes in this MultiDimContainer.

Warning
Remember to call endMultipleChanges() when you finish your changes.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 226 of file multiDimImplementation_tpl.h.

◆ changeNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::changeNotification ( const Instantiation i,
const DiscreteVariable *const  var,
Idx  oldval,
Idx  newval 
)
virtual

Listen to changes in a given Instantiation.

Parameters
iThe Instantiation to listen.
varThe changed dim.
oldvalThe old value.
newvalThe changed value.

Implements gum::MultiDimAdressable.

Definition at line 167 of file multiDimFunctionGraph_tpl.h.

171  {}

◆ clear()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::clear ( )

Clears the function graph.

Definition at line 419 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::__rebuildFunctionGraph(), gum::MultiDimFunctionGraph< bool, ExactTerminalNodePolicy >::clear(), gum::StatesCounter::reset(), gum::StatesChecker::reset(), and gum::ITI< AttributeSelection, isScalar >::updateFunctionGraph().

419  {
420  __model.clear();
421  // Always discard the nodeId 0
422  __model.addNode();
423 
424  this->clearAllTerminalNodes();
425 
426  // Nodes cleaning
427  for (HashTableIterator< NodeId, InternalNode* > nodeIter =
428  __internalNodeMap.begin();
429  nodeIter != __internalNodeMap.end();
430  ++nodeIter) {
431  delete nodeIter.val();
432  }
433  __internalNodeMap.clear();
434 
435  // Cleaning the list of nodes for each variables
436  for (HashTableIterator< const DiscreteVariable*, LinkedList< NodeId >* >
437  varIter = __var2NodeIdMap.begin();
438  varIter != __var2NodeIdMap.end();
439  ++varIter) {
440  delete varIter.val();
441  }
442  __var2NodeIdMap.clear();
443 
444  for (SequenceIteratorSafe< const DiscreteVariable* > varIter =
445  this->variablesSequence().rbeginSafe();
446  varIter != this->variablesSequence().rendSafe();
447  --varIter) {
448  this->erase(**varIter);
449  }
450  }
virtual void erase(const DiscreteVariable &v)
Removes a var from the variables of the multidimensional matrix.
NodeGraphPart __model
Indicates available nodeIds.
virtual NodeId addNode()
insert a new node and return its id
HashTable< const DiscreteVariable *, LinkedList< NodeId > *> __var2NodeIdMap
Mapping between var and node.
virtual void clear()
alias for clearNodes
virtual const Sequence< const DiscreteVariable *> & variablesSequence() const override
Returns a const ref to the sequence of DiscreteVariable*.
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
+ Here is the caller graph for this function:

◆ compressionRate()

template<typename GUM_SCALAR >
INLINE float gum::MultiDimImplementation< GUM_SCALAR >::compressionRate ( ) const
inherited

The compression ratio of the table (depending on the type of implementation).

This method uses domainSize() and realSize() to compute the ration, both methods are virtual and should be surcharge if a subclass has a special policies about memory management.

Warning
This compression ratio is not exactly the memory compression ratio. It is computed in terms of number of parameters.
Returns
Returns the compression ration of the table.

Definition at line 290 of file multiDimImplementation_tpl.h.

290  {
291  return ((float)1) - (float)realSize() / (float)domainSize();
292  }
virtual Size realSize() const =0
Returns the real number of parameters used for this table.
virtual Size domainSize() const override
Returns the product of the variables domain size.

◆ contains()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimImplementation< GUM_SCALAR >::contains ( const DiscreteVariable v) const
overridevirtualinherited

Returns true if var is in *this.

Parameters
vA DiscreteVariable.
Returns
Returns true if var is in *this.

Implements gum::MultiDimInterface.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 205 of file multiDimImplementation_tpl.h.

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::__fillCpf(), gum::prm::PRMFormAttribute< GUM_SCALAR >::_type(), gum::prm::PRMFormAttribute< GUM_SCALAR >::addParent(), gum::MultiDimICIModel< GUM_SCALAR >::causalWeight(), gum::MultiDimBucket< GUM_SCALAR >::contains(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copyCpf(), gum::prm::PRMFormAttribute< GUM_SCALAR >::getCastDescendant(), and gum::prm::PRMFormAttribute< GUM_SCALAR >::swap().

206  {
207  return __vars.exists(&v);
208  }
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).
+ Here is the caller graph for this function:

◆ content() [1/2]

template<typename GUM_SCALAR >
INLINE const MultiDimImplementation< GUM_SCALAR > * gum::MultiDimImplementation< GUM_SCALAR >::content ( ) const
finalprotectedvirtualinherited

Returns the implementation for this object (may be *this).

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 339 of file multiDimImplementation_tpl.h.

339  {
340  return this;
341  }

◆ content() [2/2]

template<typename GUM_SCALAR >
INLINE MultiDimImplementation< GUM_SCALAR > * gum::MultiDimImplementation< GUM_SCALAR >::content ( )
finalprotectedvirtualinherited

Returns the implementation for this object (may be *this).

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 332 of file multiDimImplementation_tpl.h.

332  {
333  return this;
334  }

◆ copy() [1/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::copy ( const MultiDimContainer< GUM_SCALAR > &  src)
virtual
Warning
This will raise an OperationNotAllowed as MultiDimFunctionGraph can't copy other multiDim.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 215 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::MDDOperatorStrategy< GUM_SCALAR >::regress().

216  {
217  GUM_ERROR(OperationNotAllowed,
218  "You cannot copy another type of multiDim "
219  "into a MultiDimFunctionGraph.");
220  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the caller graph for this function:

◆ copy() [2/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::copy ( const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &  src)

Removes all variables in this MultiDimFunctionGraph and copy the content of src, variables included.

Parameters
srcThe MultiDimFunctionGraph to copy.

Definition at line 223 of file multiDimFunctionGraph_tpl.h.

224  {
225  if (this->__isReduced != src.isReducedAndOrdered())
226  GUM_ERROR(OperationNotAllowed,
227  "Cannot copy a Reduced and Ordered "
228  "function graph into Tree function graph "
229  "(or vice-versa).")
230 
231  this->clear();
232 
233  // New variables insertion
234  for (SequenceIteratorSafe< const DiscreteVariable* > varIter =
235  src.variablesSequence().beginSafe();
236  varIter != src.variablesSequence().endSafe();
237  ++varIter)
238  this->add(**varIter);
239 
240  std::vector< NodeId > lifo;
241  Bijection< NodeId, NodeId > src2dest;
242 
243  if (src.isTerminalNode(src.root()))
244  this->manager()->setRootNode(
245  this->manager()->addTerminalNode(src.nodeValue(src.root())));
246  else {
247  this->manager()->setRootNode(
248  this->manager()->addInternalNode(src.node(src.root())->nodeVar()));
249  src2dest.insert(src.root(), this->root());
250  lifo.push_back(src.root());
251  }
252 
253  // Depth-first exploration and copy
254  while (!lifo.empty()) {
255  NodeId currentSrcNodeId = lifo.back();
256  lifo.pop_back();
257 
258  const InternalNode* currentSrcNode = src.node(currentSrcNodeId);
259 
260  for (Idx index = 0; index < currentSrcNode->nbSons(); ++index) {
261  if (!src2dest.existsFirst(currentSrcNode->son(index))) {
262  NodeId srcSonNodeId = currentSrcNode->son(index), destSonNodeId = 0;
263  if (src.isTerminalNode(srcSonNodeId)) {
264  destSonNodeId =
265  this->manager()->addTerminalNode(src.nodeValue(srcSonNodeId));
266  } else {
267  destSonNodeId =
268  this->manager()->addInternalNode(src.node(srcSonNodeId)->nodeVar());
269  lifo.push_back(srcSonNodeId);
270  }
271  src2dest.insert(srcSonNodeId, destSonNodeId);
272  }
273  this->manager()->setSon(src2dest.second(currentSrcNodeId),
274  index,
275  src2dest.second(currentSrcNode->son(index)));
276  }
277  }
278 
279  manager()->clean();
280  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
virtual void add(const DiscreteVariable &v)
Adds a new var to the variables of the multidimensional matrix.
const NodeId & root() const
Returns the id of the root node from the diagram.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * manager()
Returns a const reference to the manager of this diagram.
Size NodeId
Type for node ids.
Definition: graphElements.h:97
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
void clear()
Clears the function graph.

◆ copyAndMultiplyByScalar()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::copyAndMultiplyByScalar ( const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &  src,
GUM_SCALAR  gamma 
)

Copies src diagrams and multiply every value by the given scalar.

Parameters
srcThe MultiDimFunctionGraph to copy.
gammaThe scalar used to multiply every value with.

Definition at line 357 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StructuredPlaner< double >::_addReward().

359  {
360  if (this->__isReduced != src.isReducedAndOrdered())
361  GUM_ERROR(OperationNotAllowed,
362  "Cannot copy a Reduced and Ordered "
363  "function graph into Tree function graph "
364  "(or vice-versa).")
365 
366  this->clear();
367 
368  // New variables insertion
369  for (SequenceIteratorSafe< const DiscreteVariable* > varIter =
370  src.variablesSequence().beginSafe();
371  varIter != src.variablesSequence().endSafe();
372  ++varIter)
373  this->add(**varIter);
374 
375  std::vector< NodeId > lifo;
377 
378  if (src.isTerminalNode(src.root()))
379  this->manager()->setRootNode(
380  this->manager()->addTerminalNode(gamma * src.nodeValue(src.root())));
381  else {
382  this->manager()->setRootNode(
383  this->manager()->addInternalNode(src.node(src.root())->nodeVar()));
384  src2dest.insert(src.root(), this->root());
385  lifo.push_back(src.root());
386  }
387 
388  // Depth-first exploration an copy
389  while (!lifo.empty()) {
390  NodeId currentSrcNodeId = lifo.back();
391  lifo.pop_back();
392 
393  const InternalNode* currentSrcNode = src.node(currentSrcNodeId);
394 
395  for (Idx index = 0; index < currentSrcNode->nbSons(); ++index) {
396  if (!src2dest.exists(currentSrcNode->son(index))) {
397  NodeId srcSonNodeId = currentSrcNode->son(index), destSonNodeId = 0;
398  if (src.isTerminalNode(srcSonNodeId)) {
399  destSonNodeId = this->manager()->addTerminalNode(
400  gamma * src.nodeValue(srcSonNodeId));
401  } else {
402  destSonNodeId =
403  this->manager()->addInternalNode(src.node(srcSonNodeId)->nodeVar());
404  lifo.push_back(srcSonNodeId);
405  }
406  src2dest.insert(srcSonNodeId, destSonNodeId);
407  }
408  this->manager()->setSon(src2dest[currentSrcNodeId],
409  index,
410  src2dest[currentSrcNode->son(index)]);
411  }
412  }
413 
414  manager()->clean();
415  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
bool exists(const Key &key) const
Checks whether there exists an element with a given key in the hashtable.
virtual void add(const DiscreteVariable &v)
Adds a new var to the variables of the multidimensional matrix.
const NodeId & root() const
Returns the id of the root node from the diagram.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * manager()
Returns a const reference to the manager of this diagram.
value_type & insert(const Key &key, const Val &val)
Adds a new element (actually a copy of this element) into the hash table.
Size NodeId
Type for node ids.
Definition: graphElements.h:97
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
void clear()
Clears the function graph.
+ Here is the caller graph for this function:

◆ copyAndReassign()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::copyAndReassign ( const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &  src,
const Bijection< const DiscreteVariable *, const DiscreteVariable * > &  reassign 
)

Copies src diagrams structure into this diagrams.

However it also changes the variables.

Warning
This has two implications:
  • First, this is not just a renaming. Pointers are trully changed.
  • Second, for each pair of variable, the new variable MUST macth the number of modalities of the old variable.
Parameters
srcThe MultiDimFunctionGraph to copy.
reassignA Bijection form variables in src to variables in this.

Definition at line 285 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::AdaptiveRMaxPlaner::_evalPolicy(), gum::StructuredPlaner< double >::_evalPolicy(), gum::AdaptiveRMaxPlaner::_valueIteration(), and gum::StructuredPlaner< double >::_valueIteration().

288  {
289  if (this->__isReduced != src.isReducedAndOrdered())
290  GUM_ERROR(OperationNotAllowed,
291  "Cannot copy a Reduced and Ordered "
292  "function graph into Tree function graph "
293  "(or vice-versa).")
294 
295  this->clear();
296 
297  // New variables insertion
298  for (SequenceIteratorSafe< const DiscreteVariable* > varIter =
299  src.variablesSequence().beginSafe();
300  varIter != src.variablesSequence().endSafe();
301  ++varIter) {
302  if ((*varIter)->domainSize() != reassign.second(*varIter)->domainSize())
303  GUM_ERROR(InvalidArgument,
304  "Var " << (*varIter)->name() << " and var "
305  << reassign.second(*varIter)->name()
306  << " have different domain sizes ("
307  << (*varIter)->domainSize()
308  << "!=" << reassign.second(*varIter)->domainSize() << ")")
309  this->add(*(reassign.second(*varIter)));
310  }
311 
312  std::vector< NodeId > lifo;
313  Bijection< NodeId, NodeId > src2dest;
314 
315  if (src.isTerminalNode(src.root())) {
316  this->manager()->setRootNode(
317  this->manager()->addTerminalNode(src.nodeValue(src.root())));
318  } else {
319  this->manager()->setRootNode(this->manager()->addInternalNode(
320  reassign.second(src.node(src.root())->nodeVar())));
321  src2dest.insert(src.root(), this->root());
322  lifo.push_back(src.root());
323  }
324 
325  // Depth-first exploration and copy
326  while (!lifo.empty()) {
327  NodeId currentSrcNodeId = lifo.back();
328  lifo.pop_back();
329 
330  const InternalNode* currentSrcNode = src.node(currentSrcNodeId);
331 
332  for (Idx index = 0; index < currentSrcNode->nbSons(); ++index) {
333  if (!src2dest.existsFirst(currentSrcNode->son(index))) {
334  NodeId srcSonNodeId = currentSrcNode->son(index), destSonNodeId = 0;
335  if (src.isTerminalNode(srcSonNodeId)) {
336  destSonNodeId =
337  this->manager()->addTerminalNode(src.nodeValue(srcSonNodeId));
338  } else {
339  destSonNodeId = this->manager()->addInternalNode(
340  reassign.second(src.node(srcSonNodeId)->nodeVar()));
341  lifo.push_back(srcSonNodeId);
342  }
343  src2dest.insert(srcSonNodeId, destSonNodeId);
344  }
345  this->manager()->setSon(src2dest.second(currentSrcNodeId),
346  index,
347  src2dest.second(currentSrcNode->son(index)));
348  }
349  }
350 
351  manager()->clean();
352  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
virtual void add(const DiscreteVariable &v)
Adds a new var to the variables of the multidimensional matrix.
const NodeId & root() const
Returns the id of the root node from the diagram.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * manager()
Returns a const reference to the manager of this diagram.
Size NodeId
Type for node ids.
Definition: graphElements.h:97
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
void clear()
Clears the function graph.
+ Here is the caller graph for this function:

◆ copyFrom() [1/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::copyFrom ( const MultiDimContainer< GUM_SCALAR > &  src,
Instantiation p_i = (Instantiation*)0 
) const
virtual
Warning
This will raise an OperationNotAllowed as MultiDimFunctionGraph can't copy other multiDim.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 207 of file multiDimFunctionGraph_tpl.h.

208  {
209  GUM_ERROR(OperationNotAllowed,
210  "You cannot copy another type of multiDim "
211  "into a MultiDimFunctionGraph.");
212  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ copyFrom() [2/2]

template<typename GUM_SCALAR >
void gum::MultiDimContainer< GUM_SCALAR >::copyFrom ( const MultiDimContainer< GUM_SCALAR > &  src) const
virtualinherited

Basic copy of a MultiDimContainer.

This method is virtual because it should be optimized in certain MultiDimContainer.

Parameters
srcThe MultiDimContainer src which values are copied. This is a full copy with no verification of dimensions.
Exceptions
OperationNotAllowedRaised if src does not have the same domain size than this MultiDimContainer.

Reimplemented in gum::aggregator::MultiDimAggregator< GUM_SCALAR >, gum::MultiDimICIModel< GUM_SCALAR >, and gum::MultiDimArray< GUM_SCALAR >.

Definition at line 262 of file multiDimContainer_tpl.h.

References gum::MultiDimInterface::domainSize(), gum::Instantiation::end(), GUM_ERROR, and gum::Instantiation::setFirst().

Referenced by gum::BayesNet< double >::__copyPotentials(), gum::MultiDimContainer< GUM_SCALAR >::copy(), gum::MultiDimArray< GUM_SCALAR >::copyFrom(), gum::MultiDimICIModel< GUM_SCALAR >::copyFrom(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::copyFrom(), and gum::Potential< GUM_SCALAR >::reorganize().

263  {
264  if (src.domainSize() != domainSize()) {
265  GUM_ERROR(OperationNotAllowed, "Domain sizes do not fit");
266  }
267 
268  Instantiation i_dest(*this);
269  Instantiation i_src(src);
270 
271  for (i_dest.setFirst(), i_src.setFirst(); !i_dest.end(); ++i_dest, ++i_src) {
272  set(i_dest, src[i_src]);
273  }
274  }
virtual Size domainSize() const =0
Returns the product of the variables domain size.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ defaultValue() [1/2]

template<>
const float gum::MultiDimFunctionGraph< float >::defaultValue ( )

Definition at line 44 of file multiDimFunctionGraph.cpp.

◆ defaultValue() [2/2]

template<>
const double gum::MultiDimFunctionGraph< double >::defaultValue ( )

Definition at line 47 of file multiDimFunctionGraph.cpp.

◆ domainSize()

◆ empty()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimImplementation< GUM_SCALAR >::empty ( ) const
overridevirtualinherited

Returns true if no var is in *this.

Returns
Returns true if no var is in *this.

Implements gum::MultiDimInterface.

Definition at line 220 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), and gum::MultiDimArray< GUM_SCALAR >::fill().

220  {
221  GUM_ASSERT(!this->_isCommitNeeded());
222  return __vars.empty();
223  }
bool _isCommitNeeded() const
Get the actual state of *this.
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).
+ Here is the caller graph for this function:

◆ endMultipleChanges() [1/2]

template<typename GUM_SCALAR >
INLINE void gum::MultiDimImplementation< GUM_SCALAR >::endMultipleChanges ( )
overridevirtualinherited

◆ endMultipleChanges() [2/2]

template<typename GUM_SCALAR>
INLINE void gum::MultiDimImplementation< GUM_SCALAR >::endMultipleChanges ( const GUM_SCALAR &  v)
overridevirtualinherited

◆ erase()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::erase ( const DiscreteVariable v)
virtual

Removes a var from the variables of the multidimensional matrix.

See also
operator>>(MultiDimInterface& c, const DiscreteVariable& v)
Exceptions
OperationNotAllowedRaised if this object is non mutable.
NotFoundRaised if v does not belong to this.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 144 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::MultiDimFunctionGraph< bool, ExactTerminalNodePolicy >::erase().

145  {
146  if (this->__var2NodeIdMap.exists(&v)) {
147  while (__var2NodeIdMap[&v]->list() != nullptr) {
148  manager()->eraseNode(__var2NodeIdMap[&v]->list()->element());
149  }
150  delete __var2NodeIdMap[&v];
151  __var2NodeIdMap.erase(&v);
152  }
153 
154  if (this->variablesSequence().exists(&v))
156  }
virtual void erase(const DiscreteVariable &v) override
Removes a var from the variables of the multidimensional matrix.
HashTable< const DiscreteVariable *, LinkedList< NodeId > *> __var2NodeIdMap
Mapping between var and node.
virtual const Sequence< const DiscreteVariable *> & variablesSequence() const override
Returns a const ref to the sequence of DiscreteVariable*.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * manager()
Returns a const reference to the manager of this diagram.
+ Here is the caller graph for this function:

◆ extractFrom()

template<typename GUM_SCALAR >
void gum::MultiDimContainer< GUM_SCALAR >::extractFrom ( const MultiDimContainer< GUM_SCALAR > &  src,
const Instantiation mask 
)
virtualinherited

Basic extraction of a MultiDimContainer.

This method is virtual because it should be optimized in certain MultiDimContainer.

Parameters
srcThe MultiDimContainer src which datas are copied.
maskpartial instantiation of variables of the Potential : the extraction will concern every variable not in the instantiation and the copy of data will use the values in this instantiation.

Definition at line 237 of file multiDimContainer_tpl.h.

References gum::MultiDimInterface::add(), gum::MultiDimContainer< GUM_SCALAR >::beginMultipleChanges(), gum::Instantiation::contains(), gum::Instantiation::end(), gum::MultiDimContainer< GUM_SCALAR >::endMultipleChanges(), gum::MultiDimInterface::erase(), GUM_ERROR, gum::Instantiation::incOut(), gum::MultiDimInterface::nbrDim(), gum::Instantiation::setFirstOut(), gum::Instantiation::setVals(), and gum::MultiDimInterface::variable().

Referenced by gum::Potential< GUM_SCALAR >::extract().

238  {
239  this->beginMultipleChanges();
240 
241  Size nbr = this->nbrDim();
242 
243  for (Idx i = 0; i < nbr; i++) {
244  this->erase(this->variable(0));
245  }
246 
247  for (Idx i = 0; i < src.nbrDim(); i++) {
248  if (!imask.contains(src.variable(i))) this->add(src.variable(i));
249  }
250 
251  if (this->nbrDim() == 0) { GUM_ERROR(FatalError, "Empty potential"); }
252 
253  this->endMultipleChanges();
254 
255  Instantiation inst(src);
256  inst.setVals(imask);
257  for (inst.setFirstOut(imask); !inst.end(); inst.incOut(imask))
258  set(inst, src[inst]);
259  }
virtual void endMultipleChanges()=0
Call this method after doing important changes in this MultiDimContainer.
virtual void add(const DiscreteVariable &v)=0
Adds a new var to the variables of the multidimensional matrix.
virtual Idx nbrDim() const =0
Returns the number of vars in the multidimensional container.
virtual const DiscreteVariable & variable(Idx i) const =0
Returns a const ref to the ith var.
virtual void beginMultipleChanges()=0
Call this method before doing important changes in this MultiDimContainer.
virtual void erase(const DiscreteVariable &v)=0
Removes a var from the variables of the multidimensional matrix.
std::size_t Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:45
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ fill()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::fill ( const GUM_SCALAR &  d) const
virtual
Warning
This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 105 of file multiDimFunctionGraph_tpl.h.

106  {
107  GUM_ERROR(OperationNotAllowed,
108  "Function Graph can't be edited so "
109  "easily.\nMultiDimFunctionGraphManager "
110  "provides the framework to edit a "
111  "Function Graph.")
112  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ get()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE GUM_SCALAR gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::get ( const Instantiation i) const
virtual

Returns the value pointed by i.

Warning
If i variables set is disjoint with this MultiDimContainer then 0 is assumed for dimensions (i.e. variables) not present in the instantiation.
Parameters
iAn Instantiation of this MultiDimContainer.
Returns
Returns the value pointe by i.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 665 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StatesChecker::checkState(), and gum::StatesCounter::incState().

666  {
667  NodeId currentNodeId = __root;
668  InternalNode* currentNode = nullptr;
669  while (!isTerminalNode(currentNodeId)) {
670  currentNode = __internalNodeMap[currentNodeId];
671  currentNodeId = currentNode->son(inst.val(*(currentNode->nodeVar())));
672  }
673  return this->terminalNodeValue(currentNodeId);
674  }
bool isTerminalNode(const NodeId &node) const
Indicates if given node is terminal or not.
NodeId __root
The root node of the function graph.
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
Size NodeId
Type for node ids.
Definition: graphElements.h:97
+ Here is the caller graph for this function:

◆ getMasterRef() [1/2]

template<typename GUM_SCALAR >
INLINE MultiDimAdressable & gum::MultiDimContainer< GUM_SCALAR >::getMasterRef ( )
virtualinherited

In order to insure the dereference for decorators, we need to virtualize the access to master pointer.

Returns
Returns the ref to content as MultiDimAdressable&

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 298 of file multiDimContainer_tpl.h.

References gum::MultiDimContainer< GUM_SCALAR >::content().

298  {
299  return static_cast< MultiDimAdressable& >(*content());
300  }
virtual const MultiDimImplementation< GUM_SCALAR > * content() const =0
Returns the implementation for this object (may be *this).
MultiDimAdressable()
Default constructor.
+ Here is the call graph for this function:

◆ getMasterRef() [2/2]

template<typename GUM_SCALAR >
INLINE const MultiDimAdressable & gum::MultiDimContainer< GUM_SCALAR >::getMasterRef ( ) const
virtualinherited

In order to insure the dereference for decorators, we need to virtualize the access to master pointer.

Returns
Returns the master of this MultiDimAdressable.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 304 of file multiDimContainer_tpl.h.

References gum::MultiDimContainer< GUM_SCALAR >::content().

304  {
305  return static_cast< const MultiDimAdressable& >(*content());
306  }
virtual const MultiDimImplementation< GUM_SCALAR > * content() const =0
Returns the implementation for this object (may be *this).
MultiDimAdressable()
Default constructor.
+ Here is the call graph for this function:

◆ getReducedAndOrderedInstance()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance ( )
static

Returns a reduced and ordered instance.

Reduced and ordered instance will reduce the size of the graph whenever it's possible. An inherent order on the variable helps doing so. The order in which variables will be inserted with function add(const DiscreteVariable&) specify that order.

Returns
Returns a reduced and ordered instance.

Definition at line 638 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::__instantiateFunctionGraph(), gum::MultiDimFunctionGraphGenerator::generate(), gum::MDDOperatorStrategy< GUM_SCALAR >::getAggregatorInstance(), gum::MDDOperatorStrategy< GUM_SCALAR >::getFunctionInstance(), gum::MultiDimFunctionGraphProjector< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::MultiDimFunctionGraphProjector(), and gum::MDDOperatorStrategy< GUM_SCALAR >::regress().

638  {
639  return new MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >();
640  }
+ Here is the caller graph for this function:

◆ getTreeInstance()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getTreeInstance ( )
static

Returns an arborescent instance.

Returns
Returns an arborescent instance

Definition at line 645 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::TreeOperatorStrategy< GUM_SCALAR >::getFunctionInstance(), and gum::TreeOperator< GUM_SCALAR, COMBINEOPERATOR, TerminalNodePolicy >::TreeOperator().

645  {
646  return new MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >(false);
647  }
+ Here is the caller graph for this function:

◆ isInternalNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::isInternalNode ( const NodeId node) const

Indicates if given node is terminal or not.

Parameters
nodeThe node to test for being itnernal.
Returns
Returns true if node is internal.

Definition at line 572 of file multiDimFunctionGraph_tpl.h.

573  {
574  return this->__internalNodeMap.exists(node);
575  }
const InternalNode * node(NodeId n) const
Returns internalNode structure associated to that nodeId.
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.

◆ isReducedAndOrdered()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::isReducedAndOrdered ( ) const

Returns true if this MultiDimFunctionGraph is reduced and Ordered.

Returns
Returns true if this MultiDimFunctionGraph is reduced and Ordered.

Definition at line 629 of file multiDimFunctionGraph_tpl.h.

630  {
631  return __isReduced;
632  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.

◆ isTerminalNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::isTerminalNode ( const NodeId node) const

Indicates if given node is terminal or not.

Parameters
nodeThe node to test for terminality.
Returns
Returns true if node is terminal.

Definition at line 564 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StructuredPlaner< double >::__recurArgMaxCopy(), gum::StatesCounter::incState(), and gum::StatesCounter::isTerminal().

565  {
566  return this->existsTerminalNodeWithId(node);
567  }
const InternalNode * node(NodeId n) const
Returns internalNode structure associated to that nodeId.
+ Here is the caller graph for this function:

◆ manager()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager ( )

Returns a const reference to the manager of this diagram.

Returns
Returns a const reference to the manager of this diagram

Definition at line 540 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph(), gum::StatesCounter::__incState(), gum::IMDDI< AttributeSelection, isScalar >::__insertLeafInFunctionGraph(), gum::ITI< AttributeSelection, isScalar >::__insertNodeInFunctionGraph(), gum::StatesChecker::__insertState(), gum::ITI< AttributeSelection, isScalar >::__insertTerminalNode(), gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::IMDDI< AttributeSelection, isScalar >::__rebuildFunctionGraph(), gum::AdaptiveRMaxPlaner::__visitLearner(), gum::AdaptiveRMaxPlaner::_initVFunction(), gum::StructuredPlaner< double >::_makeArgMax(), gum::FMDPFactory< GUM_SCALAR >::addArc(), gum::FMDPFactory< GUM_SCALAR >::addInternalNode(), gum::FMDPFactory< GUM_SCALAR >::addTerminalNode(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::reset(), gum::StatesChecker::reset(), gum::FMDPFactory< GUM_SCALAR >::setRoot(), and gum::ITI< AttributeSelection, isScalar >::updateFunctionGraph().

540  {
541  if (__manager == nullptr) {
542  if (__isReduced)
543  __manager =
544  new MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >(
545  this);
546  else
547  __manager =
548  new MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >(
549  this);
550  }
551  return __manager;
552  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * __manager
A reference to the manager that edits this function graph.
+ Here is the caller graph for this function:

◆ model()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const NodeGraphPart & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::model ( ) const

Returns a const reference to the manager of this diagram.

Returns
Returns a const reference to the manager of this diagram

Definition at line 533 of file multiDimFunctionGraph_tpl.h.

533  {
534  return __model;
535  }
NodeGraphPart __model
Indicates available nodeIds.

◆ name()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const std::string & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::name ( ) const
virtual

Returns the real name of the multiDim implementation.

In aGrUM, all the types of multi-dimensional arrays/functionals have a name that describes what they are in reality. For instance, a table stored in extension is a "MultiDimArray", one that stores only non zero elements is a "MultiDimSparseArray", and so on. These names are unique for each type of implementation and is used by the system to determine which is the best functions to use, say, when we wish to use operators such as operator+ on two MultiDimImplementations.

Returns
Returns the real name of the multiDim implementation

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 90 of file multiDimFunctionGraph_tpl.h.

90  {
91  return __name;
92  }
std::string __name
The name of the data structure.

◆ nbrDim()

template<typename GUM_SCALAR >
INLINE Idx gum::MultiDimImplementation< GUM_SCALAR >::nbrDim ( ) const
overridevirtualinherited

◆ newFactory()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE MultiDimContainer< GUM_SCALAR > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::newFactory ( ) const
virtual

Creates an empty clone of this MultiDimContainer.

This method creates a clone of this object, withouth its content (including variable), you must use this method if you want to ensure that the generated object has the same type than the object containing the called newFactory() For example :

MultiDimArray<double> y;
MultiDimContainer<double>* x = y.newFactory();

Then x is a MultiDimArray<double>*.

Warning
You must free by yourself the returned pointer.
Returns
Returns an empty clone of this object with the same type.

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 79 of file multiDimFunctionGraph_tpl.h.

79  {
80  if (__isReduced)
83  else
84  return MultiDimFunctionGraph< GUM_SCALAR,
85  TerminalNodePolicy >::getTreeInstance();
86  }
bool __isReduced
Wheter the MultiDimFunctionGraphManager is reduced or not.
MultiDimFunctionGraph(bool isReduced=true)
Default constructor.
static MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * getTreeInstance()
Returns an arborescent instance.
static MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * getReducedAndOrderedInstance()
Returns a reduced and ordered instance.

◆ node()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const InternalNode * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::node ( NodeId  n) const

Returns internalNode structure associated to that nodeId.

Parameters
nThe node for which the internal structure is returned.
Returns
Returns internalNode structure associated to that nodeId
Exceptions
InvalidNodeRaised if node is terminal

Definition at line 591 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StatesCounter::__incState(), gum::StatesChecker::__insertState(), gum::StructuredPlaner< double >::__recurArgMaxCopy(), gum::StatesChecker::addState(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::incState(), gum::StatesCounter::nodeSon(), and gum::StatesCounter::nodeVar().

592  {
593  if (!isInternalNode(n))
594  GUM_ERROR(InvalidArgument,
595  "Id " << n << " is not bound to any terminal node")
596  return this->__internalNodeMap[n];
597  }
bool isInternalNode(const NodeId &node) const
Indicates if given node is terminal or not.
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the caller graph for this function:

◆ nodeValue()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const GUM_SCALAR & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::nodeValue ( NodeId  n) const

Returns value associated to given node.

Parameters
nThe node for which the value is returned.
Returns
Returns value associated to given node.
Exceptions
InvalidNodeRaised if node isn't terminal.

Definition at line 580 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StructuredPlaner< double >::__recurArgMaxCopy(), and gum::StatesCounter::nodeNbObservation().

581  {
582  if (!isTerminalNode(n))
583  GUM_ERROR(InvalidArgument,
584  "Id " << n << " is not bound to any terminal node")
585  return this->terminalNodeValue(n);
586  }
bool isTerminalNode(const NodeId &node) const
Indicates if given node is terminal or not.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the caller graph for this function:

◆ operator!=()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimContainer< GUM_SCALAR >::operator!= ( const MultiDimContainer< GUM_SCALAR > &  p) const
inherited

Test if this MultiDimContainer is different of p.

Parameters
pThe MultiDimContainer to test for inequality.
Returns
Returns true if this MultiDimContainer is different of p.

Definition at line 157 of file multiDimContainer_tpl.h.

References gum::MultiDimContainer< GUM_SCALAR >::operator==().

Referenced by gum::MultiDimContainer< GUM_SCALAR >::operator==().

157  {
158  return !operator==(p);
159  }
bool operator==(const MultiDimContainer< GUM_SCALAR > &p) const
Test if this MultiDimContainer is equal to p.
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ operator=()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::operator= ( const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &  from)

Copy Operator.

Parameters
fromThe MultiDimFunctionGraph to copy.
Returns
Returns this MultiDimFunctionGraph.

Definition at line 61 of file multiDimFunctionGraph_tpl.h.

62  {
63  copy(from);
64  return *this;
65  }
virtual void copy(const MultiDimContainer< GUM_SCALAR > &src)

◆ operator==()

template<typename GUM_SCALAR >
bool gum::MultiDimContainer< GUM_SCALAR >::operator== ( const MultiDimContainer< GUM_SCALAR > &  p) const
inherited

Test if this MultiDimContainer is equal to p.

Parameters
pThe MultiDimContainer to test for equality.
Returns
Returns true if this MultiDimContainer is equal to p.

Definition at line 126 of file multiDimContainer_tpl.h.

References gum::MultiDimInterface::domainSize(), gum::Instantiation::end(), gum::MultiDimContainer< GUM_SCALAR >::get(), gum::MultiDimInterface::nbrDim(), gum::MultiDimContainer< GUM_SCALAR >::operator!=(), gum::Instantiation::setFirst(), and gum::MultiDimInterface::variablesSequence().

Referenced by gum::MultiDimContainer< GUM_SCALAR >::operator!=(), and gum::MultiDimContainer< GUM_SCALAR >::toString().

126  {
127  if ((nbrDim() == p.nbrDim()) && (domainSize() == p.domainSize())) {
128  if (nbrDim() == 0) return true;
129 
131  var_iterator;
132 
133  for (var_iterator iter = variablesSequence().beginSafe();
134  iter != variablesSequence().endSafe();
135  ++iter) {
136  if (!p.variablesSequence().exists(*iter)) { return false; }
137  }
138  } else {
139  return false;
140  }
141 
142  Instantiation i(*this);
143 
144  AlmostDifferent< GUM_SCALAR > cmp;
145 
146  for (i.setFirst(); !i.end(); ++i) {
147  if (cmp(get(i), p.get(i))) { return false; }
148  }
149 
150  return true;
151  }
virtual Idx nbrDim() const =0
Returns the number of vars in the multidimensional container.
virtual Size domainSize() const =0
Returns the product of the variables domain size.
virtual const Sequence< const DiscreteVariable *> & variablesSequence() const =0
Returns a const ref to the sequence of DiscreteVariable*.
SequenceIteratorSafe< Key > const_iterator_safe
Types for STL compliance.
Definition: sequence.h:1035
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ operator[]()

template<typename GUM_SCALAR >
INLINE GUM_SCALAR gum::MultiDimContainer< GUM_SCALAR >::operator[] ( const Instantiation i) const
inherited

An [] operator using a Instantiation as argument.

Warning
If i variables set is disjoint with this MultiDimContainer then 0 is assumed for dimensions (i.e. variables) not prensent in the instantiation.
Parameters
iAn Instantiation.
Returns
Returns the adressed (GUM_SCALAR) value.

Definition at line 79 of file multiDimContainer_tpl.h.

Referenced by gum::MultiDimContainer< GUM_SCALAR >::~MultiDimContainer().

79  {
80  return get(i);
81  }
+ Here is the caller graph for this function:

◆ populate() [1/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::populate ( const std::vector< GUM_SCALAR > &  v) const
virtual
Warning
This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 115 of file multiDimFunctionGraph_tpl.h.

116  {
117  GUM_ERROR(OperationNotAllowed,
118  "Function Graph can't be edited so "
119  "easily.\nMultiDimFunctionGraphManager "
120  "provides the framework to editaa "
121  "Function Graph.")
122  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ populate() [2/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::populate ( std::initializer_list< GUM_SCALAR >  v) const
virtual
Warning
This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 124 of file multiDimFunctionGraph_tpl.h.

125  {
126  GUM_ERROR(OperationNotAllowed,
127  "Function Graph can't be edited so "
128  "easily.\nMultiDimFunctionGraphManager "
129  "provides the framework to edit a "
130  "Function Graph.")
131  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ pos()

template<typename GUM_SCALAR >
INLINE Idx gum::MultiDimImplementation< GUM_SCALAR >::pos ( const DiscreteVariable v) const
overridevirtualinherited

Returns the index of a variable.

Parameters
vThe variable for which the index is returned.
Returns
Returns the index of a variable.
Exceptions
NotFoundRaised if v is not in this multidimensional matrix.

Implements gum::MultiDimInterface.

Definition at line 200 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimWithOffset< GUM_SCALAR >::erase(), gum::MultiDimArray< GUM_SCALAR >::erase(), and gum::MultiDimImplementation< std::string >::pos().

200  {
201  return __vars.pos(&v);
202  }
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).
+ Here is the caller graph for this function:

◆ realSize()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE Size gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::realSize ( ) const
virtual

Returns the real number of parameters used for this table.

This function is used by the MultiDimImplementation::compressionRate() method.

See also
MultiDimImplementation::compressionRate()
Returns
Returns the real number of parameters used for this table.

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 160 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StructuredPlaner< double >::vFunctionSize().

160  {
161  return __internalNodeMap.size(); // + __valueMap.size();
162  }
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
+ Here is the caller graph for this function:

◆ reduce()

template<typename GUM_SCALAR >
GUM_SCALAR gum::MultiDimContainer< GUM_SCALAR >::reduce ( std::function< GUM_SCALAR(GUM_SCALAR, GUM_SCALAR) >  f,
GUM_SCALAR  base 
) const
virtualinherited

compute lfold for this container

Parameters
fthe function to apply
basethe initial value

Reimplemented in gum::MultiDimDecorator< GUM_SCALAR >, and gum::MultiDimArray< GUM_SCALAR >.

Definition at line 202 of file multiDimContainer_tpl.h.

References gum::Instantiation::end(), and gum::Instantiation::setFirst().

204  {
205  GUM_SCALAR tmp = base;
206  Instantiation i(*this);
207  for (i.setFirst(); !i.end(); ++i) {
208  tmp = f(tmp, get(i));
209  }
210  return tmp;
211  }
+ Here is the call graph for this function:

◆ registerSlave()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimImplementation< GUM_SCALAR >::registerSlave ( Instantiation i)
overridevirtualinherited

Register i as a slave of this MultiDimAdressable.

Parameters
iThe Instantiation to enslave.
Returns
Returns true if i becomes a slave of this MultiDimAdressable.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >, and gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 144 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::registerSlave().

144  {
145  // check that the Instantiation has the same variables as this
146  if (slave.nbrDim() != __vars.size()) return false;
147 
149  __vars.beginSafe();
150  iter != __vars.endSafe();
151  ++iter)
152  if (!slave.contains(*iter)) return false;
153 
154  slave.synchronizeWithMaster(this);
155 
156  __slaveInstantiations += (&slave);
157 
158  return true;
159  }
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).
List< Instantiation *> __slaveInstantiations
List of instantiations of the tuples (sequences) of variables.
SequenceIteratorSafe< Key > iterator_safe
Types for STL compliance.
Definition: sequence.h:1034
+ Here is the caller graph for this function:

◆ replace()

INLINE void gum::MultiDimInterface::replace ( const DiscreteVariable x,
const DiscreteVariable y 
)
inherited

Replace variables in this multidim.

If x is in this MultiDim and y has the same domain size, then x will be replace by y in this MultiDim.

Parameters
xThe variable in this which will be replaced.
yThe variable replacing y.
Exceptions
NotFoundRaised if x does not belong to this MultiDim.
OperationNotAllowedIf y and x are not interchangeable.
DuplicateElementIf y is already in this MultiDim.

Definition at line 33 of file multiDimInterface_inl.h.

References gum::MultiDimInterface::_replace(), gum::MultiDimInterface::contains(), gum::DiscreteVariable::domainSize(), and GUM_ERROR.

Referenced by gum::MultiDimImplementation< std::string >::_replace(), gum::MultiDimBucket< GUM_SCALAR >::_replace(), and gum::MultiDimInterface::~MultiDimInterface().

34  {
35  if (!contains(x)) { GUM_ERROR(NotFound, "could not find the variable"); }
36 
37  if (contains(y)) {
38  GUM_ERROR(DuplicateElement, "variable " << y << " already in MultiDim");
39  }
40 
41  if (x.domainSize() != y.domainSize()) {
42  GUM_ERROR(OperationNotAllowed, "incompatible variables");
43  }
44 
45  _replace(&x, &y);
46  }
virtual bool contains(const DiscreteVariable &v) const =0
Returns true if var is in *this.
virtual void _replace(const DiscreteVariable *x, const DiscreteVariable *y)=0
This is called by MultiDimContainer::replace() to proceed with the replacing between x and y...
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ root()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const NodeId & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::root ( ) const

Returns the id of the root node from the diagram.

Returns
Returns the id of the root node from the diagram

Definition at line 557 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::StructuredPlaner< double >::_makeArgMax(), gum::StatesChecker::addState(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::incState(), and gum::StatesCounter::root().

557  {
558  return __root;
559  }
NodeId __root
The root node of the function graph.
+ Here is the caller graph for this function:

◆ set()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::set ( const Instantiation i,
const GUM_SCALAR &  value 
) const
virtual
Warning
This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 95 of file multiDimFunctionGraph_tpl.h.

96  {
97  GUM_ERROR(OperationNotAllowed,
98  "Function Graph can't be edited so "
99  "easily.\nMultiDimFunctionGraphManager "
100  "provides the framework to edit a "
101  "Function Graph.")
102  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ setChangeNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setChangeNotification ( const Instantiation i)
virtual

Listen to an assignment of a value in a Instantiation.

Parameters
iThe Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 195 of file multiDimFunctionGraph_tpl.h.

195 {}

◆ setDecNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setDecNotification ( const Instantiation i)
virtual

Listen to increment in each recorded Instantiation.

Parameters
iThe Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 190 of file multiDimFunctionGraph_tpl.h.

191  {}

◆ setFirstNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setFirstNotification ( const Instantiation i)
virtual

Listen to setFirst in a given Instantiation.

Parameters
iThe Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 175 of file multiDimFunctionGraph_tpl.h.

176  {}

◆ setIncNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setIncNotification ( const Instantiation i)
virtual

Listen to increment in a given Instantiation.

Parameters
iThe Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 185 of file multiDimFunctionGraph_tpl.h.

186  {}

◆ setLastNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setLastNotification ( const Instantiation i)
virtual

Listen to setLast in a given Instantiation.

Parameters
iThe Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 180 of file multiDimFunctionGraph_tpl.h.

181  {}

◆ setTableName()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setTableName ( const std::string &  name)

Sets the name of the table represented by this structure.

Parameters
namethe new name of this structure.

Definition at line 621 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::addReward(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize().

622  {
623  __tableName = name;
624  }
virtual const std::string & name() const
Returns the real name of the multiDim implementation.
std::string __tableName
The name of the data structure.
+ Here is the caller graph for this function:

◆ tableName()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const std::string & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::tableName ( ) const

Returns the name of the table represented by this structure.

Returns
Returns the name of the table represented by this structure.

Definition at line 614 of file multiDimFunctionGraph_tpl.h.

614  {
615  return __tableName;
616  }
std::string __tableName
The name of the data structure.

◆ toDot()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::toDot ( bool  withBackArcs = false) const

Returns a const reference to the manager of this diagram.

Parameters
withBackArcsIf true, back arcs will be added.
Returns
Returns a const reference to the manager of this diagram

Definition at line 455 of file multiDimFunctionGraph_tpl.h.

456  {
457  std::stringstream output;
458  std::stringstream terminalStream;
459  std::stringstream nonTerminalStream;
460  std::stringstream arcstream;
461  // std::stringstream defaultarcstream;
462  output << std::endl << "digraph \" " << __tableName << "\" {" << std::endl;
463 
464  terminalStream << "node [shape = box];" << std::endl;
465  nonTerminalStream << "node [shape = ellipse];" << std::endl;
466  std::string tab = " ";
467 
468  for (NodeGraphPart::NodeIterator nodeIter = __model.begin();
469  nodeIter != __model.end();
470  ++nodeIter)
471  if (*nodeIter != 0) {
472  if (this->isTerminalNode((NodeId)*nodeIter))
473  terminalStream << tab << *nodeIter << ";" << tab << *nodeIter
474  << " [label=\"" << *nodeIter << " - "
475  << std::setprecision(30)
476  << this->terminalNodeValue(*nodeIter) << "\"]"
477  << ";" << std::endl;
478  else {
479  InternalNode* currentNode = __internalNodeMap[*nodeIter];
480  nonTerminalStream << tab << *nodeIter << ";" << tab << *nodeIter
481  << " [label=\"" << *nodeIter << " - "
482  << currentNode->nodeVar()->name() << "\"]"
483  << ";" << std::endl;
484 
485  // if (_arcMap[*nodeIter] != NULL)
486  HashTable< NodeId, LinkedList< Idx >* > sonMap;
487  for (Idx sonIter = 0; sonIter < currentNode->nbSons(); ++sonIter) {
488  if (!sonMap.exists(currentNode->son(sonIter)))
489  sonMap.insert(currentNode->son(sonIter), new LinkedList< Idx >());
490  sonMap[currentNode->son(sonIter)]->addLink(sonIter);
491  }
492 
493  for (auto sonIter = sonMap.beginSafe(); sonIter != sonMap.endSafe();
494  ++sonIter) {
495  arcstream << tab << *nodeIter << " -> " << sonIter.key()
496  << " [label=\" ";
497  Link< Idx >* modaIter = sonIter.val()->list();
498  while (modaIter) {
499  arcstream << currentNode->nodeVar()->label(modaIter->element())
500  << ", ";
501  modaIter = modaIter->nextLink();
502  }
503  arcstream << "\",color=\"#0000ff\"]"
504  << ";" << std::endl;
505  delete sonIter.val();
506  }
507 
508  if (withBackArcs) {
509  Link< Parent >* parentIter = currentNode->parents();
510  while (parentIter != nullptr) {
511  arcstream << tab << *nodeIter << " -> "
512  << parentIter->element().parentId << " [label=\""
513  << parentIter->element().modality
514  << "\",color=\"#ff0000\"]"
515  << ";" << std::endl;
516  parentIter = parentIter->nextLink();
517  }
518  }
519  }
520  }
521 
522  output << terminalStream.str() << std::endl
523  << nonTerminalStream.str() << std::endl
524  << arcstream.str() << std::endl
525  << "}" << std::endl;
526 
527  return output.str();
528  }
bool isTerminalNode(const NodeId &node) const
Indicates if given node is terminal or not.
NodeGraphPart __model
Indicates available nodeIds.
node_iterator begin() const noexcept
a begin iterator to parse the set of nodes contained in the NodeGraphPart
NodeGraphPartIterator NodeIterator
HashTable< NodeId, InternalNode *> __internalNodeMap
Associates each non-terminal node to a variable.
std::string __tableName
The name of the data structure.
const node_iterator & end() const noexcept
the end iterator to parse the set of nodes contained in the NodeGraphPart
Size NodeId
Type for node ids.
Definition: graphElements.h:97

◆ toString() [1/2]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::toString ( const Instantiation i) const
virtual

Display the internal representation of i.

Returns
Returns an internal representation of i.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 199 of file multiDimFunctionGraph_tpl.h.

200  {
201  std::stringstream sBuff;
202  sBuff << (*i) << " = " << this->get(*i);
203  return sBuff.str();
204  }

◆ toString() [2/2]

template<typename GUM_SCALAR >
const std::string gum::MultiDimContainer< GUM_SCALAR >::toString ( ) const
virtualinherited

Returns a representation of this MultiDimContainer.

Returns
Returns a representation of this MultiDimContainer.

Reimplemented in gum::Potential< GUM_SCALAR >, gum::MultiDimDecorator< GUM_SCALAR >, gum::aggregator::MultiDimAggregator< GUM_SCALAR >, gum::MultiDimNoisyAND< GUM_SCALAR >, gum::MultiDimNoisyORCompound< GUM_SCALAR >, gum::MultiDimNoisyORNet< GUM_SCALAR >, gum::MultiDimLogit< GUM_SCALAR >, and gum::MultiDimICIModel< GUM_SCALAR >.

Definition at line 102 of file multiDimContainer_tpl.h.

References gum::Instantiation::end(), gum::MultiDimInterface::nbrDim(), gum::MultiDimContainer< GUM_SCALAR >::operator==(), and gum::Instantiation::setFirst().

Referenced by gum::operator<<().

102  {
103  // we create a new instantiation and iterate over it to display the whole
104  // content of the array
105  if (this->nbrDim() == 0) { return "[]"; }
106 
107  std::stringstream ss;
108  Instantiation inst(const_cast< MultiDimContainer* >(this));
109 
110  bool first = true;
111 
112  for (inst.setFirst(); !inst.end(); ++inst) {
113  if (!first) { ss << " /"; }
114  first = false;
115 
116  ss << inst << " :: " << get(inst);
117  }
118 
119  return ss.str();
120  }
virtual Idx nbrDim() const =0
Returns the number of vars in the multidimensional container.
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ unregisterSlave()

template<typename GUM_SCALAR >
INLINE bool gum::MultiDimImplementation< GUM_SCALAR >::unregisterSlave ( Instantiation i)
overridevirtualinherited

Unregister i as a slave of this MultiDimAdressable.

Parameters
iThe Instantiation to free.
Returns
Returns true, whatever happens.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >, and gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 165 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimWithOffset< GUM_SCALAR >::unregisterSlave(), and gum::MultiDimBucket< GUM_SCALAR >::unregisterSlave().

165  {
166  __slaveInstantiations.eraseByVal(&slave);
167  // TODO This method should return true? Why not use a void instead?
168  return true;
169  }
List< Instantiation *> __slaveInstantiations
List of instantiations of the tuples (sequences) of variables.
+ Here is the caller graph for this function:

◆ variable() [1/2]

template<typename GUM_SCALAR >
INLINE const DiscreteVariable & gum::MultiDimImplementation< GUM_SCALAR >::variable ( Idx  i) const
overridevirtualinherited

Returns a const ref to the ith var.

param i An index of this multidimensional matrix.

Returns
Returns a const ref to the ith var.
Exceptions
NotFoundRaised if i does not reference a variable in this multidimensional matrix.

Implements gum::MultiDimInterface.

Definition at line 183 of file multiDimImplementation_tpl.h.

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue(), gum::MultiDimWithOffset< GUM_SCALAR >::_computeInstantiationValue(), gum::MultiDimICIModel< GUM_SCALAR >::copyFrom(), gum::MultiDimLogit< GUM_SCALAR >::get(), gum::MultiDimNoisyORNet< GUM_SCALAR >::get(), gum::MultiDimNoisyORCompound< GUM_SCALAR >::get(), gum::MultiDimNoisyAND< GUM_SCALAR >::get(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::get(), gum::MultiDimICIModel< GUM_SCALAR >::toString(), gum::MultiDimLogit< GUM_SCALAR >::toString(), and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString().

183  {
184  return *(__vars.atPos(i));
185  }
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).
+ Here is the caller graph for this function:

◆ variable() [2/2]

template<typename GUM_SCALAR >
INLINE const DiscreteVariable & gum::MultiDimImplementation< GUM_SCALAR >::variable ( const std::string &  name) const
overridevirtualinherited

Returns the variable with the name.

Parameters
nameThe index of the variable
Returns
Returns the variable qith the name in the tuple. This function is not O(1)
Exceptions
NotFoundRaised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 188 of file multiDimImplementation_tpl.h.

189  {
190  for (const auto& v : __vars) {
191  if (v->name() == name) return *v;
192  }
193 
194  GUM_ERROR(NotFound,
195  "'" << name << "' can not be found in the multidim structure.")
196  }
Sequence< const DiscreteVariable *> __vars
List of discrete variables (dimensions).
virtual const std::string & name() const =0
Returns the real name of the multiDim implementation.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52

◆ variablesSequence()

template<typename GUM_SCALAR >
INLINE const Sequence< const DiscreteVariable *> & gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence ( ) const
overridevirtualinherited

◆ varNodeListe()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>
INLINE const LinkedList< NodeId > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::varNodeListe ( const DiscreteVariable var) const

Returns the list of node associated to given variable.

Parameters
varThe variable for which the list of associated nodes is returned.
Returns
Returns the list of node associated to given variable

Definition at line 602 of file multiDimFunctionGraph_tpl.h.

Referenced by gum::MultiDimFunctionGraphGenerator::generate().

603  {
604  if (!this->variablesSequence().exists(var))
605  GUM_ERROR(InvalidArgument,
606  "Var " << var->name()
607  << " has not been inserted in the function graph")
608  return __var2NodeIdMap[var];
609  }
HashTable< const DiscreteVariable *, LinkedList< NodeId > *> __var2NodeIdMap
Mapping between var and node.
virtual const Sequence< const DiscreteVariable *> & variablesSequence() const override
Returns a const ref to the sequence of DiscreteVariable*.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:52
+ Here is the caller graph for this function:

Member Data Documentation

◆ __internalNodeMap

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
HashTable< NodeId, InternalNode* > gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__internalNodeMap
private

Associates each non-terminal node to a variable.

Definition at line 386 of file multiDimFunctionGraph.h.

◆ __isReduced

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__isReduced
private

Wheter the MultiDimFunctionGraphManager is reduced or not.

Definition at line 392 of file multiDimFunctionGraph.h.

◆ __manager

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >* gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__manager
private

A reference to the manager that edits this function graph.

Definition at line 380 of file multiDimFunctionGraph.h.

◆ __model

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
NodeGraphPart gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__model
private

Indicates available nodeIds.

Definition at line 377 of file multiDimFunctionGraph.h.

◆ __name

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__name
private

The name of the data structure.

Definition at line 371 of file multiDimFunctionGraph.h.

◆ __root

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
NodeId gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__root
private

The root node of the function graph.

Definition at line 383 of file multiDimFunctionGraph.h.

◆ __tableName

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__tableName
private

The name of the data structure.

Definition at line 374 of file multiDimFunctionGraph.h.

◆ __var2NodeIdMap

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
HashTable< const DiscreteVariable*, LinkedList< NodeId >* > gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__var2NodeIdMap
private

Mapping between var and node.

Definition at line 389 of file multiDimFunctionGraph.h.

◆ defaultValue

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
const GUM_SCALAR gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::defaultValue
static

Only for proper initialization of a certain returned value.

Definition at line 83 of file multiDimFunctionGraph.h.


The documentation for this class was generated from the following files: