gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > Class Template Reference

Class implementingting a function graph. More...

#include <multiDimFunctionGraph.h>

Inheritance diagram for gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >:

Collaboration diagram for gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >:

Public Member Functions
Unallowed inherited methods
void	set (const Instantiation &i, const GUM_ELEMENT &value) const override
void	fill (const GUM_ELEMENT &d) const override
void	populate (const std::vector< GUM_ELEMENT > &v) const override
void	populate (std::initializer_list< GUM_ELEMENT > v) const override
void	copyFrom (const MultiDimContainer< GUM_ELEMENT > &src, Instantiation *p_i=(Instantiation *) 0) const override
void	copy (const MultiDimContainer< GUM_ELEMENT > &src) override
Inherited methods
MultiDimContainer< GUM_ELEMENT > *	newFactory () const override
	Creates an empty clone of this MultiDimContainer.
GUM_ELEMENT	get (const Instantiation &i) const override
	Returns the value pointed by i.
const std::string &	name () const override
	Returns the real name of the multiDim implementation.
void	add (const DiscreteVariable &v) override
	Adds a new var to the variables of the multidimensional matrix.
void	erase (const DiscreteVariable &v) override
	Removes a var from the variables of the multidimensional matrix.
Size	realSize () const override
	Returns the real number of parameters used for this table.
void	changeNotification (const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval) override
	Listen to changes in a given Instantiation.
void	setFirstNotification (const Instantiation &i) override
	Listen to setFirst in a given Instantiation.
void	setLastNotification (const Instantiation &i) override
	Listen to setLast in a given Instantiation.
void	setIncNotification (const Instantiation &i) override
	Listen to increment in a given Instantiation.
void	setDecNotification (const Instantiation &i) override
	Listen to increment in each recorded Instantiation.
void	setChangeNotification (const Instantiation &i) override
	Listen to an assignment of a value in a Instantiation.
std::string	toString (const Instantiation *i) const override
	Display the internal representation of i.
Copy methods.
void	copy (const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &src)
	Removes all variables in this MultiDimFunctionGraph and copy the content of src, variables included.
void	copyAndReassign (const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &src, const Bijection< const DiscreteVariable *, const DiscreteVariable * > &reassign)
	Copies src diagrams structure into this diagrams.
void	copyAndMultiplyByScalar (const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &src, GUM_ELEMENT gamma)
	Copies src diagrams and multiply every value by the given scalar.
void	clear ()
	Clears the function graph.
Accessors / Modifiers
const std::string &	basename () const
	Returns the base class name of this MultiDimImplementation.
float	compressionRate () const
	The compression ratio of the table (depending on the type of implementation).
virtual const GUM_ELEMENT *	data () const noexcept
	Returns a pointer to the contiguous data buffer, or nullptr if the implementation does not store data contiguously.
virtual GUM_ELEMENT *	data () noexcept
	Returns a mutable pointer to the contiguous data buffer, or nullptr if the implementation does not store data contiguously.
MultiDimInterface implementation
Idx	nbrDim () const override
	Returns the number of vars in the multidimensional container.
Size	domainSize () const override
	Returns the product of the variables domain size.
const Sequence< const DiscreteVariable * > &	variablesSequence () const override
	Returns a const ref to the sequence of DiscreteVariable*.
const DiscreteVariable &	variable (Idx i) const override
	Returns a const ref to the ith var.
const DiscreteVariable &	variable (std::string_view name) const override
	Returns the variable with the name.
Idx	pos (const DiscreteVariable &v) const override
	Returns the index of a variable.
bool	contains (const DiscreteVariable &v) const override
	Returns true if var is in *this.
bool	empty () const override
	Returns true if no var is in *this.
MultiDimAdressable implementation
bool	registerSlave (Instantiation &slave) override
	Register i as a slave of this MultiDimAdressable.
bool	unregisterSlave (Instantiation &slave) override
	Unregister i as a slave of this MultiDimAdressable.
MultiDimContainer implementation
void	beginMultipleChanges () override
	Call this method before doing important changes in this MultiDimContainer.
void	endMultipleChanges () override
	Call this method after doing important changes in this MultiDimContainer.
void	endMultipleChanges (const GUM_ELEMENT &) override
	Call this method after doing important changes in this MultiDimContainer.
Accessors / Modifiers
GUM_ELEMENT	operator[] (const Instantiation &i) const
	An [] operator using a Instantiation as argument.
Copy methods.
virtual void	copyFrom (const MultiDimContainer< GUM_ELEMENT > &src) const
	Basic copy of a MultiDimContainer.
virtual void	extractFrom (const MultiDimContainer< GUM_ELEMENT > &src, const Instantiation &mask)
	Basic extraction of a MultiDimContainer.
MultiDimAdressable &	getMasterRef () override
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer.
const MultiDimAdressable &	getMasterRef () const override
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer.
Various methods.
virtual std::string	toString () const
	Returns a representation of this MultiDimContainer.
bool	operator== (const MultiDimContainer< GUM_ELEMENT > &p) const
	Test if this MultiDimContainer is equal to p.
virtual void	apply (std::function< GUM_ELEMENT(GUM_ELEMENT) > f) const
	Apply a function on every element of the container.
virtual GUM_ELEMENT	reduce (std::function< GUM_ELEMENT(GUM_ELEMENT, GUM_ELEMENT) > f, GUM_ELEMENT base) const
	compute lfold for this container
Accessors / Modifiers
void	replace (const DiscreteVariable &x, const DiscreteVariable &y)
	Replace variables in this multidim.
Terminal Node Creation and Destruction
void	addTerminalNode (const NodeId &n, const GUM_ELEMENT &v) override
	Insert a new terminal node with given value.
void	eraseTerminalNode (const NodeId &n) override
	Remove node matching given id.
void	clearAllTerminalNodes () override
	Erase all terminal nodes.
Terminal Nodes Existence
bool	existsTerminalNodeWithId (const NodeId &n) const override
	Returns true if a terminal node matching this id exists.
bool	existsTerminalNodeWithValue (const GUM_ELEMENT &v) const override
	Returns true if a terminal node matching this value exists.
Terminal Nodes value and id access
const GUM_ELEMENT &	terminalNodeValue (const NodeId &n) const override
	Returns the value of the terminal node that has the given id.
const NodeId &	terminalNodeId (const GUM_ELEMENT &v) const override
	Returns the id of the terminal node that has the given value.
Iterator on Terminal Nodes
void	beginValues () const override
	Initializes the constant safe iterator on terminal nodes.
bool	hasValue () const override
	Indicates if constant safe iterator has reach end of terminal nodes list.
void	nextValue () const override
	Increments the constant safe iterator.
const GUM_ELEMENT &	value () const override
	Returns the value of the current terminal nodes pointed by the constant safe iterator.
const NodeId &	id () const override
	Returns the id of the current terminal nodes pointed by the constant safe iterator.

Static Public Attributes
static const GUM_ELEMENT	defaultValue
	Only for proper initialization of a certain returned value.

Protected Member Functions
void	replace_ (const DiscreteVariable *x, const DiscreteVariable *y) override
GUM_ELEMENT &	get_ (const Instantiation &inst) const override
const MultiDimImplementation< GUM_ELEMENT > *	content () const final
	Returns the implementation for this object (may be *this).
MultiDimImplementation< GUM_ELEMENT > *	content () final
	Returns the implementation for this object (may be *this).
Fast large modifications in structures
virtual void	commitMultipleChanges_ ()
	Synchronize content after MultipleChanges.
virtual void	commitMultipleChanges_ (const GUM_ELEMENT &value)
	Synchronize content after MultipleChanges.
bool	isInMultipleChangeMethod_ () const
	Get the actual change method of this MultiDimImplementation.
bool	isCommitNeeded_ () const
	Get the actual state of *this.
const List< Instantiation * > &	slaves_ () const
	Returns a constant reference over the list of slaved instantiations.
virtual void	invert_ (Idx p1, Idx p2)
	Inverts variables at position p1 and p2.

Private Types
enum class	_InternalChangeMethod_ : char { DIRECT_CHANGE , MULTIPLE_CHANGE }
	Used to represent in which change method this MultiDimImplementation is. More...
enum class	_InternalChangeState_ : char { NO_CHANGE , NOT_COMMITTED_CHANGE }
	Used to represent in which change state this MultiDimImplementation is. More...

Private Member Functions
void	_setNotCommitedChange_ ()
	Change the internalChangeState to NOT_COMMITTED_CHANGE.

Private Attributes
std::string	_name_
	The name of the data structure.
std::string	_tableName_
	The name of the data structure.
NodeGraphPart	_model_
	Indicates available nodeIds.
MultiDimFunctionGraphManager< GUM_ELEMENT, TerminalNodePolicy > *	_manager_
	A reference to the manager that edits this function graph.
NodeId	_root_
	The root node of the function graph.
HashTable< NodeId, InternalNode * >	_internalNodeMap_
	Associates each non-terminal node to a variable.
HashTable< const DiscreteVariable *, LinkedList< NodeId > * >	_var2NodeIdMap_
	Mapping between var and node.
bool	_isReduced_
	Wheter the MultiDimFunctionGraphManager is reduced or not.
Sequence< const DiscreteVariable * >	_vars_
	List of discrete variables (dimensions).
List< Instantiation * >	_slaveInstantiations_
	List of instantiations of the tuples (sequences) of variables.
_InternalChangeMethod_	_internalChangeMethod_
	The current change method.
_InternalChangeState_	_internalChangeState_
	The current change state.
Size	_domainSize_
	This MultiDimImplementation domain size.
Bijection< NodeId, GUM_ELEMENT >	_map_
BijectionIteratorSafe< NodeId, GUM_ELEMENT >	_mappy_

Constructors, destructor and copy
	MultiDimFunctionGraph (bool isReduced=true)
	Default constructor.
	MultiDimFunctionGraph (const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &from)
	Copy constructor.
MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &	operator= (const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &from)
	Copy Operator.
	~MultiDimFunctionGraph () override
	Class destructor.

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

Detailed Description

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
class gum::MultiDimFunctionGraph< GUM_ELEMENT, 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.

#include <agrum/base/multidim/implementations/multiDimFunctionGraph.h>

Template Parameters

GUM_ELEMENT	The type of scalars stored in this multidimensional table.
TerminalNodePolicy	The terminal node policy to use in this MultiDimFunctionGraph.

Definition at line 90 of file multiDimFunctionGraph.h.

Member Enumeration Documentation

_InternalChangeMethod_

template<typename GUM_ELEMENT>

enum class gum::MultiDimImplementation::_InternalChangeMethod_ : char

strongprivateinherited

Used to represent in which change method this MultiDimImplementation is.

Enumerator
DIRECT_CHANGE
MULTIPLE_CHANGE

Definition at line 317 of file multiDimImplementation.h.

: char { DIRECT_CHANGE, MULTIPLE_CHANGE };

_InternalChangeState_

template<typename GUM_ELEMENT>

enum class gum::MultiDimImplementation::_InternalChangeState_ : char

strongprivateinherited

Used to represent in which change state this MultiDimImplementation is.

Enumerator
NO_CHANGE
NOT_COMMITTED_CHANGE

Definition at line 320 of file multiDimImplementation.h.

: char { NO_CHANGE, NOT_COMMITTED_CHANGE };

Constructor & Destructor Documentation

MultiDimFunctionGraph() [1/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::MultiDimFunctionGraph ( bool isReduced = true )

private

Default constructor.

Parameters

isReduced

If true, then this MultiDimFunctionGraph is reduced.

Definition at line 58 of file multiDimFunctionGraph_tpl.h.

                                                                                                :
      MultiDimImplementation< GUM_ELEMENT >(), _name_("MultiDimFunctionGraph"),
      _tableName_("NO NAME"), _model_(500, true), _manager_(nullptr), _root_(0),
      _internalNodeMap_(500, true, false), _var2NodeIdMap_(500, true, false),
      _isReduced_(isReduced) {
    GUM_CONSTRUCTOR(MultiDimFunctionGraph);
    _manager_ = nullptr;
    // Pop up a first node so that id 0 is unavailable
    _model_.addNode();
  }

References MultiDimFunctionGraph(), gum::MultiDimImplementation< GUM_ELEMENT >::MultiDimImplementation(), _internalNodeMap_, _isReduced_, _manager_, _model_, _name_, _root_, _tableName_, and _var2NodeIdMap_.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), and ~MultiDimFunctionGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

MultiDimFunctionGraph() [2/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::MultiDimFunctionGraph

(

const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &

from

)

Copy constructor.

Parameters

from	The MultiDimFunctionGraph to copy.

Definition at line 71 of file multiDimFunctionGraph_tpl.h.

                                                                            :
      MultiDimImplementation< GUM_ELEMENT >(), _name_("MultiDimFunctionGraph"),
      _tableName_("No NAME"), _model_(500, true), _manager_(nullptr), _root_(0),
      _internalNodeMap_(500, true, false), _var2NodeIdMap_(500, true, false),
      _isReduced_(from.isReducedAndOrdered()) {
    GUM_CONS_CPY(MultiDimFunctionGraph);
    copy(from);
  }

References MultiDimFunctionGraph(), gum::MultiDimImplementation< GUM_ELEMENT >::MultiDimImplementation(), _internalNodeMap_, _isReduced_, _manager_, _model_, _name_, _root_, _tableName_, _var2NodeIdMap_, copy(), and isReducedAndOrdered().

Here is the call graph for this function:

~MultiDimFunctionGraph()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::~MultiDimFunctionGraph ( )

override

Class destructor.

Definition at line 92 of file multiDimFunctionGraph_tpl.h.

                                                                                   {
    // Manager deletion
    GUM_DESTRUCTOR(MultiDimFunctionGraph);
    if (_manager_ != nullptr) delete _manager_;
    this->clear();
  }

References MultiDimFunctionGraph(), _manager_, and clear().

Here is the call graph for this function:

Member Function Documentation

_setNotCommitedChange_()

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::_setNotCommitedChange_ ( )

privateinherited

Change the internalChangeState to NOT_COMMITTED_CHANGE.

Definition at line 286 of file multiDimImplementation_tpl.h.

                                                                     {
    _internalChangeState_ = _InternalChangeState_::NOT_COMMITTED_CHANGE;
  }

References _internalChangeState_, and NOT_COMMITTED_CHANGE.

add()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::add ( const DiscreteVariable & v )

overridevirtual

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

v	The new var.

Exceptions

DuplicateElement	Raised if the variable already belongs to the sequence of variables.
OperationNotAllowed	Raised if this object is non mutable.

Implements gum::MultiDimInterface.

Definition at line 164 of file multiDimFunctionGraph_tpl.h.

                                                                                              {
    if (!this->variablesSequence().exists(&v)) MultiDimImplementation< GUM_ELEMENT >::add(v);
 
    if (!this->_var2NodeIdMap_.exists(&v)) _var2NodeIdMap_.insert(&v, new LinkedList< NodeId >());
  }

References _var2NodeIdMap_, gum::MultiDimImplementation< GUM_ELEMENT >::add(), and gum::MultiDimImplementation< GUM_ELEMENT >::variablesSequence().

Referenced by gum::MultiDimFunctionGraphGenerator::generate(), gum::IMDDI< AttributeSelection, isScalar >::insertSetOfVars(), gum::IncrementalGraphLearner< AttributeSelection, isScalar >::insertSetOfVars(), gum::StatesCounter::insertSetOfVars(), gum::ITI< AttributeSelection, isScalar >::insertSetOfVars_(), and gum::StructuredPlaner< GUM_ELEMENT >::makeArgMax_().

Here is the call graph for this function:

Here is the caller graph for this function:

addTerminalNode()

template<typename GUM_ELEMENT>

void gum::ExactTerminalNodePolicy< GUM_ELEMENT >::addTerminalNode ( const NodeId & n, const GUM_ELEMENT & v )

overridevirtualinherited

Insert a new terminal node with given value.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 49 of file ExactTerminalNodePolicy_tpl.h.

                                                                                     {
    _map_.insert(n, v);
  }

References _map_.

apply()

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::apply ( std::function< GUM_ELEMENT(GUM_ELEMENT) > f ) const

virtualinherited

Apply a function on every element of the container.

Parameters

f	the function to apply

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

Definition at line 200 of file multiDimContainer_tpl.h.

                                                                                              {
    Instantiation i(*this);
    for (i.setFirst(); !i.end(); ++i) {
      set(i, f(get(i)));
    }
  }

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

Here is the call graph for this function:

basename()

template<typename GUM_ELEMENT>

const std::string & gum::MultiDimImplementation< GUM_ELEMENT >::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 298 of file multiDimImplementation_tpl.h.

                                                                         {
    static const std::string str = "MultiDimImplementation";
    return str;
  }

beginMultipleChanges()

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::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_ELEMENT >.

Definition at line 232 of file multiDimImplementation_tpl.h.

                                                                   {
    _internalChangeMethod_ = _InternalChangeMethod_::MULTIPLE_CHANGE;
  }

References _internalChangeMethod_, and MULTIPLE_CHANGE.

beginValues()

template<typename GUM_ELEMENT>

void gum::ExactTerminalNodePolicy< GUM_ELEMENT >::beginValues ( ) const

overridevirtualinherited

Initializes the constant safe iterator on terminal nodes.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 87 of file ExactTerminalNodePolicy_tpl.h.

                                                                 {
    _mappy_ = _map_.beginSafe();
  }

References _map_, and _mappy_.

changeNotification()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::changeNotification ( const Instantiation & i, const DiscreteVariable *const var, Idx oldval, Idx newval )

overridevirtual

Listen to changes in a given Instantiation.

Parameters

i	The Instantiation to listen.
var	The changed dim.
oldval	The old value.
newval	The changed value.

Implements gum::MultiDimAdressable.

Definition at line 189 of file multiDimFunctionGraph_tpl.h.

                                            {}

clear()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::clear

(

)

Clears the function graph.

Definition at line 425 of file multiDimFunctionGraph_tpl.h.

                                                                       {
    _model_.clear();
    // Always discard the nodeId 0
    _model_.addNode();
 
    this->clearAllTerminalNodes();
 
    // Nodes cleaning
    for (HashTableIterator< NodeId, InternalNode* > nodeIter = _internalNodeMap_.begin();
         nodeIter != _internalNodeMap_.end();
         ++nodeIter) {
      delete nodeIter.val();
    }
    _internalNodeMap_.clear();
 
    // Cleaning the list of nodes for each variables
    for (HashTableIterator< const DiscreteVariable*, LinkedList< NodeId >* > varIter
         = _var2NodeIdMap_.begin();
         varIter != _var2NodeIdMap_.end();
         ++varIter) {
      delete varIter.val();
    }
    _var2NodeIdMap_.clear();
 
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter
         = this->variablesSequence().rbeginSafe();
         varIter != this->variablesSequence().rendSafe();
         --varIter) {
      this->erase(**varIter);
    }
  }

References _internalNodeMap_, _model_, _var2NodeIdMap_, clear(), gum::ExactTerminalNodePolicy< GUM_ELEMENT >::clearAllTerminalNodes(), erase(), and gum::MultiDimImplementation< GUM_ELEMENT >::variablesSequence().

Referenced by ~MultiDimFunctionGraph(), and clear().

Here is the call graph for this function:

Here is the caller graph for this function:

clearAllTerminalNodes()

template<typename GUM_ELEMENT>

void gum::ExactTerminalNodePolicy< GUM_ELEMENT >::clearAllTerminalNodes ( )

overridevirtualinherited

Erase all terminal nodes.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 60 of file ExactTerminalNodePolicy_tpl.h.

                                                                     {
    _map_.clear();
  }

References _map_.

Referenced by gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::clear().

Here is the caller graph for this function:

commitMultipleChanges_() [1/2]

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::commitMultipleChanges_ ( )

protectedvirtualinherited

Synchronize content after MultipleChanges.

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

Definition at line 257 of file multiDimImplementation_tpl.h.

                                                                     {
    // empty!
  }

Referenced by gum::MultiDimBucket< GUM_ELEMENT >::commitMultipleChanges_(), and endMultipleChanges().

Here is the caller graph for this function:

commitMultipleChanges_() [2/2]

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::commitMultipleChanges_ ( const GUM_ELEMENT & value )

protectedvirtualinherited

Synchronize content after MultipleChanges.

Parameters

value

Default value for uninitialized values.

Reimplemented in gum::MultiDimArray< GUM_ELEMENT >.

Definition at line 262 of file multiDimImplementation_tpl.h.

                                                                                       {
    // empty!
  }

compressionRate()

template<typename GUM_ELEMENT>

float gum::MultiDimImplementation< GUM_ELEMENT >::compressionRate ( ) const

inherited

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

This method uses domainSize() and realSize() to compute the ratio, 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 292 of file multiDimImplementation_tpl.h.

                                                                     {
    return ((float)1) - (float)realSize() / (float)domainSize();
  }

References domainSize(), and realSize().

Here is the call graph for this function:

contains()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::contains ( const DiscreteVariable & v ) const

overridevirtualinherited

Returns true if var is in *this.

Parameters

v	A DiscreteVariable.

Returns

Returns true if var is in *this.

Implements gum::MultiDimInterface.

Definition at line 212 of file multiDimImplementation_tpl.h.

                                                                                      {
    return _vars_.exists(&v);
  }

References _vars_.

Referenced by gum::MultiDimBucket< GUM_ELEMENT >::contains().

Here is the caller graph for this function:

content() [1/2]

template<typename GUM_ELEMENT>

const MultiDimImplementation< GUM_ELEMENT > * gum::MultiDimImplementation< GUM_ELEMENT >::content ( ) const

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 335 of file multiDimImplementation_tpl.h.

                                                           {
    return this;
  }

content() [2/2]

template<typename GUM_ELEMENT>

MultiDimImplementation< GUM_ELEMENT > * gum::MultiDimImplementation< GUM_ELEMENT >::content ( )

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 328 of file multiDimImplementation_tpl.h.

                                                                                        {
    return this;
  }

References MultiDimImplementation().

Here is the call graph for this function:

copy() [1/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::copy ( const MultiDimContainer< GUM_ELEMENT > & src )

overridevirtual

Warning

This will raise an OperationNotAllowed as MultiDimFunctionGraph can't copy other multiDim.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 233 of file multiDimFunctionGraph_tpl.h.

                                                   {
    GUM_ERROR(OperationNotAllowed,
              "You cannot copy another type of multiDim "
              "into a MultiDimFunctionGraph.");
  }

Referenced by MultiDimFunctionGraph(), operator=(), and gum::MDDOperatorStrategy< GUM_ELEMENT >::regress().

Here is the caller graph for this function:

copy() [2/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::copy

(

const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &

src

)

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

Parameters

src	The MultiDimFunctionGraph to copy.

Definition at line 241 of file multiDimFunctionGraph_tpl.h.

                                                                           {
    if (this->_isReduced_ != src.isReducedAndOrdered())
      GUM_ERROR(OperationNotAllowed,
                "Cannot copy a Reduced and Ordered "
                "function graph into Tree function graph "
                "(or vice-versa).")
 
    this->clear();
 
    // New variables insertion
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter
         = src.variablesSequence().beginSafe();
         varIter != src.variablesSequence().endSafe();
         ++varIter)
      this->add(**varIter);
 
    std::vector< NodeId >       lifo;
    Bijection< NodeId, NodeId > src2dest;
 
    if (src.isTerminalNode(src.root()))
      this->manager()->setRootNode(this->manager()->addTerminalNode(src.nodeValue(src.root())));
    else {
      this->manager()->setRootNode(
          this->manager()->addInternalNode(src.node(src.root())->nodeVar()));
      src2dest.insert(src.root(), this->root());
      lifo.push_back(src.root());
    }
 
    // Depth-first exploration and copy
    while (!lifo.empty()) {
      NodeId currentSrcNodeId = lifo.back();
      lifo.pop_back();
 
      const InternalNode* currentSrcNode = src.node(currentSrcNodeId);
 
      for (Idx index = 0; index < currentSrcNode->nbSons(); ++index) {
        if (!src2dest.existsFirst(currentSrcNode->son(index))) {
          NodeId srcSonNodeId = currentSrcNode->son(index), destSonNodeId = 0;
          if (src.isTerminalNode(srcSonNodeId)) {
            destSonNodeId = this->manager()->addTerminalNode(src.nodeValue(srcSonNodeId));
          } else {
            destSonNodeId = this->manager()->addInternalNode(src.node(srcSonNodeId)->nodeVar());
            lifo.push_back(srcSonNodeId);
          }
          src2dest.insert(srcSonNodeId, destSonNodeId);
        }
        this->manager()->setSon(src2dest.second(currentSrcNodeId),
                                index,
                                src2dest.second(currentSrcNode->son(index)));
      }
    }
 
    manager()->clean();
  }

References _isReduced_, and GUM_ERROR.

copyAndMultiplyByScalar()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::copyAndMultiplyByScalar	(	const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &	src,
		GUM_ELEMENT	gamma )

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

Parameters

src	The MultiDimFunctionGraph to copy.
gamma	The scalar used to multiply every value with.

Definition at line 365 of file multiDimFunctionGraph_tpl.h.

                                                                             {
    if (this->_isReduced_ != src.isReducedAndOrdered())
      GUM_ERROR(OperationNotAllowed,
                "Cannot copy a Reduced and Ordered "
                "function graph into Tree function graph "
                "(or vice-versa).")
 
    this->clear();
 
    // New variables insertion
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter
         = src.variablesSequence().beginSafe();
         varIter != src.variablesSequence().endSafe();
         ++varIter)
      this->add(**varIter);
 
    std::vector< NodeId >       lifo;
    HashTable< NodeId, NodeId > src2dest;
 
    if (src.isTerminalNode(src.root()))
      this->manager()->setRootNode(
          this->manager()->addTerminalNode(gamma * src.nodeValue(src.root())));
    else {
      this->manager()->setRootNode(
          this->manager()->addInternalNode(src.node(src.root())->nodeVar()));
      src2dest.insert(src.root(), this->root());
      lifo.push_back(src.root());
    }
 
    // Depth-first exploration an copy
    while (!lifo.empty()) {
      NodeId currentSrcNodeId = lifo.back();
      lifo.pop_back();
 
      const InternalNode* currentSrcNode = src.node(currentSrcNodeId);
 
      for (Idx index = 0; index < currentSrcNode->nbSons(); ++index) {
        if (!src2dest.exists(currentSrcNode->son(index))) {
          NodeId srcSonNodeId = currentSrcNode->son(index), destSonNodeId = 0;
          if (src.isTerminalNode(srcSonNodeId)) {
            destSonNodeId = this->manager()->addTerminalNode(gamma * src.nodeValue(srcSonNodeId));
          } else {
            destSonNodeId = this->manager()->addInternalNode(src.node(srcSonNodeId)->nodeVar());
            lifo.push_back(srcSonNodeId);
          }
          src2dest.insert(srcSonNodeId, destSonNodeId);
        }
        this->manager()->setSon(src2dest[currentSrcNodeId],
                                index,
                                src2dest[currentSrcNode->son(index)]);
      }
    }
 
    manager()->clean();
  }

References _isReduced_, copyAndMultiplyByScalar(), and GUM_ERROR.

Referenced by gum::StructuredPlaner< GUM_ELEMENT >::addReward_(), and copyAndMultiplyByScalar().

Here is the call graph for this function:

Here is the caller graph for this function:

copyAndReassign()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::copyAndReassign	(	const MultiDimFunctionGraph< GUM_ELEMENT, 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

src	The MultiDimFunctionGraph to copy.
reassign	A Bijection form variables in src to variables in this.

Definition at line 299 of file multiDimFunctionGraph_tpl.h.

                                                                                     {
    if (this->_isReduced_ != src.isReducedAndOrdered())
      GUM_ERROR(OperationNotAllowed,
                "Cannot copy a Reduced and Ordered "
                "function graph into Tree function graph "
                "(or vice-versa).")
 
    this->clear();
 
    // New variables insertion
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter
         = src.variablesSequence().beginSafe();
         varIter != src.variablesSequence().endSafe();
         ++varIter) {
      if ((*varIter)->domainSize() != reassign.second(*varIter)->domainSize())
        GUM_ERROR(InvalidArgument,
                  "Var " << (*varIter)->name() << " and var " << reassign.second(*varIter)->name()
                         << " have different domain sizes (" << (*varIter)->domainSize()
                         << "!=" << reassign.second(*varIter)->domainSize() << ")")
      this->add(*(reassign.second(*varIter)));
    }
 
    std::vector< NodeId >       lifo;
    Bijection< NodeId, NodeId > src2dest;
 
    if (src.isTerminalNode(src.root())) {
      this->manager()->setRootNode(this->manager()->addTerminalNode(src.nodeValue(src.root())));
    } else {
      this->manager()->setRootNode(
          this->manager()->addInternalNode(reassign.second(src.node(src.root())->nodeVar())));
      src2dest.insert(src.root(), this->root());
      lifo.push_back(src.root());
    }
 
    // Depth-first exploration and copy
    while (!lifo.empty()) {
      NodeId currentSrcNodeId = lifo.back();
      lifo.pop_back();
 
      const InternalNode* currentSrcNode = src.node(currentSrcNodeId);
 
      for (Idx index = 0; index < currentSrcNode->nbSons(); ++index) {
        if (!src2dest.existsFirst(currentSrcNode->son(index))) {
          NodeId srcSonNodeId = currentSrcNode->son(index), destSonNodeId = 0;
          if (src.isTerminalNode(srcSonNodeId)) {
            destSonNodeId = this->manager()->addTerminalNode(src.nodeValue(srcSonNodeId));
          } else {
            destSonNodeId = this->manager()->addInternalNode(
                reassign.second(src.node(srcSonNodeId)->nodeVar()));
            lifo.push_back(srcSonNodeId);
          }
          src2dest.insert(srcSonNodeId, destSonNodeId);
        }
        this->manager()->setSon(src2dest.second(currentSrcNodeId),
                                index,
                                src2dest.second(currentSrcNode->son(index)));
      }
    }
 
    manager()->clean();
  }

References _isReduced_, and GUM_ERROR.

Referenced by gum::AdaptiveRMaxPlaner::evalPolicy_(), gum::StructuredPlaner< GUM_ELEMENT >::evalPolicy_(), gum::AdaptiveRMaxPlaner::valueIteration_(), and gum::StructuredPlaner< GUM_ELEMENT >::valueIteration_().

Here is the caller graph for this function:

copyFrom() [1/2]

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::copyFrom ( const MultiDimContainer< GUM_ELEMENT > & src ) const

virtualinherited

Basic copy of a MultiDimContainer.

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

Parameters

src	The MultiDimContainer src which values are copied. This is a full copy with no verification of dimensions.

Exceptions

OperationNotAllowed

Raised if src does not have the same domain size than this MultiDimContainer.

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

Definition at line 266 of file multiDimContainer_tpl.h.

                                                         {
    if (src.domainSize() != domainSize()) {
      GUM_ERROR(OperationNotAllowed,
                "Domain sizes do not fit : " << src.domainSize() << "!=" << domainSize());
    }
 
    Instantiation i_dest(*this);
    Instantiation i_src(src);
 
    for (i_dest.setFirst(), i_src.setFirst(); !i_dest.end(); ++i_dest, ++i_src) {
      set(i_dest, src[i_src]);
    }
  }

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

Referenced by gum::Tensor< GUM_SCALAR >::Tensor(), gum::MultiDimArray< GUM_ELEMENT >::copyFrom(), and gum::MultiDimICIModel< GUM_SCALAR >::externalWeight().

Here is the call graph for this function:

Here is the caller graph for this function:

copyFrom() [2/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::copyFrom ( const MultiDimContainer< GUM_ELEMENT > & src, Instantiation * p_i = (Instantiation*)0 ) const

overridevirtual

Warning

This will raise an OperationNotAllowed as MultiDimFunctionGraph can't copy other multiDim.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 224 of file multiDimFunctionGraph_tpl.h.

                                                         {
    GUM_ERROR(OperationNotAllowed,
              "You cannot copy another type of multiDim "
              "into a MultiDimFunctionGraph.");
  }

References GUM_ERROR.

data() [1/2]

template<typename GUM_ELEMENT>

const GUM_ELEMENT * gum::MultiDimImplementation< GUM_ELEMENT >::data ( ) const

virtualnoexceptinherited

Returns a pointer to the contiguous data buffer, or nullptr if the implementation does not store data contiguously.

Subclasses backed by a contiguous array (e.g. MultiDimArray) override this to expose direct memory access, enabling zero-copy interop with external libraries such as NumPy.

Returns

Pointer to the first element of the contiguous buffer, or nullptr.

Reimplemented in gum::MultiDimArray< GUM_ELEMENT >.

Definition at line 340 of file multiDimImplementation_tpl.h.

                                                                                {
    return nullptr;
  }

data() [2/2]

template<typename GUM_ELEMENT>

GUM_ELEMENT * gum::MultiDimImplementation< GUM_ELEMENT >::data ( )

virtualnoexceptinherited

Returns a mutable pointer to the contiguous data buffer, or nullptr if the implementation does not store data contiguously.

Returns

Pointer to the first element of the contiguous buffer, or nullptr.

Reimplemented in gum::MultiDimArray< GUM_ELEMENT >.

Definition at line 345 of file multiDimImplementation_tpl.h.

                                                                    {
    return nullptr;
  }

domainSize()

template<typename GUM_ELEMENT>

Size gum::MultiDimImplementation< GUM_ELEMENT >::domainSize ( ) const

overridevirtualinherited

Returns the product of the variables domain size.

Returns

Returns the product of the variables domain size.

Implements gum::MultiDimInterface.

Definition at line 187 of file multiDimImplementation_tpl.h.

                                                               {
    return _domainSize_;
  }

References _domainSize_.

Referenced by gum::MultiDimArray< GUM_ELEMENT >::add(), gum::MultiDimBucket< GUM_ELEMENT >::add(), gum::MultiDimWithOffset< GUM_ELEMENT >::add(), gum::MultiDimWithOffset< GUM_ELEMENT >::changeNotification(), gum::MultiDimArray< GUM_ELEMENT >::commitMultipleChanges_(), gum::MultiDimBucket< GUM_ELEMENT >::commitMultipleChanges_(), compressionRate(), gum::MultiDimWithOffset< GUM_ELEMENT >::computeInstantiationValue_(), gum::MultiDimArray< GUM_ELEMENT >::erase(), gum::MultiDimBucket< GUM_ELEMENT >::erase(), gum::MultiDimArray< GUM_ELEMENT >::realSize(), gum::MultiDimBucket< GUM_ELEMENT >::setBufferSize(), gum::MultiDimWithOffset< GUM_ELEMENT >::setIncNotification(), and gum::MultiDimWithOffset< GUM_ELEMENT >::setLastNotification().

Here is the caller graph for this function:

empty()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::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 226 of file multiDimImplementation_tpl.h.

                                                          {
    GUM_ASSERT(!this->isCommitNeeded_());
    return _vars_.empty();
  }

References _vars_, and isCommitNeeded_().

Referenced by gum::MultiDimBucket< GUM_ELEMENT >::_initializeBuffer_(), and gum::MultiDimArray< GUM_ELEMENT >::fill().

Here is the call graph for this function:

Here is the caller graph for this function:

endMultipleChanges() [1/2]

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::endMultipleChanges ( )

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 237 of file multiDimImplementation_tpl.h.

                                                                 {
    if (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE) {
      commitMultipleChanges_();
      _internalChangeState_ = _InternalChangeState_::NO_CHANGE;
    }
 
    _internalChangeMethod_ = _InternalChangeMethod_::DIRECT_CHANGE;
  }

References _internalChangeMethod_, _internalChangeState_, commitMultipleChanges_(), DIRECT_CHANGE, NO_CHANGE, and NOT_COMMITTED_CHANGE.

Here is the call graph for this function:

endMultipleChanges() [2/2]

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::endMultipleChanges ( const GUM_ELEMENT & v )

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 247 of file multiDimImplementation_tpl.h.

                                                                                     {
    if (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE) {
      commitMultipleChanges_(x);
      _internalChangeState_ = _InternalChangeState_::NO_CHANGE;
    }
 
    _internalChangeMethod_ = _InternalChangeMethod_::DIRECT_CHANGE;
  }

erase()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::erase ( const DiscreteVariable & v )

overridevirtual

Removes a var from the variables of the multidimensional matrix.

See also

operator>>(MultiDimInterface& c, const DiscreteVariable& v)

Exceptions

OperationNotAllowed	Raised if this object is non mutable.
NotFound	Raised if v does not belong to this.

Implements gum::MultiDimInterface.

Definition at line 171 of file multiDimFunctionGraph_tpl.h.

                                                                                                {
    if (this->_var2NodeIdMap_.exists(&v)) {
      while (_var2NodeIdMap_[&v]->list() != nullptr) {
        manager()->eraseNode(_var2NodeIdMap_[&v]->list()->element());
      }
      delete _var2NodeIdMap_[&v];
      _var2NodeIdMap_.erase(&v);
    }
 
    if (this->variablesSequence().exists(&v)) MultiDimImplementation< GUM_ELEMENT >::erase(v);
  }

References _var2NodeIdMap_, and manager().

Referenced by clear().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseTerminalNode()

template<typename GUM_ELEMENT>

void gum::ExactTerminalNodePolicy< GUM_ELEMENT >::eraseTerminalNode ( const NodeId & n )

overridevirtualinherited

Remove node matching given id.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 55 of file ExactTerminalNodePolicy_tpl.h.

                                                                                {
    _map_.eraseFirst(n);
  }

References _map_.

existsTerminalNodeWithId()

template<typename GUM_ELEMENT>

bool gum::ExactTerminalNodePolicy< GUM_ELEMENT >::existsTerminalNodeWithId ( const NodeId & n ) const

overridevirtualinherited

Returns true if a terminal node matching this id exists.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 65 of file ExactTerminalNodePolicy_tpl.h.

                                                                                             {
    return _map_.existsFirst(n);
  }

References _map_.

Referenced by gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::isTerminalNode().

Here is the caller graph for this function:

existsTerminalNodeWithValue()

template<typename GUM_ELEMENT>

bool gum::ExactTerminalNodePolicy< GUM_ELEMENT >::existsTerminalNodeWithValue ( const GUM_ELEMENT & v ) const

overridevirtualinherited

Returns true if a terminal node matching this value exists.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 70 of file ExactTerminalNodePolicy_tpl.h.

                                  {
    return _map_.existsSecond(v);
  }

References _map_.

extractFrom()

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::extractFrom ( const MultiDimContainer< GUM_ELEMENT > & src, const Instantiation & mask )

virtualinherited

Basic extraction of a MultiDimContainer.

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

Parameters

src	The MultiDimContainer src which datas are copied.
mask	partial instantiation of variables of the Tensor : the

extraction will concern every variable not in the instantiation and the copy of data will use the (relevant) values in this instantiation.

Definition at line 242 of file multiDimContainer_tpl.h.

                                                                                 {
    this->beginMultipleChanges();
 
    Size nbr = this->nbrDim();
    for (Idx i = 0; i < nbr; i++) {
      this->erase(this->variable(0));
    }
 
    for (Idx i = 0; i < src.nbrDim(); i++) {
      if (!imask.contains(src.variable(i))) this->add(src.variable(i));
    }
 
    this->endMultipleChanges();
 
    if (this->nbrDim() == 0) { GUM_ERROR(FatalError, "Empty tensor") }
 
    Instantiation inst(src);
    inst.setVals(imask);
    for (inst.setFirstOut(imask); !inst.end(); inst.incOut(imask))
      set(inst, src[inst]);
  }

References MultiDimContainer(), beginMultipleChanges(), gum::MultiDimInterface::erase(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variable().

Here is the call graph for this function:

fill()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::fill ( const GUM_ELEMENT & d ) const

overridevirtual

Warning

This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 135 of file multiDimFunctionGraph_tpl.h.

                                                                                                {
    GUM_ERROR(OperationNotAllowed,
              "Function Graph can't be edited so "
              "easily.\nMultiDimFunctionGraphManager "
              "provides the framework to edit a "
              "Function Graph.")
  }

References GUM_ERROR.

get()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

GUM_ELEMENT gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::get ( const Instantiation & i ) const

overridevirtual

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

i	An Instantiation of this MultiDimContainer.

Returns

Returns the value pointe by i.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 642 of file multiDimFunctionGraph_tpl.h.

                                       {
    NodeId        currentNodeId = _root_;
    InternalNode* currentNode   = nullptr;
    while (!isTerminalNode(currentNodeId)) {
      currentNode   = _internalNodeMap_[currentNodeId];
      currentNodeId = currentNode->son(inst.val(*(currentNode->nodeVar())));
    }
    return this->terminalNodeValue(currentNodeId);
  }

References _internalNodeMap_, _root_, get(), isTerminalNode(), gum::InternalNode::nodeVar(), gum::InternalNode::son(), gum::ExactTerminalNodePolicy< GUM_ELEMENT >::terminalNodeValue(), and gum::Instantiation::val().

Referenced by get(), toString(), and gum::FMDPSimulator::transitionProbability_().

Here is the call graph for this function:

Here is the caller graph for this function:

get_()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

GUM_ELEMENT & gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::get_ ( const Instantiation & inst ) const

overrideprotectedvirtual

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_ELEMENT >.

Definition at line 635 of file multiDimFunctionGraph_tpl.h.

                                       {
    GUM_ERROR(OperationNotAllowed, "You can't edit a function by other mean than the manager")
  }

References get_(), and GUM_ERROR.

Referenced by get_().

Here is the call graph for this function:

Here is the caller graph for this function:

getMasterRef() [1/2]

template<typename GUM_ELEMENT>

const MultiDimAdressable & gum::MultiDimContainer< GUM_ELEMENT >::getMasterRef ( ) const

overridevirtualinherited

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.

Definition at line 307 of file multiDimContainer_tpl.h.

                                                                                 {
    return static_cast< const MultiDimAdressable& >(*content());
  }

References gum::MultiDimAdressable::MultiDimAdressable(), and content().

Here is the call graph for this function:

getMasterRef() [2/2]

template<typename GUM_ELEMENT>

MultiDimAdressable & gum::MultiDimContainer< GUM_ELEMENT >::getMasterRef ( )

overridevirtualinherited

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.

Definition at line 302 of file multiDimContainer_tpl.h.

                                                                     {
    return static_cast< MultiDimAdressable& >(*content());
  }

References gum::MultiDimAdressable::MultiDimAdressable(), and content().

Here is the call graph for this function:

getReducedAndOrderedInstance()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::getReducedAndOrderedInstance ( )

staticnodiscard

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 615 of file multiDimFunctionGraph_tpl.h.

                                                                                             {
    return new MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >();
  }

References getReducedAndOrderedInstance().

Referenced by gum::MultiDimFunctionGraph< double >::MultiDimFunctionGraph(), gum::MultiDimFunctionGraphOperator< GUM_ELEMENT, FUNCTOR, TerminalNodePolicy >::MultiDimFunctionGraphOperator(), gum::MultiDimFunctionGraphProjector< GUM_ELEMENT, FUNCTOR, TerminalNodePolicy >::MultiDimFunctionGraphProjector(), gum::Regress< GUM_ELEMENT, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy >::Regress(), gum::FMDPFactory< GUM_ELEMENT >::_initializeFunctionGraph_(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::_instantiateFunctionGraph_(), gum::MultiDimFunctionGraphGenerator::generate(), gum::MDDOperatorStrategy< GUM_ELEMENT >::getFunctionInstance(), getReducedAndOrderedInstance(), and gum::MDDOperatorStrategy< GUM_ELEMENT >::regress().

Here is the call graph for this function:

Here is the caller graph for this function:

getTreeInstance()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::getTreeInstance ( )

staticnodiscard

Returns an arborescent instance.

Returns

Returns an arborescent instance

Definition at line 622 of file multiDimFunctionGraph_tpl.h.

                                                                                {
    return new MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >(false);
  }

References getTreeInstance().

Referenced by gum::MultiDimFunctionGraph< double >::MultiDimFunctionGraph(), gum::TreeOperator< GUM_ELEMENT, COMBINEOPERATOR, TerminalNodePolicy >::TreeOperator(), gum::TreeOperator< GUM_ELEMENT, COMBINEOPERATOR, TerminalNodePolicy >::TreeOperator(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::_instantiateFunctionGraph_(), gum::TreeRegress< GUM_ELEMENT, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy >::_xPloreVFunc_(), gum::TreeRegress< GUM_ELEMENT, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy >::compute(), gum::TreeOperatorStrategy< GUM_ELEMENT >::getAggregatorInstance(), gum::TreeOperatorStrategy< GUM_ELEMENT >::getFunctionInstance(), and getTreeInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

hasValue()

template<typename GUM_ELEMENT>

bool gum::ExactTerminalNodePolicy< GUM_ELEMENT >::hasValue ( ) const

overridevirtualinherited

Indicates if constant safe iterator has reach end of terminal nodes list.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 92 of file ExactTerminalNodePolicy_tpl.h.

                                                              {
    return _mappy_ != _map_.endSafe();
  }

id()

template<typename GUM_ELEMENT>

const NodeId & gum::ExactTerminalNodePolicy< GUM_ELEMENT >::id ( ) const

overridevirtualinherited

Returns the id of the current terminal nodes pointed by the constant safe iterator.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 107 of file ExactTerminalNodePolicy_tpl.h.

                                                                 {
    return _mappy_.first();
  }

References _mappy_.

invert_()

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::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

p1	The first position.
p2	The second position.

Definition at line 316 of file multiDimImplementation_tpl.h.

                                                                    {
    _vars_.swap(p1, p2);
  }

References _vars_.

isCommitNeeded_()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::isCommitNeeded_ ( ) const

protectedinherited

Get the actual state of *this.

Returns

Returns true if a commit is needed.

Definition at line 274 of file multiDimImplementation_tpl.h.

                                                                    {
    return (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE);
  }

References _internalChangeState_, and NOT_COMMITTED_CHANGE.

Referenced by MultiDimImplementation(), and empty().

Here is the caller graph for this function:

isInMultipleChangeMethod_()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::isInMultipleChangeMethod_ ( ) const

protectedinherited

Get the actual change method of this MultiDimImplementation.

Returns

Returns true if in multiple changes.

Definition at line 268 of file multiDimImplementation_tpl.h.

                                                                              {
    return (_internalChangeMethod_ == _InternalChangeMethod_::MULTIPLE_CHANGE);
  }

References _internalChangeMethod_, and MULTIPLE_CHANGE.

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

Here is the caller graph for this function:

isInternalNode()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

bool gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::isInternalNode

(

const NodeId &

node

)

const

Indicates if given node is terminal or not.

Parameters

node	The node to test for being itnernal.

Returns

Returns true if node is internal.

Definition at line 559 of file multiDimFunctionGraph_tpl.h.

                                {
    return this->_internalNodeMap_.exists(node);
  }

References _internalNodeMap_, isInternalNode(), and node().

Referenced by isInternalNode(), and node().

Here is the call graph for this function:

Here is the caller graph for this function:

isReducedAndOrdered()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

bool gum::MultiDimFunctionGraph< GUM_ELEMENT, 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 608 of file multiDimFunctionGraph_tpl.h.

                                                                                           {
    return _isReduced_;
  }

References _isReduced_, and isReducedAndOrdered().

Referenced by MultiDimFunctionGraph(), and isReducedAndOrdered().

Here is the call graph for this function:

Here is the caller graph for this function:

isTerminalNode()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

bool gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::isTerminalNode

(

const NodeId &

node

)

const

Indicates if given node is terminal or not.

Parameters

node	The node to test for terminality.

Returns

Returns true if node is terminal.

Definition at line 552 of file multiDimFunctionGraph_tpl.h.

                                {
    return this->existsTerminalNodeWithId(node);
  }

References gum::ExactTerminalNodePolicy< GUM_ELEMENT >::existsTerminalNodeWithId(), isTerminalNode(), and node().

Referenced by gum::StructuredPlaner< GUM_ELEMENT >::_recurArgMaxCopy_(), get(), isTerminalNode(), nodeValue(), and toDot().

Here is the call graph for this function:

Here is the caller graph for this function:

manager()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

MultiDimFunctionGraphManager< GUM_ELEMENT, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_ELEMENT, 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 534 of file multiDimFunctionGraph_tpl.h.

                                                                        {
    if (_manager_ == nullptr) {
      if (_isReduced_)
        _manager_ = new MultiDimFunctionGraphROManager< GUM_ELEMENT, TerminalNodePolicy >(this);
      else
        _manager_ = new MultiDimFunctionGraphTreeManager< GUM_ELEMENT, TerminalNodePolicy >(this);
    }
    return _manager_;
  }

References _isReduced_, _manager_, and manager().

Referenced by gum::AdaptiveRMaxPlaner::_makeRMaxFunctionGraphs_(), gum::AdaptiveRMaxPlaner::_visitLearner_(), gum::MultiDimFunctionGraph< double >::clear(), erase(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StructuredPlaner< GUM_ELEMENT >::makeArgMax_(), manager(), and gum::MultiDimFunctionGraph< double >::manager().

Here is the call graph for this function:

Here is the caller graph for this function:

model()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const NodeGraphPart & gum::MultiDimFunctionGraph< GUM_ELEMENT, 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 527 of file multiDimFunctionGraph_tpl.h.

                                                                                             {
    return _model_;
  }

References _model_, and model().

Referenced by model().

Here is the call graph for this function:

Here is the caller graph for this function:

name()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const std::string & gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::name ( ) const

overridevirtual

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_ELEMENT >.

Definition at line 119 of file multiDimFunctionGraph_tpl.h.

                                                                                        {
    return _name_;
  }

References _name_.

Referenced by setTableName().

Here is the caller graph for this function:

nbrDim()

template<typename GUM_ELEMENT>

Idx gum::MultiDimImplementation< GUM_ELEMENT >::nbrDim ( ) const

overridevirtualinherited

Returns the number of vars in the multidimensional container.

Returns

Returns the number of vars in the multidimensional container.

Implements gum::MultiDimInterface.

Definition at line 182 of file multiDimImplementation_tpl.h.

                                                          {
    return _vars_.size();
  }

References _vars_.

Referenced by gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::buildValue_(), gum::MultiDimWithOffset< GUM_ELEMENT >::computeInstantiationValue_(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::get(), gum::MultiDimICIModel< GUM_ELEMENT >::realSize(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::toString(), and gum::MultiDimICIModel< GUM_ELEMENT >::toString().

Here is the caller graph for this function:

newFactory()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

MultiDimContainer< GUM_ELEMENT > * gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::newFactory ( ) const

nodiscardoverridevirtual

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_ELEMENT >.

Definition at line 108 of file multiDimFunctionGraph_tpl.h.

                                                                                 {
    if (_isReduced_)
      return MultiDimFunctionGraph< GUM_ELEMENT,
                                    TerminalNodePolicy >::getReducedAndOrderedInstance();
    else return MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::getTreeInstance();
  }

nextValue()

template<typename GUM_ELEMENT>

void gum::ExactTerminalNodePolicy< GUM_ELEMENT >::nextValue ( ) const

overridevirtualinherited

Increments the constant safe iterator.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 97 of file ExactTerminalNodePolicy_tpl.h.

                                                               {
    ++_mappy_;
  }

References _mappy_.

node()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const InternalNode * gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::node

(

NodeId

n

)

const

Returns internalNode structure associated to that nodeId.

Parameters

n	The node for which the internal structure is returned.

Returns

Returns internalNode structure associated to that nodeId

Exceptions

InvalidNode

Raised if node is terminal

Definition at line 576 of file multiDimFunctionGraph_tpl.h.

                                                                                   {
    if (!isInternalNode(n))
      GUM_ERROR(InvalidArgument, "Id " << n << " is not bound to any terminal node")
    return this->_internalNodeMap_[n];
  }

References _internalNodeMap_, GUM_ERROR, isInternalNode(), and node().

Referenced by gum::StructuredPlaner< GUM_ELEMENT >::_recurArgMaxCopy_(), gum::MultiDimFunctionGraphGenerator::generate(), isInternalNode(), isTerminalNode(), and node().

Here is the call graph for this function:

Here is the caller graph for this function:

nodeValue()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const GUM_ELEMENT & gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::nodeValue

(

NodeId

n

)

const

Returns value associated to given node.

Parameters

n	The node for which the value is returned.

Returns

Returns value associated to given node.

Exceptions

InvalidNode

Raised if node isn't terminal.

Definition at line 567 of file multiDimFunctionGraph_tpl.h.

                                                                                        {
    if (!isTerminalNode(n))
      GUM_ERROR(InvalidArgument, "Id " << n << " is not bound to any terminal node")
    return this->terminalNodeValue(n);
  }

References GUM_ERROR, isTerminalNode(), nodeValue(), and gum::ExactTerminalNodePolicy< GUM_ELEMENT >::terminalNodeValue().

Referenced by gum::StructuredPlaner< GUM_ELEMENT >::_recurArgMaxCopy_(), and nodeValue().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > & gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::operator=

(

const MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy > &

from

)

Copy Operator.

Parameters

from	The MultiDimFunctionGraph to copy.

Returns

Returns this MultiDimFunctionGraph.

Definition at line 84 of file multiDimFunctionGraph_tpl.h.

                                                                                {
    copy(from);
    return *this;
  }

References copy().

Here is the call graph for this function:

operator==()

template<typename GUM_ELEMENT>

bool gum::MultiDimContainer< GUM_ELEMENT >::operator== ( const MultiDimContainer< GUM_ELEMENT > & p ) const

inherited

Test if this MultiDimContainer is equal to p.

Parameters

p	The MultiDimContainer to test for equality.

Returns

Returns true if this MultiDimContainer is equal to p.

Definition at line 148 of file multiDimContainer_tpl.h.

                                                       {
    if ((nbrDim() == p.nbrDim()) && (domainSize() == p.domainSize())) {
      if (nbrDim() == 0) return true;
 
      for (auto iter = variablesSequence().beginSafe(); iter != variablesSequence().endSafe();
           ++iter) {
        if (!p.variablesSequence().exists(*iter)) { return false; }
      }
    } else {
      return false;
    }
 
    Instantiation                  i(*this);
    AlmostDifferent< GUM_ELEMENT > cmp;
    for (i.setFirst(); !i.end(); ++i) {
      if (cmp(get(i), p.get(i))) { return false; }
    }
 
    return true;
  }

References MultiDimContainer(), gum::MultiDimInterface::domainSize(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variablesSequence().

Here is the call graph for this function:

operator[]()

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::MultiDimContainer< GUM_ELEMENT >::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

i	An Instantiation.

Returns

Returns the adressed (GUM_ELEMENT) value.

Definition at line 103 of file multiDimContainer_tpl.h.

                                                                                       {
    return get(i);
  }

References get().

Here is the call graph for this function:

populate() [1/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::populate ( const std::vector< GUM_ELEMENT > & v ) const

overridevirtual

Warning

This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 144 of file multiDimFunctionGraph_tpl.h.

                                               {
    GUM_ERROR(OperationNotAllowed,
              "Function Graph can't be edited so "
              "easily.\nMultiDimFunctionGraphManager "
              "provides the framework to editaa "
              "Function Graph.")
  }

populate() [2/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::populate ( std::initializer_list< GUM_ELEMENT > v ) const

overridevirtual

Warning

This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 154 of file multiDimFunctionGraph_tpl.h.

                                                  {
    GUM_ERROR(OperationNotAllowed,
              "Function Graph can't be edited so "
              "easily.\nMultiDimFunctionGraphManager "
              "provides the framework to edit a "
              "Function Graph.")
  }

References GUM_ERROR.

pos()

template<typename GUM_ELEMENT>

Idx gum::MultiDimImplementation< GUM_ELEMENT >::pos ( const DiscreteVariable & v ) const

overridevirtualinherited

Returns the index of a variable.

Parameters

v	The variable for which the index is returned.

Returns

Returns the index of a variable.

Exceptions

NotFound

Raised if v is not in this multidimensional matrix.

Implements gum::MultiDimInterface.

Definition at line 207 of file multiDimImplementation_tpl.h.

                                                                                {
    return _vars_.pos(&v);
  }

Referenced by gum::MultiDimArray< GUM_ELEMENT >::erase(), and gum::MultiDimWithOffset< GUM_ELEMENT >::erase().

Here is the caller graph for this function:

realSize()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

Size gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::realSize ( ) const

overridevirtual

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_ELEMENT >.

Definition at line 184 of file multiDimFunctionGraph_tpl.h.

                                                                                {
    return _internalNodeMap_.size();   // +  _valueMap_.size();
  }

reduce()

template<typename GUM_ELEMENT>

GUM_ELEMENT gum::MultiDimContainer< GUM_ELEMENT >::reduce ( std::function< GUM_ELEMENT(GUM_ELEMENT, GUM_ELEMENT) > f, GUM_ELEMENT base ) const

virtualinherited

compute lfold for this container

Parameters

f	the function to apply
base	the initial value

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

Definition at line 208 of file multiDimContainer_tpl.h.

                                                                         {
    GUM_ELEMENT   tmp = base;
    Instantiation i(*this);
    for (i.setFirst(); !i.end(); ++i) {
      tmp = f(tmp, get(i));
    }
    return tmp;
  }

registerSlave()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::registerSlave ( Instantiation & i )

overridevirtualinherited

Register i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to enslave.

Returns

Returns true if i becomes a slave of this MultiDimAdressable.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimWithOffset< GUM_ELEMENT >.

Definition at line 157 of file multiDimImplementation_tpl.h.

                                                                                {
    // check that the Instantiation has the same variables as this
    if (slave.nbrDim() != _vars_.size()) return false;
 
    for (Sequence< const DiscreteVariable* >::iterator_safe iter = _vars_.beginSafe();
         iter != _vars_.endSafe();
         ++iter)
      if (!slave.contains(*iter)) return false;
 
    slave.synchronizeWithMaster(this);
 
    _slaveInstantiations_ += (&slave);
 
    return true;
  }

References _vars_, and gum::Instantiation::nbrDim().

Referenced by gum::MultiDimBucket< GUM_ELEMENT >::registerSlave(), and gum::MultiDimWithOffset< GUM_ELEMENT >::registerSlave().

Here is the call graph for this function:

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

x	The variable in this which will be replaced.
y	The variable replacing y.

Exceptions

NotFound	Raised if x does not belong to this MultiDim.
OperationNotAllowed	If y and x are not interchangeable.
DuplicateElement	If y is already in this MultiDim.

Definition at line 57 of file multiDimInterface_inl.h.

                                                                                      {
    if (!contains(x)) { GUM_ERROR(NotFound, "could not find the variable") }
 
    if (contains(y)) { GUM_ERROR(DuplicateElement, "variable " << y << " already in MultiDim") }
 
    if (x.domainSize() != y.domainSize()) {
      GUM_ERROR(OperationNotAllowed, "incompatible variables")
    }
 
    replace_(&x, &y);
  }

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

Here is the call graph for this function:

replace_()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::replace_ ( const DiscreteVariable * x, const DiscreteVariable * y )

overrideprotectedvirtual

Warning

This will raise an OperationNotAllowed as this method has not yet been implemented.

Implements gum::MultiDimInterface.

Definition at line 628 of file multiDimFunctionGraph_tpl.h.

                                 {
    GUM_ERROR(OperationNotAllowed, "Not Implemented Yet")
  }

References GUM_ERROR, and replace_().

Referenced by replace_().

Here is the call graph for this function:

Here is the caller graph for this function:

root()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const NodeId & gum::MultiDimFunctionGraph< GUM_ELEMENT, 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 546 of file multiDimFunctionGraph_tpl.h.

                                                                                     {
    return _root_;
  }

References _root_, and root().

Referenced by gum::MultiDimFunctionGraphGenerator::generate(), gum::StructuredPlaner< GUM_ELEMENT >::makeArgMax_(), and root().

Here is the call graph for this function:

Here is the caller graph for this function:

set()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::set ( const Instantiation & i, const GUM_ELEMENT & value ) const

overridevirtual

Warning

This will raise an OperationNotAllowed exceptions. Use the MultiDimFunctionGraphManager class to edit a MultiDimFunctionGraph.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 124 of file multiDimFunctionGraph_tpl.h.

                                        {
    GUM_ERROR(OperationNotAllowed,
              "Function Graph can't be edited so "
              "easily.\nMultiDimFunctionGraphManager "
              "provides the framework to edit a "
              "Function Graph.")
  }

References GUM_ERROR, and gum::ExactTerminalNodePolicy< GUM_ELEMENT >::value().

Here is the call graph for this function:

setChangeNotification()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::setChangeNotification ( const Instantiation & i )

overridevirtual

Listen to an assignment of a value in a Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 212 of file multiDimFunctionGraph_tpl.h.

                              {}

setDecNotification()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::setDecNotification ( const Instantiation & i )

overridevirtual

Listen to increment in each recorded Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 208 of file multiDimFunctionGraph_tpl.h.

                              {}

setFirstNotification()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::setFirstNotification ( const Instantiation & i )

overridevirtual

Listen to setFirst in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 196 of file multiDimFunctionGraph_tpl.h.

                              {}

setIncNotification()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::setIncNotification ( const Instantiation & i )

overridevirtual

Listen to increment in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 204 of file multiDimFunctionGraph_tpl.h.

                              {}

setLastNotification()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::setLastNotification ( const Instantiation & i )

overridevirtual

Listen to setLast in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 200 of file multiDimFunctionGraph_tpl.h.

                              {}

setTableName()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::setTableName

(

std::string_view

name

)

Sets the name of the table represented by this structure.

Parameters

name	the new name of this structure.

Definition at line 601 of file multiDimFunctionGraph_tpl.h.

                           {
    _tableName_ = name;
  }

References _tableName_, name(), and setTableName().

Referenced by gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize(), and setTableName().

Here is the call graph for this function:

Here is the caller graph for this function:

slaves_()

template<typename GUM_ELEMENT>

const List< Instantiation * > & gum::MultiDimImplementation< GUM_ELEMENT >::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 280 of file multiDimImplementation_tpl.h.

                                                                                     {
    return _slaveInstantiations_;
  }

References _slaveInstantiations_.

Referenced by gum::MultiDimBucket< GUM_ELEMENT >::_initializeBuffer_().

Here is the caller graph for this function:

tableName()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const std::string & gum::MultiDimFunctionGraph< GUM_ELEMENT, 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 595 of file multiDimFunctionGraph_tpl.h.

                                                                                             {
    return _tableName_;
  }

References _tableName_, and tableName().

Referenced by tableName().

Here is the call graph for this function:

Here is the caller graph for this function:

terminalNodeId()

template<typename GUM_ELEMENT>

const NodeId & gum::ExactTerminalNodePolicy< GUM_ELEMENT >::terminalNodeId ( const GUM_ELEMENT & v ) const

overridevirtualinherited

Returns the id of the terminal node that has the given value.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 82 of file ExactTerminalNodePolicy_tpl.h.

                                                                                                 {
    return _map_.first(v);
  }

terminalNodeValue()

template<typename GUM_ELEMENT>

const GUM_ELEMENT & gum::ExactTerminalNodePolicy< GUM_ELEMENT >::terminalNodeValue ( const NodeId & n ) const

overridevirtualinherited

Returns the value of the terminal node that has the given id.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 77 of file ExactTerminalNodePolicy_tpl.h.

                                                                                     {
    return _map_.second(n);
  }

Referenced by gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::get(), gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::nodeValue(), and gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::toDot().

Here is the caller graph for this function:

toDot()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

std::string gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::toDot

(

bool

withBackArcs = false

)

const

Returns a const reference to the manager of this diagram.

Parameters

withBackArcs

If true, back arcs will be added.

Returns

Returns a const reference to the manager of this diagram

Definition at line 459 of file multiDimFunctionGraph_tpl.h.

                                                                                             {
    std::stringstream output;
    std::stringstream terminalStream;
    std::stringstream nonTerminalStream;
    std::stringstream arcstream;
    //      std::stringstream defaultarcstream;
    output << '\n' << "digraph \" " << _tableName_ << "\" {" << '\n';
 
    terminalStream << "node [shape = box];" << '\n';
    nonTerminalStream << "node [shape = ellipse];" << '\n';
    std::string tab = "  ";
 
    for (NodeGraphPart::NodeIterator nodeIter = _model_.begin(); nodeIter != _model_.end();
         ++nodeIter)
      if (*nodeIter != 0) {
        if (this->isTerminalNode((NodeId)*nodeIter))
          terminalStream << tab << *nodeIter << ";" << tab << *nodeIter << " [label=\"" << *nodeIter
                         << " - " << std::setprecision(30) << this->terminalNodeValue(*nodeIter)
                         << "\"]"
                         << ";" << '\n';
        else {
          InternalNode* currentNode = _internalNodeMap_[*nodeIter];
          nonTerminalStream << tab << *nodeIter << ";" << tab << *nodeIter << " [label=\""
                            << *nodeIter << " - " << currentNode->nodeVar()->name() << "\"]"
                            << ";" << '\n';
 
          //              if (arcMap_[*nodeIter] != NULL)
          HashTable< NodeId, LinkedList< Idx >* > sonMap;
          for (Idx sonIter = 0; sonIter < currentNode->nbSons(); ++sonIter) {
            if (!sonMap.exists(currentNode->son(sonIter)))
              sonMap.insert(currentNode->son(sonIter), new LinkedList< Idx >());
            sonMap[currentNode->son(sonIter)]->addLink(sonIter);
          }
 
          for (auto sonIter = sonMap.beginSafe(); sonIter != sonMap.endSafe(); ++sonIter) {
            arcstream << tab << *nodeIter << " -> " << sonIter.key() << " [label=\" ";
            Link< Idx >* modaIter = sonIter.val()->list();
            while (modaIter) {
              arcstream << currentNode->nodeVar()->label(modaIter->element()) << ", ";
              modaIter = modaIter->nextLink();
            }
            arcstream << "\",color=\"#0000ff\"]"
                      << ";" << '\n';
            delete sonIter.val();
          }
 
          if (withBackArcs) {
            Link< Parent >* parentIter = currentNode->parents();
            while (parentIter != nullptr) {
              arcstream << tab << *nodeIter << " -> " << parentIter->element().parentId
                        << " [label=\"" << parentIter->element().modality << "\",color=\"#ff0000\"]"
                        << ";" << '\n';
              parentIter = parentIter->nextLink();
            }
          }
        }
      }
 
    output << terminalStream.str() << '\n'
           << nonTerminalStream.str() << '\n'
           << arcstream.str() << '\n'
           << "}" << '\n';
 
    return output.str();
  }

References _internalNodeMap_, _model_, _tableName_, gum::HashTable< Key, Val >::beginSafe(), gum::Link< T >::element(), gum::HashTable< Key, Val >::endSafe(), gum::HashTable< Key, Val >::exists(), gum::HashTable< Key, Val >::insert(), isTerminalNode(), gum::DiscreteVariable::label(), gum::Variable::name(), gum::InternalNode::nbSons(), gum::Link< T >::nextLink(), gum::InternalNode::nodeVar(), gum::InternalNode::parents(), gum::InternalNode::son(), gum::ExactTerminalNodePolicy< GUM_ELEMENT >::terminalNodeValue(), and toDot().

Referenced by toDot().

Here is the call graph for this function:

Here is the caller graph for this function:

toString() [1/2]

template<typename GUM_ELEMENT>

std::string gum::MultiDimContainer< GUM_ELEMENT >::toString ( ) const

virtualinherited

Returns a representation of this MultiDimContainer.

Returns

Returns a representation of this MultiDimContainer.

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

Definition at line 125 of file multiDimContainer_tpl.h.

                                                             {
    // we create a new instantiation and iterate over it to display the whole
    // content of the array
    if (this->nbrDim() == 0) { return "[]"; }
 
    std::stringstream ss;
    Instantiation     inst(const_cast< MultiDimContainer* >(this));
 
    bool first = true;
 
    for (inst.setFirst(); !inst.end(); ++inst) {
      if (!first) { ss << " /"; }
      first = false;
 
      ss << inst << " :: " << get(inst);
    }
 
    return ss.str();
  }

References gum::MultiDimInterface::nbrDim().

Referenced by gum::MultiDimContainer< double >::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

toString() [2/2]

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

std::string gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::toString ( const Instantiation * i ) const

overridevirtual

Display the internal representation of i.

Returns

Returns an internal representation of i.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 216 of file multiDimFunctionGraph_tpl.h.

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

References get().

Here is the call graph for this function:

unregisterSlave()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::unregisterSlave ( Instantiation & i )

overridevirtualinherited

Unregister i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to free.

Returns

Returns true, whatever happens.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimWithOffset< GUM_ELEMENT >.

Definition at line 176 of file multiDimImplementation_tpl.h.

                                                                                  {
    _slaveInstantiations_.eraseByVal(&slave);
    return true;
  }

References _slaveInstantiations_.

Referenced by gum::MultiDimWithOffset< GUM_ELEMENT >::unregisterSlave().

Here is the caller graph for this function:

value()

template<typename GUM_ELEMENT>

const GUM_ELEMENT & gum::ExactTerminalNodePolicy< GUM_ELEMENT >::value ( ) const

overridevirtualinherited

Returns the value of the current terminal nodes pointed by the constant safe iterator.

Implements gum::ITerminalNodePolicy< GUM_ELEMENT >.

Definition at line 102 of file ExactTerminalNodePolicy_tpl.h.

                                                                         {
    return _mappy_.second();
  }

References _mappy_.

Referenced by gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::set().

Here is the caller graph for this function:

variable() [1/2]

template<typename GUM_ELEMENT>

const DiscreteVariable & gum::MultiDimImplementation< GUM_ELEMENT >::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

NotFound

Raised if i does not reference a variable in this multidimensional matrix.

Implements gum::MultiDimInterface.

Definition at line 192 of file multiDimImplementation_tpl.h.

                                                                                     {
    return *(_vars_.atPos(i));
  }

Referenced by gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::buildValue_(), gum::MultiDimWithOffset< GUM_ELEMENT >::computeInstantiationValue_(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::get(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::toString(), gum::MultiDimICIModel< GUM_ELEMENT >::toString(), gum::MultiDimNoisyAND< GUM_SCALAR >::toString(), gum::MultiDimNoisyORCompound< GUM_SCALAR >::toString(), and gum::MultiDimNoisyORNet< GUM_SCALAR >::toString().

Here is the caller graph for this function:

variable() [2/2]

template<typename GUM_ELEMENT>

const DiscreteVariable & gum::MultiDimImplementation< GUM_ELEMENT >::variable ( std::string_view name ) const

overridevirtualinherited

Returns the variable with the name.

Parameters

name	The index of the variable

Returns

Returns the variable qith the name in the tuple. @warging This function is not O(1)

Exceptions

NotFound

Raised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 198 of file multiDimImplementation_tpl.h.

                                                                               {
    for (const auto& v: _vars_) {
      if (v->name() == name) return *v;
    }
 
    GUM_ERROR(NotFound, "'" << name << "' can not be found in the multidim structure.")
  }

References name().

Here is the call graph for this function:

variablesSequence()

template<typename GUM_ELEMENT>

const Sequence< const DiscreteVariable * > & gum::MultiDimImplementation< GUM_ELEMENT >::variablesSequence ( ) const

overridevirtualinherited

Returns a const ref to the sequence of DiscreteVariable*.

Returns

Returns a const ref to the sequence of DiscreteVariable*.

Implements gum::MultiDimInterface.

Definition at line 220 of file multiDimImplementation_tpl.h.

                                                                     {
    return _vars_;
  }

References _vars_.

Referenced by gum::MultiDimBijArray< GUM_ELEMENT >::MultiDimBijArray(), gum::MultiDimBijArray< GUM_ELEMENT >::MultiDimBijArray(), gum::MultiDimBijArray< GUM_ELEMENT >::MultiDimBijArray(), gum::MultiDimFunctionGraphOperator< GUM_ELEMENT, FUNCTOR, TerminalNodePolicy >::_distance_(), gum::MultiDimFunctionGraphOperator< GUM_ELEMENT, FUNCTOR, TerminalNodePolicy >::_findRetrogradeVariables_(), gum::Regress< GUM_ELEMENT, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy >::_findRetrogradeVariables_(), gum::MultiDimBucket< GUM_ELEMENT >::_initializeBuffer_(), gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::add(), gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::clear(), gum::prm::copyTensor(), gum::MultiDimArray< GUM_ELEMENT >::erase(), gum::MultiDimWithOffset< GUM_ELEMENT >::erase(), gum::MultiDimFunctionGraphGenerator::generate(), gum::MDDOperatorStrategy< GUM_ELEMENT >::lastVar_(), gum::StructuredPlaner< GUM_ELEMENT >::makeArgMax_(), gum::TreeOperatorStrategy< GUM_ELEMENT >::regress(), and gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::varNodeListe().

Here is the caller graph for this function:

varNodeListe()

template<typename GUM_ELEMENT, template< class > class TerminalNodePolicy>

const LinkedList< NodeId > * gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::varNodeListe

(

const DiscreteVariable *

var

)

const

Returns the list of node associated to given variable.

Parameters

var	The variable for which the list of associated nodes is returned.

Returns

Returns the list of node associated to given variable

Definition at line 585 of file multiDimFunctionGraph_tpl.h.

                                             {
    if (!this->variablesSequence().exists(var))
      GUM_ERROR(InvalidArgument,
                "Var " << var->name() << " has not been inserted in the function graph")
    return _var2NodeIdMap_[var];
  }

References _var2NodeIdMap_, GUM_ERROR, gum::Variable::name(), gum::MultiDimImplementation< GUM_ELEMENT >::variablesSequence(), and varNodeListe().

Referenced by gum::MultiDimFunctionGraphGenerator::generate(), and varNodeListe().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_domainSize_

template<typename GUM_ELEMENT>

Size gum::MultiDimImplementation< GUM_ELEMENT >::_domainSize_

privateinherited

This MultiDimImplementation domain size.

Definition at line 329 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), domainSize(), and erase().

_internalChangeMethod_

template<typename GUM_ELEMENT>

_InternalChangeMethod_ gum::MultiDimImplementation< GUM_ELEMENT >::_internalChangeMethod_

privateinherited

The current change method.

Definition at line 323 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), beginMultipleChanges(), endMultipleChanges(), and isInMultipleChangeMethod_().

_internalChangeState_

template<typename GUM_ELEMENT>

_InternalChangeState_ gum::MultiDimImplementation< GUM_ELEMENT >::_internalChangeState_

privateinherited

The current change state.

Definition at line 326 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), _setNotCommitedChange_(), endMultipleChanges(), and isCommitNeeded_().

_internalNodeMap_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

HashTable< NodeId, InternalNode* > gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_internalNodeMap_

private

Associates each non-terminal node to a variable.

Definition at line 396 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), clear(), get(), isInternalNode(), node(), and toDot().

_isReduced_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

bool gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_isReduced_

private

Wheter the MultiDimFunctionGraphManager is reduced or not.

Definition at line 402 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), copy(), copyAndMultiplyByScalar(), copyAndReassign(), isReducedAndOrdered(), and manager().

_manager_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

MultiDimFunctionGraphManager< GUM_ELEMENT, TerminalNodePolicy >* gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_manager_

private

A reference to the manager that edits this function graph.

Definition at line 390 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), ~MultiDimFunctionGraph(), and manager().

_map_

template<typename GUM_ELEMENT>

Bijection< NodeId, GUM_ELEMENT > gum::ExactTerminalNodePolicy< GUM_ELEMENT >::_map_

privateinherited

Definition at line 135 of file ExactTerminalNodePolicy.h.

Referenced by addTerminalNode(), beginValues(), clearAllTerminalNodes(), eraseTerminalNode(), existsTerminalNodeWithId(), and existsTerminalNodeWithValue().

_mappy_

template<typename GUM_ELEMENT>

BijectionIteratorSafe< NodeId, GUM_ELEMENT > gum::ExactTerminalNodePolicy< GUM_ELEMENT >::_mappy_

mutableprivateinherited

Definition at line 136 of file ExactTerminalNodePolicy.h.

Referenced by beginValues(), id(), nextValue(), and value().

_model_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

NodeGraphPart gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_model_

private

Indicates available nodeIds.

Definition at line 387 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), clear(), model(), and toDot().

_name_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

std::string gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_name_

private

The name of the data structure.

Definition at line 381 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), and name().

_root_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

NodeId gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_root_

private

The root node of the function graph.

Definition at line 393 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), get(), and root().

_slaveInstantiations_

template<typename GUM_ELEMENT>

List< Instantiation* > gum::MultiDimImplementation< GUM_ELEMENT >::_slaveInstantiations_

privateinherited

List of instantiations of the tuples (sequences) of variables.

Definition at line 314 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), ~MultiDimImplementation(), slaves_(), and unregisterSlave().

_tableName_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

std::string gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_tableName_

private

The name of the data structure.

Definition at line 384 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), setTableName(), tableName(), and toDot().

_var2NodeIdMap_

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

HashTable< const DiscreteVariable*, LinkedList< NodeId >* > gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::_var2NodeIdMap_

private

Mapping between var and node.

Definition at line 399 of file multiDimFunctionGraph.h.

Referenced by MultiDimFunctionGraph(), MultiDimFunctionGraph(), add(), clear(), erase(), and varNodeListe().

_vars_

template<typename GUM_ELEMENT>

Sequence< const DiscreteVariable* > gum::MultiDimImplementation< GUM_ELEMENT >::_vars_

privateinherited

List of discrete variables (dimensions).

Definition at line 311 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), add(), contains(), empty(), erase(), invert_(), nbrDim(), registerSlave(), replace_(), and variablesSequence().

defaultValue

template<typename GUM_ELEMENT, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>

const GUM_ELEMENT gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::defaultValue

static

Only for proper initialization of a certain returned value.

Definition at line 95 of file multiDimFunctionGraph.h.

---

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

• agrum/base/multidim/implementations/multiDimFunctionGraph.h
• agrum/base/multidim/implementations/multiDimFunctionGraph_tpl.h