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

Class implementingting a function graph. More...

#include <multiDimFunctionGraph.h>

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

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

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

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

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

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

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

Detailed Description

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

Class implementingting a function graph.

Warning

Doxygen does not like spanning command on multiple line, so we could not configure it with the correct include directive. Use the following code snippet to include this file.

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

Template Parameters

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

Definition at line 81 of file multiDimFunctionGraph.h.

Constructor & Destructor Documentation

MultiDimFunctionGraph() [1/2]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

private

Default constructor.

Parameters

isReduced

If true, then this MultiDimFunctionGraph is reduced.

Definition at line 37 of file multiDimFunctionGraph_tpl.h.

                                           :
      MultiDimImplementation< GUM_SCALAR >(),
      __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();
  }

MultiDimFunctionGraph() [2/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

INLINE gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::MultiDimFunctionGraph

(

const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &

from

)

Copy constructor.

Parameters

from	The MultiDimFunctionGraph to copy.

Definition at line 51 of file multiDimFunctionGraph_tpl.h.

                                                                             :
      MultiDimImplementation< GUM_SCALAR >(),
      __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);
  }

~MultiDimFunctionGraph()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::~MultiDimFunctionGraph

(

)

Class destructor.

Definition at line 73 of file multiDimFunctionGraph_tpl.h.

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

Member Function Documentation

_commitMultipleChanges() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::MultiDimImplementation< GUM_SCALAR >::_commitMultipleChanges ( )

protectedvirtualinherited

Synchronize content after MultipleChanges.

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

Definition at line 255 of file multiDimImplementation_tpl.h.

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

                                                                           {
    // empty!
  }

Here is the caller graph for this function:

_commitMultipleChanges() [2/2]

template<typename GUM_SCALAR>

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

protectedvirtualinherited

Synchronize content after MultipleChanges.

Parameters

value

Default value for uninitialized values.

Reimplemented in gum::MultiDimArray< GUM_SCALAR >.

Definition at line 260 of file multiDimImplementation_tpl.h.

                        {
    // empty!
  }

_get()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE GUM_SCALAR & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::_get ( const Instantiation &  inst ) const

protectedvirtual

Warning

This will raise an OperationNotAllowed as you should not use this method as MultiDimFunctionGraph use its own internal structure for storing data.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 660 of file multiDimFunctionGraph_tpl.h.

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

_invert()

template<typename GUM_SCALAR >

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

protectedvirtualinherited

Inverts variables at position p1 and p2.

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

Parameters

p1	The first position.
p2	The second position.

Definition at line 319 of file multiDimImplementation_tpl.h.

                                                                          {
    __vars.swap(p1, p2);
  }

_isCommitNeeded()

template<typename GUM_SCALAR >

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

protectedinherited

Get the actual state of *this.

Returns

Returns true if a commit is needed.

Definition at line 274 of file multiDimImplementation_tpl.h.

                                                                          {
    return (__internalChangeState == __InternalChangeState::NOT_COMMITTED_CHANGE);
  }

_isInMultipleChangeMethod()

template<typename GUM_SCALAR >

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

protectedinherited

Get the actual change method of this MultiDimImplementation.

Returns

Returns true if in multiple changes.

Definition at line 268 of file multiDimImplementation_tpl.h.

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

                                                                           {
    return (__internalChangeMethod == __InternalChangeMethod::MULTIPLE_CHANGE);
  }

Here is the caller graph for this function:

_replace()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::_replace ( const DiscreteVariable *  x, const DiscreteVariable *  y  )

protectedvirtual

Warning

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

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 654 of file multiDimFunctionGraph_tpl.h.

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

_slaves()

template<typename GUM_SCALAR >

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

protectedinherited

Returns a constant reference over the list of slaved instantiations.

Returns

Returns a constant reference over the list of slaved instantiations.

Definition at line 281 of file multiDimImplementation_tpl.h.

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

                                                                   {
    return __slaveInstantiations;
  }

Here is the caller graph for this function:

add()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

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

See also

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

Warning

Note that the variable passed in argument is not duplicated, that is, only a pointer toward the variable is kept by the MultiDimInterface.

Parameters

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.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 137 of file multiDimFunctionGraph_tpl.h.

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

                                {
    if (!this->variablesSequence().exists(&v))
      MultiDimImplementation< GUM_SCALAR >::add(v);

    if (!this->__var2NodeIdMap.exists(&v))
      __var2NodeIdMap.insert(&v, new LinkedList< NodeId >());
  }

Here is the caller graph for this function:

apply()

template<typename GUM_SCALAR >

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

virtualinherited

Apply a function on every element of the container.

Parameters

f	the function to apply

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

Definition at line 196 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

basename()

template<typename GUM_SCALAR >

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

inherited

Returns the base class name of this MultiDimImplementation.

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

Definition at line 299 of file multiDimImplementation_tpl.h.

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

beginMultipleChanges()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimImplementation< GUM_SCALAR >::beginMultipleChanges ( )

overridevirtualinherited

Call this method before doing important changes in this MultiDimContainer.

Warning

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 229 of file multiDimImplementation_tpl.h.

                                                                         {
    __internalChangeMethod = __InternalChangeMethod::MULTIPLE_CHANGE;
  }

changeNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Listen to changes in a given Instantiation.

Parameters

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

Implements gum::MultiDimAdressable.

Definition at line 170 of file multiDimFunctionGraph_tpl.h.

                                              {}

clear()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::clear

(

)

Clears the function graph.

Definition at line 422 of file multiDimFunctionGraph_tpl.h.

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

                                                                             {
    __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);
    }
  }

Here is the caller graph for this function:

compressionRate()

template<typename GUM_SCALAR >

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

inherited

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

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

Warning

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

Returns

Returns the compression ration of the table.

Definition at line 293 of file multiDimImplementation_tpl.h.

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

contains()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns true if var is in *this.

Parameters

v	A DiscreteVariable.

Returns

Returns true if var is in *this.

Implements gum::MultiDimInterface.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 208 of file multiDimImplementation_tpl.h.

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

                                      {
    return __vars.exists(&v);
  }

Here is the caller graph for this function:

content() [1/2]

template<typename GUM_SCALAR >

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

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 342 of file multiDimImplementation_tpl.h.

                                                                   {
    return this;
  }

content() [2/2]

template<typename GUM_SCALAR >

INLINE MultiDimImplementation< GUM_SCALAR > * gum::MultiDimImplementation< GUM_SCALAR >::content ( )

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 335 of file multiDimImplementation_tpl.h.

                                                       {
    return this;
  }

copy() [1/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

virtual

Warning

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 218 of file multiDimFunctionGraph_tpl.h.

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

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

Here is the caller graph for this function:

copy() [2/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::copy

(

const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &

src

)

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

Parameters

src	The MultiDimFunctionGraph to copy.

Definition at line 226 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();
  }

copyAndMultiplyByScalar()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

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

Parameters

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

Definition at line 360 of file multiDimFunctionGraph_tpl.h.

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

                                                                              {
    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();
  }

Here is the caller graph for this function:

copyAndReassign()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

Copies src diagrams structure into this diagrams.

However it also changes the variables.

Warning

This has two implications:

• First, this is not just a renaming. Pointers are trully changed.
• Second, for each pair of variable, the new variable MUST macth the number of modalities of the old variable.

Parameters

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

Definition at line 288 of file multiDimFunctionGraph_tpl.h.

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

                     {
    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();
  }

Here is the caller graph for this function:

copyFrom() [1/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

virtual

Warning

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 210 of file multiDimFunctionGraph_tpl.h.

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

copyFrom() [2/2]

template<typename GUM_SCALAR >

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

virtualinherited

Basic copy of a MultiDimContainer.

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

Parameters

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_SCALAR >, gum::MultiDimICIModel< GUM_SCALAR >, and gum::MultiDimArray< GUM_SCALAR >.

Definition at line 265 of file multiDimContainer_tpl.h.

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

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

                                                       {
    if (src.domainSize() != domainSize()) {
      GUM_ERROR(OperationNotAllowed, "Domain sizes do not fit");
    }

    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]);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

defaultValue() [1/2]

template<>

const float gum::MultiDimFunctionGraph< float >::defaultValue

(

)

Definition at line 47 of file multiDimFunctionGraph.cpp.

defaultValue() [2/2]

template<>

const double gum::MultiDimFunctionGraph< double >::defaultValue

(

)

Definition at line 50 of file multiDimFunctionGraph.cpp.

domainSize()

template<typename GUM_SCALAR >

INLINE Size gum::MultiDimImplementation< GUM_SCALAR >::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 180 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimWithOffset< GUM_SCALAR >::_computeInstantiationValue(), gum::MultiDimWithOffset< GUM_SCALAR >::add(), gum::MultiDimArray< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimWithOffset< GUM_SCALAR >::changeNotification(), gum::MultiDimICIModel< GUM_SCALAR >::copyFrom(), gum::MultiDimArray< GUM_SCALAR >::erase(), gum::MultiDimBucket< GUM_SCALAR >::erase(), gum::MultiDimArray< GUM_SCALAR >::realSize(), gum::MultiDimBucket< GUM_SCALAR >::setBufferSize(), gum::MultiDimWithOffset< GUM_SCALAR >::setIncNotification(), and gum::MultiDimWithOffset< GUM_SCALAR >::setLastNotification().

                                                                     {
    return __domainSize;
  }

Here is the caller graph for this function:

empty()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns true if no var is in *this.

Returns

Returns true if no var is in *this.

Implements gum::MultiDimInterface.

Definition at line 223 of file multiDimImplementation_tpl.h.

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

                                                                {
    GUM_ASSERT(!this->_isCommitNeeded());
    return __vars.empty();
  }

Here is the caller graph for this function:

endMultipleChanges() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::MultiDimImplementation< GUM_SCALAR >::endMultipleChanges ( )

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 234 of file multiDimImplementation_tpl.h.

                                                                       {
    if (__internalChangeState == __InternalChangeState::NOT_COMMITTED_CHANGE) {
      _commitMultipleChanges();
      __internalChangeState = __InternalChangeState::NO_CHANGE;
    }

    __internalChangeMethod = __InternalChangeMethod::DIRECT_CHANGE;
  }

endMultipleChanges() [2/2]

template<typename GUM_SCALAR>

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

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 244 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_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Removes a var from the variables of the multidimensional matrix.

See also

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

Exceptions

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

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 147 of file multiDimFunctionGraph_tpl.h.

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

                                {
    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_SCALAR >::erase(v);
  }

Here is the caller graph for this function:

extractFrom()

template<typename GUM_SCALAR >

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

virtualinherited

Basic extraction of a MultiDimContainer.

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

Parameters

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

Definition at line 240 of file multiDimContainer_tpl.h.

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

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

                                                                             {
    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));
    }

    if (this->nbrDim() == 0) { GUM_ERROR(FatalError, "Empty potential"); }

    this->endMultipleChanges();

    Instantiation inst(src);
    inst.setVals(imask);
    for (inst.setFirstOut(imask); !inst.end(); inst.incOut(imask))
      set(inst, src[inst]);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

fill()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

virtual

Warning

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 108 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.")
  }

get()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Returns the value pointed by i.

Warning

If i variables set is disjoint with this MultiDimContainer then 0 is assumed for dimensions (i.e. variables) not present in the instantiation.

Parameters

i	An Instantiation of this MultiDimContainer.

Returns

Returns the value pointe by i.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 668 of file multiDimFunctionGraph_tpl.h.

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

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

Here is the caller graph for this function:

getMasterRef() [1/2]

template<typename GUM_SCALAR >

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

virtualinherited

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

Returns

Returns the ref to content as MultiDimAdressable&

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 301 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

getMasterRef() [2/2]

template<typename GUM_SCALAR >

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

virtualinherited

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

Returns

Returns the master of this MultiDimAdressable.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 307 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

getReducedAndOrderedInstance()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance ( )

static

Returns a reduced and ordered instance.

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

Returns

Returns a reduced and ordered instance.

Definition at line 641 of file multiDimFunctionGraph_tpl.h.

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

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

Here is the caller graph for this function:

getTreeInstance()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getTreeInstance ( )

static

Returns an arborescent instance.

Returns

Returns an arborescent instance

Definition at line 648 of file multiDimFunctionGraph_tpl.h.

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

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

Here is the caller graph for this function:

isInternalNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::isInternalNode

(

const NodeId &

node

)

const

Indicates if given node is terminal or not.

Parameters

node	The node to test for being itnernal.

Returns

Returns true if node is internal.

Definition at line 575 of file multiDimFunctionGraph_tpl.h.

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

isReducedAndOrdered()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::isReducedAndOrdered

(

)

const

Returns true if this MultiDimFunctionGraph is reduced and Ordered.

Returns

Returns true if this MultiDimFunctionGraph is reduced and Ordered.

Definition at line 632 of file multiDimFunctionGraph_tpl.h.

              {
    return __isReduced;
  }

isTerminalNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::isTerminalNode

(

const NodeId &

node

)

const

Indicates if given node is terminal or not.

Parameters

node	The node to test for terminality.

Returns

Returns true if node is terminal.

Definition at line 567 of file multiDimFunctionGraph_tpl.h.

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

                                  {
    return this->existsTerminalNodeWithId(node);
  }

Here is the caller graph for this function:

manager()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager

(

)

Returns a const reference to the manager of this diagram.

Returns

Returns a const reference to the manager of this diagram

Definition at line 543 of file multiDimFunctionGraph_tpl.h.

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

                                                                          {
    if (__manager == nullptr) {
      if (__isReduced)
        __manager =
           new MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >(
              this);
      else
        __manager =
           new MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >(
              this);
    }
    return __manager;
  }

Here is the caller graph for this function:

model()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE const NodeGraphPart & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::model

(

)

const

Returns a const reference to the manager of this diagram.

Returns

Returns a const reference to the manager of this diagram

Definition at line 536 of file multiDimFunctionGraph_tpl.h.

                                                                                    {
    return __model;
  }

name()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Returns the real name of the multiDim implementation.

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

Returns

Returns the real name of the multiDim implementation

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 93 of file multiDimFunctionGraph_tpl.h.

                                                                                   {
    return __name;
  }

nbrDim()

template<typename GUM_SCALAR >

INLINE Idx gum::MultiDimImplementation< GUM_SCALAR >::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 175 of file multiDimImplementation_tpl.h.

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

                                                                {
    return __vars.size();
  }

Here is the caller graph for this function:

newFactory()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Creates an empty clone of this MultiDimContainer.

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

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

Then x is a MultiDimArray<double>*.

Warning

You must free by yourself the returned pointer.

Returns

Returns an empty clone of this object with the same type.

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 82 of file multiDimFunctionGraph_tpl.h.

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

node()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE const InternalNode * gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::node

(

NodeId

n

)

const

Returns internalNode structure associated to that nodeId.

Parameters

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

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

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

Here is the caller graph for this function:

nodeValue()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE const GUM_SCALAR & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::nodeValue

(

NodeId

n

)

const

Returns value associated to given node.

Parameters

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

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

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

Here is the caller graph for this function:

operator!=()

template<typename GUM_SCALAR >

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

inherited

Test if this MultiDimContainer is different of p.

Parameters

p	The MultiDimContainer to test for inequality.

Returns

Returns true if this MultiDimContainer is different of p.

Definition at line 160 of file multiDimContainer_tpl.h.

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

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

                                                                         {
    return !operator==(p);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

INLINE MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::operator=

(

const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > &

from

)

Copy Operator.

Parameters

from	The MultiDimFunctionGraph to copy.

Returns

Returns this MultiDimFunctionGraph.

Definition at line 64 of file multiDimFunctionGraph_tpl.h.

                                                                             {
    copy(from);
    return *this;
  }

operator==()

template<typename GUM_SCALAR >

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

inherited

Test if this MultiDimContainer is equal to p.

Parameters

p	The MultiDimContainer to test for equality.

Returns

Returns true if this MultiDimContainer is equal to p.

Definition at line 129 of file multiDimContainer_tpl.h.

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

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

                                                                  {
    if ((nbrDim() == p.nbrDim()) && (domainSize() == p.domainSize())) {
      if (nbrDim() == 0) return true;

      typedef Sequence< const DiscreteVariable* >::const_iterator_safe
         var_iterator;

      for (var_iterator iter = variablesSequence().beginSafe();
           iter != variablesSequence().endSafe();
           ++iter) {
        if (!p.variablesSequence().exists(*iter)) { return false; }
      }
    } else {
      return false;
    }

    Instantiation i(*this);

    AlmostDifferent< GUM_SCALAR > cmp;

    for (i.setFirst(); !i.end(); ++i) {
      if (cmp(get(i), p.get(i))) { return false; }
    }

    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

operator[]()

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::MultiDimContainer< GUM_SCALAR >::operator[] ( const Instantiation &  i ) const

inherited

An [] operator using a Instantiation as argument.

Warning

If i variables set is disjoint with this MultiDimContainer then 0 is assumed for dimensions (i.e. variables) not prensent in the instantiation.

Parameters

i	An Instantiation.

Returns

Returns the adressed (GUM_SCALAR) value.

Definition at line 82 of file multiDimContainer_tpl.h.

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

                                                             {
    return get(i);
  }

Here is the caller graph for this function:

populate() [1/2]

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

virtual

Warning

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 118 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_SCALAR, template< class > class TerminalNodePolicy>

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

virtual

Warning

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 127 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.")
  }

pos()

template<typename GUM_SCALAR >

INLINE Idx gum::MultiDimImplementation< GUM_SCALAR >::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 203 of file multiDimImplementation_tpl.h.

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

                                                                                  {
    return __vars.pos(&v);
  }

Here is the caller graph for this function:

realSize()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Returns the real number of parameters used for this table.

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

See also

MultiDimImplementation::compressionRate()

Returns

Returns the real number of parameters used for this table.

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 163 of file multiDimFunctionGraph_tpl.h.

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

                                                                                 {
    return __internalNodeMap.size();   // + __valueMap.size();
  }

Here is the caller graph for this function:

reduce()

template<typename GUM_SCALAR >

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

virtualinherited

compute lfold for this container

Parameters

f	the function to apply
base	the initial value

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

Definition at line 205 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

registerSlave()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Register i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to enslave.

Returns

Returns true if i becomes a slave of this MultiDimAdressable.

Implements gum::MultiDimAdressable.

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

Definition at line 147 of file multiDimImplementation_tpl.h.

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

                                                                             {
    // 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;
  }

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 36 of file multiDimInterface_inl.h.

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

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

                                                             {
    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);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

root()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE const NodeId & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::root

(

)

const

Returns the id of the root node from the diagram.

Returns

Returns the id of the root node from the diagram

Definition at line 560 of file multiDimFunctionGraph_tpl.h.

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

                                                                                   {
    return __root;
  }

Here is the caller graph for this function:

set()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

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

virtual

Warning

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 98 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.")
  }

setChangeNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Listen to an assignment of a value in a Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 198 of file multiDimFunctionGraph_tpl.h.

{}

setDecNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Listen to increment in each recorded Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 193 of file multiDimFunctionGraph_tpl.h.

                                {}

setFirstNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Listen to setFirst in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 178 of file multiDimFunctionGraph_tpl.h.

                                {}

setIncNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Listen to increment in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 188 of file multiDimFunctionGraph_tpl.h.

                                {}

setLastNotification()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Listen to setLast in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 183 of file multiDimFunctionGraph_tpl.h.

                                {}

setTableName()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setTableName

(

const std::string &

name

)

Sets the name of the table represented by this structure.

Parameters

name	the new name of this structure.

Definition at line 624 of file multiDimFunctionGraph_tpl.h.

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

                               {
    __tableName = name;
  }

Here is the caller graph for this function:

tableName()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE const std::string & gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::tableName

(

)

const

Returns the name of the table represented by this structure.

Returns

Returns the name of the table represented by this structure.

Definition at line 617 of file multiDimFunctionGraph_tpl.h.

                                                                                        {
    return __tableName;
  }

toDot()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::toDot

(

bool

withBackArcs = false

)

const

Returns a const reference to the manager of this diagram.

Parameters

withBackArcs

If true, back arcs will be added.

Returns

Returns a const reference to the manager of this diagram

Definition at line 458 of file multiDimFunctionGraph_tpl.h.

                                 {
    std::stringstream output;
    std::stringstream terminalStream;
    std::stringstream nonTerminalStream;
    std::stringstream arcstream;
    //      std::stringstream defaultarcstream;
    output << std::endl << "digraph \" " << __tableName << "\" {" << std::endl;

    terminalStream << "node [shape = box];" << std::endl;
    nonTerminalStream << "node [shape = ellipse];" << std::endl;
    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) << "\"]"
                         << ";" << std::endl;
        else {
          InternalNode* currentNode = __internalNodeMap[*nodeIter];
          nonTerminalStream << tab << *nodeIter << ";" << tab << *nodeIter
                            << " [label=\"" << *nodeIter << " - "
                            << currentNode->nodeVar()->name() << "\"]"
                            << ";" << std::endl;

          //              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\"]"
                      << ";" << std::endl;
            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\"]"
                        << ";" << std::endl;
              parentIter = parentIter->nextLink();
            }
          }
        }
      }

    output << terminalStream.str() << std::endl
           << nonTerminalStream.str() << std::endl
           << arcstream.str() << std::endl
           << "}" << std::endl;

    return output.str();
  }

toString() [1/2]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

virtual

Display the internal representation of i.

Returns

Returns an internal representation of i.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 202 of file multiDimFunctionGraph_tpl.h.

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

toString() [2/2]

template<typename GUM_SCALAR >

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

virtualinherited

Returns a representation of this MultiDimContainer.

Returns

Returns a representation of this MultiDimContainer.

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

Definition at line 105 of file multiDimContainer_tpl.h.

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

Referenced by gum::operator<<().

                                                                  {
    // 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();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

unregisterSlave()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Unregister i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to free.

Returns

Returns true, whatever happens.

Implements gum::MultiDimAdressable.

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

Definition at line 168 of file multiDimImplementation_tpl.h.

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

                                                                               {
    __slaveInstantiations.eraseByVal(&slave);
    // TODO This method should return true? Why not use a void instead?
    return true;
  }

Here is the caller graph for this function:

variable() [1/2]

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns a const ref to the ith var.

param i An index of this multidimensional matrix.

Returns

Returns a const ref to the ith var.

Exceptions

NotFound

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

Implements gum::MultiDimInterface.

Definition at line 186 of file multiDimImplementation_tpl.h.

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

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

Here is the caller graph for this function:

variable() [2/2]

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns the variable with the name.

Parameters

name	The index of the variable

Returns

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

Exceptions

NotFound

Raised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 191 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.")
  }

variablesSequence()

template<typename GUM_SCALAR >

INLINE const Sequence< const DiscreteVariable *> & gum::MultiDimImplementation< GUM_SCALAR >::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 217 of file multiDimImplementation_tpl.h.

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::__fillCpf(), gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::ITI< AttributeSelection, isScalar >::__insertNodeInFunctionGraph(), gum::ITI< AttributeSelection, isScalar >::__insertTerminalNode(), gum::StructuredPlaner< double >::_makeArgMax(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copy(), gum::prm::copyPotential(), gum::MultiDimWithOffset< GUM_SCALAR >::erase(), gum::MultiDimArray< GUM_SCALAR >::erase(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::insertSetOfVars(), gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray(), and gum::TreeOperatorStrategy< GUM_SCALAR >::regress().

                                                                             {
    return __vars;
  }

Here is the caller graph for this function:

varNodeListe()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

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

(

const DiscreteVariable *

var

)

const

Returns the list of node associated to given variable.

Parameters

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

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

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

Here is the caller graph for this function:

Member Data Documentation

__internalNodeMap

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

HashTable< NodeId, InternalNode* > gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__internalNodeMap

private

Associates each non-terminal node to a variable.

Definition at line 389 of file multiDimFunctionGraph.h.

__isReduced

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

bool gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__isReduced

private

Wheter the MultiDimFunctionGraphManager is reduced or not.

Definition at line 395 of file multiDimFunctionGraph.h.

__manager

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

MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >* gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__manager

private

A reference to the manager that edits this function graph.

Definition at line 383 of file multiDimFunctionGraph.h.

__model

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

NodeGraphPart gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__model

private

Indicates available nodeIds.

Definition at line 380 of file multiDimFunctionGraph.h.

__name

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

std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__name

private

The name of the data structure.

Definition at line 374 of file multiDimFunctionGraph.h.

__root

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

NodeId gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__root

private

The root node of the function graph.

Definition at line 386 of file multiDimFunctionGraph.h.

__tableName

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

std::string gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__tableName

private

The name of the data structure.

Definition at line 377 of file multiDimFunctionGraph.h.

__var2NodeIdMap

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

HashTable< const DiscreteVariable*, LinkedList< NodeId >* > gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::__var2NodeIdMap

private

Mapping between var and node.

Definition at line 392 of file multiDimFunctionGraph.h.

defaultValue

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

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

static

Only for proper initialization of a certain returned value.

Definition at line 86 of file multiDimFunctionGraph.h.

---

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

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