<agrum/multidim/aggregators/multiDimAggregator.h> More...

#include <multiDimAggregator.h>

Inheritance diagram for gum::aggregator::MultiDimAggregator< GUM_SCALAR >:

Collaboration diagram for gum::aggregator::MultiDimAggregator< GUM_SCALAR >:

Public Member Functions
virtual MultiDimContainer< GUM_SCALAR > *	newFactory () const override=0
	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() More...

Constructors / Destructors
	MultiDimAggregator ()
	Default constructor. More...

	MultiDimAggregator (const MultiDimAggregator< GUM_SCALAR > &from)
	Copy constructor. More...

virtual	~MultiDimAggregator ()
	Class destructor. More...

Accessors / Modifiers
virtual GUM_SCALAR	get (const Instantiation &i) const override

virtual std::string	aggregatorName () const =0

const std::string	toString () const override

void	changeNotification (const gum::Instantiation &, const gum::DiscreteVariable *const, gum::Idx, gum::Idx) override

void	setFirstNotification (const gum::Instantiation &) override

void	setLastNotification (const gum::Instantiation &) override

void	setIncNotification (const gum::Instantiation &) override

void	setDecNotification (const gum::Instantiation &) override

void	setChangeNotification (const gum::Instantiation &) override

const std::string	toString (const gum::Instantiation *i) const override

Size	realSize () const override

const std::string &	name () const override
	Returns the real name of the multiDimArray. More...

void	copyFrom (const MultiDimContainer< GUM_SCALAR > &src) const override
	Copy of a multiDimICIModel. More...

Accessors / Modifiers
virtual void	set (const Instantiation &i, const GUM_SCALAR &value) const

virtual void	fill (const GUM_SCALAR &) const

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 void	add (const DiscreteVariable &v) override
	Adds a new var to the variables of the multidimensional matrix. More...

virtual void	erase (const DiscreteVariable &v) override
	Removes a var from the variables of the multidimensional matrix. 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...

virtual void	populate (const std::vector< GUM_SCALAR > &v) const
	Automatically fills this MultiDimContainer with the values in v. More...

virtual void	populate (std::initializer_list< GUM_SCALAR > l) const
	Automatically fills this MultiDimContainer with the values in l. More...

Copy methods.
virtual void	copyFrom (const MultiDimContainer< GUM_SCALAR > &src, Instantiation *p_i) 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...

virtual void	copy (const MultiDimContainer< GUM_SCALAR > &src)
	Removes all variables in this MultiDimContainer and copy the content of src, variables included. More...

Various methods.
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...

Protected Member Functions
virtual Idx	_buildValue (const gum::Instantiation &i) const
	by default, _buildValue uses a "fold" scheme and the user has to implement _neutralElt and _fold but if necessary (as for Median), _buildValue can be reimplemented. More...

virtual Idx	_neutralElt () const =0
	_neutralElt() is the result value for the first application of _fold More...

virtual Idx	_fold (const DiscreteVariable &v, Idx i1, Idx i2, bool &stop_iteration) const =0
	_fold is applied on value i1 for variable v. the actual result for precedent applications is i2. More...

virtual GUM_SCALAR &	_get (const Instantiation &i) 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	_replace (const DiscreteVariable x, const DiscreteVariable y) override
	Replace variable x by y. More...

virtual void	_invert (Idx p1, Idx p2)
	Inverts variables at position p1 and p2. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::aggregator::MultiDimAggregator< GUM_SCALAR >

Abstract base class for all multi dimensionnal aggregator.

The principle of a deterministic aggregator is that \(P[i,J_1,\cdots,J_n]=1 \iff i==f(J_1,f(J_2,\cdots,f(J_n,NeutraElement)\cdots))\) and 0 otherwise. f is a virtual function called the folder function (like folder_left or folder_right in OCaml). NeutralElement is an Idx

Warning

the way aggregators are implemented assumed that the FIRST variable in the multiDim is the aggregator variable.
the way aggregators are implemented does not check types and domain size (e.g domain(folder function)==domain(aggregator variable)). However, \(f(J_1,f(J_2,\cdots,f(J_n,NeutraElement)\cdots))\) is truncated in order to fit in domain(aggregator variable).

Definition at line 64 of file multiDimAggregator.h.

Constructor & Destructor Documentation

◆ MultiDimAggregator() [1/2]

template<typename GUM_SCALAR >

INLINE gum::aggregator::MultiDimAggregator< GUM_SCALAR >::MultiDimAggregator ( )

Default constructor.

Definition at line 38 of file multiDimAggregator_tpl.h.

                                                                 :
         MultiDimReadOnly< GUM_SCALAR >() {
       GUM_CONSTRUCTOR(MultiDimAggregator);
     }

◆ MultiDimAggregator() [2/2]

template<typename GUM_SCALAR >

INLINE gum::aggregator::MultiDimAggregator< GUM_SCALAR >::MultiDimAggregator ( const MultiDimAggregator< GUM_SCALAR > & from )

Copy constructor.

Definition at line 45 of file multiDimAggregator_tpl.h.

                                                      :
         MultiDimReadOnly< GUM_SCALAR >(from) {
       GUM_CONS_CPY(MultiDimAggregator);
     }

◆ ~MultiDimAggregator()

template<typename GUM_SCALAR >

INLINE gum::aggregator::MultiDimAggregator< GUM_SCALAR >::~MultiDimAggregator ( )

virtual

Class destructor.

Definition at line 53 of file multiDimAggregator_tpl.h.

                                                                  {
       GUM_DESTRUCTOR(MultiDimAggregator);
     }

Member Function Documentation

◆ _buildValue()

template<typename GUM_SCALAR >

Idx gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue ( const gum::Instantiation & i ) const

protectedvirtual

by default, _buildValue uses a "fold" scheme and the user has to implement _neutralElt and _fold but if necessary (as for Median), _buildValue can be reimplemented.

Reimplemented in gum::aggregator::Median< GUM_SCALAR >, and gum::aggregator::Amplitude< GUM_SCALAR >.

Definition at line 58 of file multiDimAggregator_tpl.h.

References gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_fold(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_neutralElt(), gum::MultiDimImplementation< GUM_SCALAR >::nbrDim(), gum::Instantiation::val(), and gum::MultiDimImplementation< GUM_SCALAR >::variable().

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::get(), and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::realSize().

                                      {
       if (this->nbrDim() == 1) return _neutralElt();
 
       // is i equal to f(f(f(f...(j_,neutral_elt))))
       Idx current = _neutralElt();
 
       bool stop_iteration = false;
 
       for (Idx j = 1; j < this->nbrDim(); j++) {
         current = _fold(
            this->variable(j), i.val(this->variable(j)), current, stop_iteration);
 
         if (stop_iteration) break;
       }
 
       return current;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _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!
   }

◆ _fold()

template<typename GUM_SCALAR>

virtual Idx gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_fold	(	const DiscreteVariable &	v,
		Idx	i1,
		Idx	i2,
		bool &	stop_iteration
	)		const

protectedpure virtual

_fold is applied on value i1 for variable v. the actual result for precedent applications is i2.

Returns: the new result for applications up to v.

Implemented in gum::aggregator::Median< GUM_SCALAR >, gum::aggregator::Amplitude< GUM_SCALAR >, gum::aggregator::Count< GUM_SCALAR >, gum::aggregator::Or< GUM_SCALAR >, gum::aggregator::And< GUM_SCALAR >, gum::aggregator::Forall< GUM_SCALAR >, gum::aggregator::Max< GUM_SCALAR >, gum::aggregator::Exists< GUM_SCALAR >, and gum::aggregator::Min< GUM_SCALAR >.

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue(), and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::realSize().

Here is the caller graph for this function:

◆ _get()

template<typename GUM_SCALAR >

GUM_SCALAR & gum::MultiDimReadOnly< GUM_SCALAR >::_get ( const Instantiation & i ) const

protectedvirtualinherited

Warning: An OperationNotAllowed will be raised because this is a read only table.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 74 of file multiDimReadOnly_tpl.h.

References GUM_ERROR.

                                                                                {
     GUM_ERROR(OperationNotAllowed, "No (unconst) access to an aggregator");
   }

◆ _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:

◆ _neutralElt()

template<typename GUM_SCALAR>

virtual Idx gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_neutralElt ( ) const

protectedpure virtual

_neutralElt() is the result value for the first application of _fold

Implemented in gum::aggregator::Median< GUM_SCALAR >, gum::aggregator::Amplitude< GUM_SCALAR >, gum::aggregator::Count< GUM_SCALAR >, gum::aggregator::Or< GUM_SCALAR >, gum::aggregator::And< GUM_SCALAR >, gum::aggregator::Forall< GUM_SCALAR >, gum::aggregator::Max< GUM_SCALAR >, gum::aggregator::Exists< GUM_SCALAR >, and gum::aggregator::Min< GUM_SCALAR >.

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue(), and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::realSize().

Here is the caller graph for this function:

◆ _replace()

template<typename GUM_SCALAR >

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

overrideprotectedvirtualinherited

Replace variable x by y.

Technically this should be call by any subclass overloading this method to proceed with the changes in this class containers.

Parameters

x	The first variable to swap.
y	The second variable to swap.

Implements gum::MultiDimInterface.

Definition at line 306 of file multiDimImplementation_tpl.h.

Referenced by gum::MultiDimSparse< GUM_SCALAR >::_replace(), gum::MultiDimICIModel< GUM_SCALAR >::_replace(), gum::MultiDimBijArray< GUM_SCALAR >::_replace(), gum::MultiDimArray< GUM_SCALAR >::_replace(), and gum::MultiDimBucket< GUM_SCALAR >::_replace().

                                                                                {
     __vars.setAtPos(__vars.pos(x), y);
 
     for (List< Instantiation* >::iterator_safe iter =
             __slaveInstantiations.beginSafe();
          iter != __slaveInstantiations.endSafe();
          ++iter) {
       (**iter).replace(*x, *y);
     }
   }

Here is the caller graph for this function:

◆ _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 >

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

overridevirtualinherited

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 77 of file multiDimImplementation_tpl.h.

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::_type(), gum::MultiDimWithOffset< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::prm::PRMFormAttribute< GUM_SCALAR >::addParent(), gum::prm::PRMFormAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copyCpf(), gum::prm::PRMFormAttribute< GUM_SCALAR >::PRMFormAttribute(), and gum::prm::PRMFormAttribute< GUM_SCALAR >::swap().

                                                                         {
     // check if the variable already belongs to the tuple of variables
     // of the Instantiation
     if (__vars.exists(&v)) {
       GUM_ERROR(DuplicateElement,
                 "Var " << v.name() << " already exists in this instantiation");
     }
     for (const auto& w : __vars) {
       if (w->name() == v.name())
         GUM_ERROR(DuplicateElement,
                   "A var with name '" << v.name()
                                       << "' already exists in this instantiation");
     }
 
     __domainSize *= v.domainSize();
 
     __vars.insert(&v);
 
     // informs all the slaves that they have to update themselves
     for (List< Instantiation* >::iterator_safe iter =
             __slaveInstantiations.beginSafe();
          iter != __slaveInstantiations.endSafe();
          ++iter) {
       (*iter)->addWithMaster(this, v);
     }
 
     if (_isInMultipleChangeMethod()) __setNotCommitedChange();
   }

Here is the caller graph for this function:

◆ aggregatorName()

template<typename GUM_SCALAR>

virtual std::string gum::aggregator::MultiDimAggregator< GUM_SCALAR >::aggregatorName ( ) const

pure virtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implemented in gum::aggregator::Or< GUM_SCALAR >, gum::aggregator::And< GUM_SCALAR >, gum::aggregator::Forall< GUM_SCALAR >, gum::aggregator::Max< GUM_SCALAR >, gum::aggregator::Exists< GUM_SCALAR >, gum::aggregator::Min< GUM_SCALAR >, gum::aggregator::Median< GUM_SCALAR >, gum::aggregator::Amplitude< GUM_SCALAR >, and gum::aggregator::Count< GUM_SCALAR >.

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString().

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>

void gum::aggregator::MultiDimAggregator< GUM_SCALAR >::changeNotification	(	const gum::Instantiation &	,
		const gum::DiscreteVariable *	const,
		gum::Idx	,
		gum::Idx
	)

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimAdressable.

Definition at line 118 of file multiDimAggregator.h.

121 {};

◆ 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()

template<typename GUM_SCALAR >

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

virtualinherited

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

Parameters

src	The MultiDimContainer to copy.

Reimplemented in gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >, gum::MultiDimFunctionGraph< GUM_SCALAR >, and gum::MultiDimFunctionGraph< GUM_SCALAR, ExactTerminalNodePolicy >.

Definition at line 282 of file multiDimContainer_tpl.h.

References gum::MultiDimInterface::add(), gum::MultiDimContainer< GUM_SCALAR >::beginMultipleChanges(), gum::MultiDimContainer< GUM_SCALAR >::copyFrom(), gum::MultiDimContainer< GUM_SCALAR >::endMultipleChanges(), gum::MultiDimInterface::erase(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variable().

Referenced by gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__eraseArc(), and gum::MCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::disturbBN().

                                                  {
     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++) {
       this->add(src.variable(i));
     }
 
     this->endMultipleChanges();
     this->copyFrom(src);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyFrom() [1/2]

template<typename GUM_SCALAR >

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

overridevirtual

Copy of a multiDimICIModel.

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

Exceptions

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 110 of file multiDimAggregator_tpl.h.

References gum::MultiDimContainer< GUM_SCALAR >::copyFrom(), GUM_ERROR, and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::name().

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::realSize().

                                                          {
       auto p = dynamic_cast< const MultiDimAggregator< GUM_SCALAR >* >(&src);
       if (p == nullptr) {
         MultiDimReadOnly< GUM_SCALAR >::copyFrom(src);
       } else {
         if (p->name() != this->name()) {
           GUM_ERROR(OperationNotAllowed,
                     "Can not copy from a " << p->name() << " to a "
                                            << this->name());
         }
       }
       // it the types aree consistant, nothing to do...
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyFrom() [2/2]

template<typename GUM_SCALAR >

void gum::MultiDimContainer< GUM_SCALAR >::copyFrom	(	const MultiDimContainer< GUM_SCALAR > &	src,
		Instantiation *	p_i
	)		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.
p_i	Give the order to iterate in this MultiDimContainer during the copy (nullptr will correctly copy if this is a reorganization of src).

Exceptions

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

Reimplemented in gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >, gum::MultiDimFunctionGraph< GUM_SCALAR >, and gum::MultiDimFunctionGraph< GUM_SCALAR, ExactTerminalNodePolicy >.

Definition at line 218 of file multiDimContainer_tpl.h.

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

                                                                            {
     if (src.domainSize() != domainSize()) {
       GUM_ERROR(OperationNotAllowed, "Domain sizes do not fit");
     }
 
     if (p_i == nullptr) {   // if null, we just follow the same order
       Instantiation i(src);
       for (i.setFirst(); !i.end(); ++i) {
         set(i, src[i]);
       }
     } else {
       Instantiation i_dest(*this);
       Instantiation i_src(src);
       for (i_dest.setFirst(), i_src.setFirst(); !i_dest.end();
            i_dest.incIn(*p_i), ++i_src) {
         set(i_dest, src[i_src]);
       }
     }
   }

Here is the call graph for this function:

◆ 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 >

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

overridevirtualinherited

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 110 of file multiDimImplementation_tpl.h.

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

                                                                           {
     // check that the variable does actually belong to the
     // MultiDimImplementation
     if (!__vars.exists(&v)) {
       GUM_ERROR(NotFound, "Var does not exist in this implementation");
     }
 
     __domainSize /= v.domainSize();
 
     __vars.erase(&v);
 
     // informs all the slaves that they have to update themselves
     for (List< Instantiation* >::iterator_safe iter =
             __slaveInstantiations.beginSafe();
          iter != __slaveInstantiations.endSafe();
          ++iter) {
       (*iter)->eraseWithMaster(this, v);
     }
 
     if (_isInMultipleChangeMethod()) __setNotCommitedChange();
   }

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 >

void gum::MultiDimReadOnly< GUM_SCALAR >::fill ( const GUM_SCALAR & ) const

virtualinherited

Warning: An OperationNotAllowed will be raised because this is a read only table.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 67 of file multiDimReadOnly_tpl.h.

References GUM_ERROR.

                                                                    {
     GUM_ERROR(OperationNotAllowed, "Write access to an aggregator");
   }

◆ get()

template<typename GUM_SCALAR >

GUM_SCALAR gum::aggregator::MultiDimAggregator< GUM_SCALAR >::get ( const Instantiation & i ) const

overridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 79 of file multiDimAggregator_tpl.h.

References gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue(), gum::DiscreteVariable::domainSize(), GUM_ERROR, gum::MultiDimImplementation< GUM_SCALAR >::nbrDim(), gum::Instantiation::val(), and gum::MultiDimImplementation< GUM_SCALAR >::variable().

                                                                          {
       if (this->nbrDim() < 1) {
         GUM_ERROR(OperationNotAllowed,
                   "Not enough variable for an aggregator : " << *this);
       }
 
       const DiscreteVariable& agg = this->variable((Idx)0);
       auto                    current = _buildValue(i);
 
       // truncate to fit in aggreegator domain size
       if (current >= agg.domainSize()) current = agg.domainSize() - 1;
 
       return (i.val(agg) == current) ? (GUM_SCALAR)1.0 : (GUM_SCALAR)0.0;
     }

Here is the call 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:

◆ name()

template<typename GUM_SCALAR >

const std::string & gum::aggregator::MultiDimAggregator< GUM_SCALAR >::name ( ) const

overridevirtual

Returns the real name of the multiDimArray.

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.

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 127 of file multiDimAggregator_tpl.h.

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::copyFrom(), and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::realSize().

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

Here is the caller graph for this function:

◆ 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>

virtual MultiDimContainer< GUM_SCALAR >* gum::aggregator::MultiDimAggregator< GUM_SCALAR >::newFactory ( ) const

overridepure virtual

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 desallocate by yourself the memory

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

Implements gum::MultiDimReadOnly< GUM_SCALAR >.

Implemented in gum::aggregator::Median< GUM_SCALAR >, gum::aggregator::Amplitude< GUM_SCALAR >, gum::aggregator::Count< GUM_SCALAR >, gum::aggregator::Or< GUM_SCALAR >, gum::aggregator::And< GUM_SCALAR >, gum::aggregator::Forall< GUM_SCALAR >, gum::aggregator::Max< GUM_SCALAR >, gum::aggregator::Exists< GUM_SCALAR >, and gum::aggregator::Min< GUM_SCALAR >.

◆ 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 >

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 >

void gum::MultiDimContainer< GUM_SCALAR >::populate ( const std::vector< GUM_SCALAR > & v ) const

virtualinherited

Automatically fills this MultiDimContainer with the values in v.

The order used to fill this MultiDimContainer is the same as with an instantiation over it.

Size cpt = 0;
Instantiation i( *this );
for (i.setFirst(); !i.end(); ++i, ++cpt) {
  set(i, v[cpt]);
}

Parameters

v	Vector of values.

Exceptions

SizeError Raised if v size's does not matches this MultiDimContainer domain size.

Reimplemented in gum::MultiDimDecorator< GUM_SCALAR >, gum::MultiDimBijArray< GUM_SCALAR >, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >, gum::MultiDimFunctionGraph< GUM_SCALAR >, and gum::MultiDimFunctionGraph< GUM_SCALAR, ExactTerminalNodePolicy >.

Definition at line 166 of file multiDimContainer_tpl.h.

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

                                              {
     if (domainSize() != v.size()) {
       GUM_ERROR(SizeError, "Sizes do not match in populate");
     }
 
     Size cpt = 0;
 
     Instantiation i(*this);
 
     for (i.setFirst(); !i.end(); ++i, ++cpt)
       set(i, v[cpt]);
   }

Here is the call graph for this function:

◆ populate() [2/2]

template<typename GUM_SCALAR >

void gum::MultiDimContainer< GUM_SCALAR >::populate ( std::initializer_list< GUM_SCALAR > l ) const

virtualinherited

Automatically fills this MultiDimContainer with the values in l.

The order used to fill this MultiDimContainer is the same as with an instantiation over it.

Size cpt = 0;
Instantiation i( *this );
for (i.setFirst(); !i.end(); ++i, ++cpt) {
  set(i, v[cpt]);
}

Parameters

l	contains the data.

Exceptions

SizeError Raised if l size's does not matches this MultiDimContainer domain size.

Reimplemented in gum::MultiDimBijArray< GUM_SCALAR >, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >, gum::MultiDimFunctionGraph< GUM_SCALAR >, and gum::MultiDimFunctionGraph< GUM_SCALAR, ExactTerminalNodePolicy >.

Definition at line 181 of file multiDimContainer_tpl.h.

References gum::MultiDimInterface::domainSize(), and GUM_ERROR.

                                                 {
     if (domainSize() != l.size()) {
       GUM_ERROR(SizeError, "Sizes do not match in populate");
     }
 
     Instantiation i(*this);
     // insert all the elements
     for (const auto& elt : l) {
       set(i, elt);
       ++i;
     }
   }

Here is the call graph for this function:

◆ 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>

Size gum::aggregator::MultiDimAggregator< GUM_SCALAR >::realSize ( ) const

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 142 of file multiDimAggregator.h.

References gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_fold(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_neutralElt(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::copyFrom(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::name(), and gum::aggregator::operator<<().

142 { return 0; };

Here is the call 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:

◆ set()

template<typename GUM_SCALAR >

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

virtualinherited

Warning: An OperationNotAllowed will be raised because this is a read only table.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 59 of file multiDimReadOnly_tpl.h.

References GUM_ERROR.

                                                                                  {
     GUM_ERROR(OperationNotAllowed, "Write access to an aggregator");
   }

◆ setChangeNotification()

template<typename GUM_SCALAR>

void gum::aggregator::MultiDimAggregator< GUM_SCALAR >::setChangeNotification ( const gum::Instantiation & )

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimAdressable.

Definition at line 131 of file multiDimAggregator.h.

131 {};

◆ setDecNotification()

template<typename GUM_SCALAR>

void gum::aggregator::MultiDimAggregator< GUM_SCALAR >::setDecNotification ( const gum::Instantiation & )

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimAdressable.

Definition at line 129 of file multiDimAggregator.h.

129 {};

◆ setFirstNotification()

template<typename GUM_SCALAR>

void gum::aggregator::MultiDimAggregator< GUM_SCALAR >::setFirstNotification ( const gum::Instantiation & )

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimAdressable.

Definition at line 123 of file multiDimAggregator.h.

123 {};

◆ setIncNotification()

template<typename GUM_SCALAR>

void gum::aggregator::MultiDimAggregator< GUM_SCALAR >::setIncNotification ( const gum::Instantiation & )

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimAdressable.

Definition at line 127 of file multiDimAggregator.h.

127 {};

◆ setLastNotification()

template<typename GUM_SCALAR>

void gum::aggregator::MultiDimAggregator< GUM_SCALAR >::setLastNotification ( const gum::Instantiation & )

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimAdressable.

Definition at line 125 of file multiDimAggregator.h.

125 {};

◆ toString() [1/2]

template<typename GUM_SCALAR >

const std::string gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString ( ) const

overridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 95 of file multiDimAggregator_tpl.h.

References gum::aggregator::MultiDimAggregator< GUM_SCALAR >::aggregatorName(), gum::MultiDimImplementation< GUM_SCALAR >::nbrDim(), and gum::MultiDimImplementation< GUM_SCALAR >::variable().

Referenced by gum::aggregator::operator<<().

                                                                      {
       std::stringstream s;
       s << this->variable(0) << "=" << aggregatorName() << "(";
 
       for (Idx i = 1; i < this->nbrDim(); i++) {
         if (i > 1) s << ",";
 
         s << this->variable(i);
       }
 
       s << ")";
 
       return s.str();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toString() [2/2]

template<typename GUM_SCALAR>

const std::string gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString ( const gum::Instantiation * i ) const

inlineoverridevirtual

Returns: the real number of parameters used for this table.

This function is used for compute

See also: compressionRatio()

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 133 of file multiDimAggregator.h.

References gum::Instantiation::toString().

                                                                          {
         return i->toString();
       };

Here is the call 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:

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

agrum/multidim/aggregators/multiDimAggregator.h
agrum/multidim/aggregators/multiDimAggregator_tpl.h

Public Member Functions

Protected Member Functions

Detailed Description

template<typename GUM_SCALAR> class gum::aggregator::MultiDimAggregator< GUM_SCALAR >

Constructor & Destructor Documentation

◆ MultiDimAggregator() [1/2]

◆ MultiDimAggregator() [2/2]

◆ ~MultiDimAggregator()

Member Function Documentation

◆ _buildValue()

◆ _commitMultipleChanges() [1/2]

◆ _commitMultipleChanges() [2/2]

◆ _fold()

◆ _get()

◆ _invert()

◆ _isCommitNeeded()

◆ _isInMultipleChangeMethod()

◆ _neutralElt()

◆ _replace()

◆ _slaves()

◆ add()

◆ aggregatorName()

◆ apply()

◆ basename()

◆ beginMultipleChanges()

◆ changeNotification()

◆ compressionRate()

◆ contains()

◆ content() [1/2]

◆ content() [2/2]

◆ copy()

◆ copyFrom() [1/2]

◆ copyFrom() [2/2]

◆ domainSize()

◆ empty()

◆ endMultipleChanges() [1/2]

◆ endMultipleChanges() [2/2]

◆ erase()

◆ extractFrom()

◆ fill()

◆ get()

◆ getMasterRef() [1/2]

◆ getMasterRef() [2/2]

◆ name()

◆ nbrDim()

◆ newFactory()

◆ operator!=()

◆ operator==()

◆ operator[]()

◆ populate() [1/2]

◆ populate() [2/2]

◆ pos()

◆ realSize()

◆ reduce()

◆ registerSlave()

◆ replace()

◆ set()

◆ setChangeNotification()

◆ setDecNotification()

◆ setFirstNotification()

◆ setIncNotification()

◆ setLastNotification()

◆ toString() [1/2]

◆ toString() [2/2]

◆ unregisterSlave()

◆ variable() [1/2]

◆ variable() [2/2]

◆ variablesSequence()

template<typename GUM_SCALAR>
class gum::aggregator::MultiDimAggregator< GUM_SCALAR >