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

#include <agrum/multidim/instantiation.h>

Inheritance diagram for gum::Instantiation:

Collaboration diagram for gum::Instantiation:

Public Member Functions
Constructors / Destructors
	Instantiation ()
	Default constructor: creates an empty tuple. More...

	Instantiation (const Instantiation &aI, const bool notifyMaster=true)
	Copy constructor. More...

Instantiation &	operator= (const Instantiation &aI)
	Copy operator. More...

	Instantiation (MultiDimAdressable &aMD)
	Constructor for a Instantiation of all the variables of a MultiDimAdressable. More...

	Instantiation (const MultiDimAdressable &aMD)
	Constructor for a Instantiation of all the variables of a MultiDimAdressable. More...

	Instantiation (MultiDimAdressable *aMD)
	Constructor for a Instantiation of all the variables of a MultiDimAdressable. More...

	Instantiation (const MultiDimAdressable *aMD)
	Constructor for a Instantiation of all the variables of a MultiDimAdressable. More...

	~Instantiation ()
	Destructor. More...

Accessors / Modifiers
Idx	nbrDim () const final
	Returns the number of variables in the Instantiation. More...

void	add (const DiscreteVariable &v) final
	Adds a new variable in the Instantiation. More...

void	erase (const DiscreteVariable &v) final
	Removes a variable from the Instantiation. More...

void	clear ()
	Erase all variables from an Instantiation. More...

Size	domainSize () const final
	Returns the product of the variable's domain size in the Instantiation. More...

Idx	pos (const DiscreteVariable &v) const final
	Returns the position of the variable v. More...

Idx	val (Idx i) const
	Returns the current value of the variable at position i. More...

Idx	val (const DiscreteVariable &var) const
	Returns the current value of a given variable. More...

Idx	valFromPtr (const DiscreteVariable *pvar) const
	Returns the current value of a given variable. More...

const DiscreteVariable &	variable (Idx i) const final
	Returns the variable at position i in the tuple. More...

const DiscreteVariable &	variable (const std::string &name) const final
	Returns the variable with the name. More...

Instantiation &	chgVal (const DiscreteVariable &v, Idx newval)
	Assign newval to variable v in the Instantiation. More...

Instantiation &	chgVal (const DiscreteVariable *v, Idx newval)
	Assign newval to variable v in the Instantiation. More...

Instantiation &	chgVal (Idx varPos, Idx newval)
	Assign newval to variable at position varPos in the Instantiation. More...

Instantiation &	chgVal (const std::string &var, Idx newval)
	Assign newval to variable at position varPos in the Instantiation. More...

Instantiation &	chgVal (const std::string &var, const std::string &newval)
	Assign newval to variable at position varPos in the Instantiation. More...

Instantiation &	setVals (const Instantiation &i)
	Assign the values from i in the Instantiation. More...

void	setValsFrom (const HashTable< const DiscreteVariable , const DiscreteVariable > &map, const Instantiation &external)
	Assign the values of external in *this, using map as a bijection between external and this variables. More...

bool	contains (const DiscreteVariable &v) const final
	Indicates whether a given variable belongs to the Instantiation. More...

bool	contains (const DiscreteVariable *v) const
	Indicates whether a given variable belongs to the Instantiation. More...

const Sequence< const DiscreteVariable *> &	variablesSequence () const final
	Returns the sequence of DiscreteVariable of this instantiation. More...

virtual bool	empty () const final
	Returns true if the instantiation is empty. More...

Overflow management methods.
bool	inOverflow () const
	Indicates whether the current value of the tuple is correct or not. More...

void	unsetOverflow ()
	Removes the flag overflow. More...

void	unsetEnd ()
	Alias for unsetOverflow(). More...

bool	end () const
	Returns true if the Instantiation reached the end. More...

bool	rend () const
	Returns true if the Instantiation reached the rend. More...

Incrementation and decrementation methods
void	inc ()
	Operator increment. More...

void	dec ()
	Operator decrement. More...

void	incIn (const Instantiation &i)
	Operator increment for the variables in i. More...

void	decIn (const Instantiation &i)
	Operator decrement for the variables in i. More...

void	incOut (const Instantiation &i)
	Operator increment for the variables not in i. More...

void	decOut (const Instantiation &i)
	Operator decrement for the variables not in i. More...

void	incNotVar (const DiscreteVariable &v)
	Operator increment for vars which are not v. More...

void	decNotVar (const DiscreteVariable &v)
	Operator decrement for vars which are not v. More...

void	incVar (const DiscreteVariable &v)
	Operator increment for variable v only. More...

void	decVar (const DiscreteVariable &v)
	Operator decrement for variable v only. More...

Initialization methods
void	setFirst ()
	Assign the first values to the tuple of the Instantiation. More...

void	setLast ()
	Assign the last values in the Instantiation. More...

void	setFirstIn (const Instantiation &i)
	Assign the first values in the Instantiation for the variables in i. More...

void	setLastIn (const Instantiation &i)
	Assign the last values in the Instantiation for the variables in i. More...

void	setFirstOut (const Instantiation &i)
	Assign the first values in the Instantiation for the variables not in i. More...

void	setLastOut (const Instantiation &i)
	Assign the last values in the Instantiation for the variables not in i. More...

void	setFirstNotVar (const DiscreteVariable &v)
	Assign the first values to variables different of v. More...

void	setLastNotVar (const DiscreteVariable &v)
	Assign the last values to variables different of v. More...

void	setFirstVar (const DiscreteVariable &v)
	Assign the first value in the Instantiation for var v. More...

void	setLastVar (const DiscreteVariable &v)
	Assign the last value in the Instantiation for var v. More...

Notification methods
bool	actAsSlave (MultiDimAdressable &aMD)
	Tries to register the Instantiation to a MultiDimAdressable. More...

bool	forgetMaster ()
	Deassociate the master MultiDimAdressable, if any. More...

bool	isSlave () const
	Indicates whether the Instantiation has a master. More...

bool	isMaster (const MultiDimAdressable *m) const
	Indicates whether m is the master of this instantiation. More...

bool	isMaster (const MultiDimAdressable &m) const
	Indicates whether m is the master of this instantiation. More...

void	synchronizeWithMaster (const MultiDimAdressable *m)
	Force the variables sequence to be the same as the master one. More...

void	addWithMaster (const MultiDimAdressable *m, const DiscreteVariable &v)
	Call Instantiation::__add(const DiscreteVariable&) by master. More...

void	eraseWithMaster (const MultiDimAdressable *m, const DiscreteVariable &v)
	Call Instantiation::__erase(const DiscreteVariable&) by master. More...

Operators
bool	operator== (const Instantiation &other) const
	operator== More...

Instantiation &	operator++ ()
	Alias of Instantiation::inc(). More...

Instantiation &	operator-- ()
	Alias of Instantiation::dec(). More...

Instantiation &	operator+= (Size depl)
	Calls depl times Instantiation::inc(). More...

Instantiation &	operator-= (Size depl)
	Calls depl times Instantiation::dec(). More...

Various methods
Idx	hamming () const
	Returns the hamming distance of this instantiation. More...

std::string	toString () const
	Give a string version of instantiation. More...

void	reorder (const Sequence< const DiscreteVariable * > &v)
	Reorder vars of this instantiation giving the order in v. More...

void	reorder (const Instantiation &i)
	Calls reorder(const Sequence<const DiscreteVariable*>&) with i.variablesSequence() More...

Accessors / Modifiers
void	replace (const DiscreteVariable &x, const DiscreteVariable &y)
	Replace variables in this multidim. More...

Protected Member Functions
virtual void	_replace (const DiscreteVariable x, const DiscreteVariable y) final
	Replace x by y. More...

Detailed Description

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

Instantiation is designed to assign values to tuples of variables and to efficiently loop over values of subsets of variables. This class can be used in two different flavors:

the tuple of variables in the Instantiation is related to a multidimensional array and, when we loop over the possible values of the tuple, we also loop at the same time over the corresponding values in the array.
the tuple of variables in the Instantiation is not related to a multidimensional array and we can loop over the possible values of the tuple without looping over values fo any array.

An Instantiation can be associated/deassociated to a given multidimensional array using the MultiDimAdressable::registerSlave(Instantiation& i) and MultiDimAdressable::unregisterSlave functions. Note that, to be registrable, the Instantiation must have precisely the same variables as the array. As a consequence, adding or removing a variable from a Instantiation associated to an array will unregister it. This behavior is compulsory as, if it were still associated, it would not be possible to retrieve a correct value of the array given a value of the Instantiation. For instance, if M[A,B,C] is an array indexed by Boolean variables A,B,C, Which value of M should be returned if B=0 and C=0? We do not know for sure as we do not know the value of A. Note also that, at any time, you can unregister a Instantiation from its master multidimensional array and you can ask to associate it (provided the tuple of variable match).

To print information about a Instantiation use the following function:

See also: operator<<(std::ostream&, const Instantiation&).

Definition at line 83 of file instantiation.h.

Constructor & Destructor Documentation

◆ Instantiation() [1/6]

gum::Instantiation::Instantiation ( )

Default constructor: creates an empty tuple.

Definition at line 40 of file instantiation.cpp.

                                : __master(nullptr), __overflow(false) {
     GUM_CONSTRUCTOR(Instantiation);
   }

◆ Instantiation() [2/6]

gum::Instantiation::Instantiation	(	const Instantiation &	aI,
		const bool	notifyMaster = `true`
	)

Copy constructor.

Note that the Instantiation is by default associated to the same MultiDimAdressable as aI. This means that looping over values of the tuple will induce looping over the values of the MultiDimAdressable. Similarly, the value of the tuple is that of aI, and, if the Instantiation is slaved, its master is notified of the value of the Instantiation if notifyMaster is true.

Parameters

aI	The Instantiation we copy.
notifyMaster	Whether or not notify master if exits.

Definition at line 103 of file instantiation.cpp.

References __master, __overflow, __vals, __vars, and actAsSlave().

                                                                                :
       MultiDimInterface(), __master(0), __overflow(false) {
     // for debugging purposes
     GUM_CONS_CPY(Instantiation);
     // copy the content of aI
     __vars = aI.__vars;
     __vals = aI.__vals;
     __overflow = aI.__overflow;
 
     if (aI.__master && notifyMaster) actAsSlave(*aI.__master);
   }

Here is the call graph for this function:

◆ Instantiation() [3/6]

gum::Instantiation::Instantiation ( MultiDimAdressable & aMD )

Constructor for a Instantiation of all the variables of a MultiDimAdressable.

The variables of the Instantiation are those of aMD (actually, they are shared in memory). All the variables of aMD belong to the tuple of variables to be instantiated.

Note that the Instantiation is by default associated to aMD, i.e., looping over values of the tuple will induce looping over the values of aMD. The value given to the tuple is the first possible value, that is, (0,...,0). If the Instantiation is slaved, its master is notified of the value of the Instantiation.

Parameters

aMD	The array the variables of which are those of the Instantiation.

Definition at line 68 of file instantiation.cpp.

References __init().

                                                     :
       __master(0), __overflow(false) {
     // for debugging purposes
     GUM_CONSTRUCTOR(Instantiation);
     __init(&d);
   }

Here is the call graph for this function:

◆ Instantiation() [4/6]

gum::Instantiation::Instantiation ( const MultiDimAdressable & aMD )

Constructor for a Instantiation of all the variables of a MultiDimAdressable.

The variables of the Instantiation are those of aMD (actually, they are shared in memory). All the variables of aMD belong to the tuple of variables to be instantiated.

Note that the Instantiation is by default associated to aMD, i.e., looping over values of the tuple will induce looping over the values of aMD. The value given to the tuple is the first possible value, that is, (0,...,0). If the Instantiation is slaved, its master is notified of the value of the Instantiation.

Parameters

aMD	The array the variables of which are those of the Instantiation.

Definition at line 75 of file instantiation.cpp.

References __init().

                                                           :
       __master(0), __overflow(false) {
     // for debugging purposes
     GUM_CONSTRUCTOR(Instantiation);
     __init(const_cast< MultiDimAdressable* >(&d));
   }

Here is the call graph for this function:

◆ Instantiation() [5/6]

gum::Instantiation::Instantiation ( MultiDimAdressable * aMD )

Constructor for a Instantiation of all the variables of a MultiDimAdressable.

The variables of the Instantiation are those of aMD (actually, they are shared in memory). All the variables of aMD belong to the tuple of variables to be instantiated.

Note that the Instantiation is by default associated to aMD, i.e., looping over values of the tuple will induce looping over the values of aMD. The value given to the tuple is the first possible value, that is, (0,...,0). If the Instantiation is slaved, its master is notified of the value of the Instantiation.

Parameters

aMD	The array the variables of which are those of the Instantiation.

Definition at line 83 of file instantiation.cpp.

References __init().

                                                     :
       __master(0), __overflow(false) {
     // for debugging purposes
     GUM_CONSTRUCTOR(Instantiation);
 
     if (d) __init(d);
   }

Here is the call graph for this function:

◆ Instantiation() [6/6]

gum::Instantiation::Instantiation ( const MultiDimAdressable * aMD )

Constructor for a Instantiation of all the variables of a MultiDimAdressable.

The variables of the Instantiation are those of aMD (actually, they are shared in memory). All the variables of aMD belong to the tuple of variables to be instantiated.

Note that the Instantiation is by default associated to aMD, i.e., looping over values of the tuple will induce looping over the values of aMD. The value given to the tuple is the first possible value, that is, (0,...,0). If the Instantiation is slaved, its master is notified of the value of the Instantiation.

Parameters

aMD	The array the variables of which are those of the Instantiation.

Definition at line 94 of file instantiation.cpp.

References __init().

                                                                 :
       __master(0), __overflow(false) {
     // for debugging purposes
     GUM_CONSTRUCTOR(Instantiation);
 
     if (const_d) __init(const_cast< MultiDimAdressable* >(const_d));
   }

Here is the call graph for this function:

◆ ~Instantiation()

gum::Instantiation::~Instantiation ( )

Destructor.

Definition at line 45 of file instantiation.cpp.

References __master, and gum::MultiDimAdressable::unregisterSlave().

                                 {
     GUM_DESTRUCTOR(Instantiation);
     // unregister the Instantiation from its __master
 
     if (__master) __master->unregisterSlave(*this);
   }

Here is the call graph for this function:

Member Function Documentation

◆ __add()

INLINE void gum::Instantiation::__add ( const DiscreteVariable & v )

private

Adds a new var to the sequence of vars.

If variable v already belongs to the Instantiation tuple of variables, then nothing is done. In particular, no exception is thrown in this case.

Warning: note that this function does not deassociate the Instantiation from its master MultiDimAdressable, if any. To do so, use function add instead.; this function does not notify the master MultiDimAdressable, if any. Use in addition function chgVal or __chgVal if need be.; variable v is known to the Instantiation only by a pointer to it. As a result, this is not a copy of v that is used by Instantiation but rather v itself. As such, v should never be deleted from memory until the Instantiation is removed.

Parameters

v	The new var.

Exceptions

DuplicateElement Raised if v is already in this Instantiation.

Definition at line 786 of file instantiation_inl.h.

References __overflow, __vals, and __vars.

Referenced by __init(), add(), and addWithMaster().

                                                             {
     __vars.insert(&v);
     __vals.push_back(0);
     __overflow = false;
   }

Here is the caller graph for this function:

◆ __chgVal()

INLINE void gum::Instantiation::__chgVal	(	Idx	varPos,
		Idx	newVal
	)

private

Modifies internally the value of a given variable of the sequence.

In addition to modifying the value of the variable, the Instantiation informs its master MultiDimAdressable of the modification.

Parameters

varPos	The variable to change.
newVal	The variable new value.

Definition at line 45 of file instantiation_inl.h.

References __masterChangeNotification(), and __vals.

Referenced by chgVal(), decIn(), decNotVar(), decOut(), decVar(), incIn(), incNotVar(), incOut(), incVar(), setFirstIn(), setFirstNotVar(), setFirstOut(), setFirstVar(), setLastIn(), setLastNotVar(), setLastOut(), setLastVar(), and setVals().

                                                             {
     Idx oldVal = __vals[varPos];
     __vals[varPos] = newVal;
 
     __masterChangeNotification(varPos, newVal, oldVal);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __erase()

INLINE void gum::Instantiation::__erase ( const DiscreteVariable & v )

private

Removes a variable from the sequence of vars.

If variable v does not belong to the Instantiation tuple of variables, then nothing is done. In particular, no exception is thrown in this case.

Warning: this function does not notify the master MultiDimAdressable, if any.; note that this function does not deassociate the Instantiation from its master MultiDimAdressable, if any. To do so, use function removeDim instead.

Parameters

v	The variable to be erased from the tuple.

Definition at line 793 of file instantiation_inl.h.

References __vals, __vars, and pos().

Referenced by erase(), and eraseWithMaster().

                                                               {
     // get the position of the variable
     Idx pos = __vars.pos(&v);
     __vars.erase(&v);
     __vals.erase(__vals.begin() + pos);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __init()

void gum::Instantiation::__init ( MultiDimAdressable * master )

private

Initialize this Instantiation.

Parameters

master This Instantiation's master.

Definition at line 52 of file instantiation.cpp.

References __add(), __vals, __vars, actAsSlave(), gum::MultiDimAdressable::getMasterRef(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::size(), and gum::MultiDimInterface::variablesSequence().

Referenced by Instantiation().

                                                        {
     // for speed issues
     GUM_ASSERT(master != nullptr);
 
     const Sequence< const DiscreteVariable* >& v = master->variablesSequence();
     __vars.resize(v.size());
     __vals.reserve(v.size());
     // fill the instantiation
 
     for (const auto var : v)
       __add(*var);
 
     actAsSlave(master->getMasterRef());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __masterChangeNotification()

void gum::Instantiation::__masterChangeNotification	(	Idx	varPos,
		Idx	newVal,
		Idx	oldVal
	)		const

private

Definition at line 198 of file instantiation.cpp.

References __master, __vars, and gum::MultiDimAdressable::changeNotification().

Referenced by __chgVal().

                                                                    {
     if (__master)
       __master->changeNotification(*this, __vars[varPos], oldVal, newVal);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __masterDecNotification()

void gum::Instantiation::__masterDecNotification ( ) const

private

Definition at line 215 of file instantiation.cpp.

References __master, and gum::MultiDimAdressable::setDecNotification().

Referenced by dec().

                                                     {
     if (__master) __master->setDecNotification(*this);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __masterFirstNotification()

void gum::Instantiation::__masterFirstNotification ( ) const

private

Definition at line 205 of file instantiation.cpp.

References __master, and gum::MultiDimAdressable::setFirstNotification().

Referenced by inc(), and setFirst().

                                                       {
     if (__master) __master->setFirstNotification(*this);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __masterIncNotification()

void gum::Instantiation::__masterIncNotification ( ) const

private

Definition at line 209 of file instantiation.cpp.

References __master, and gum::MultiDimAdressable::setIncNotification().

Referenced by inc().

                                                     {
     if (__master) __master->setIncNotification(*this);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __masterLastNotification()

void gum::Instantiation::__masterLastNotification ( ) const

private

Definition at line 212 of file instantiation.cpp.

References __master, and gum::MultiDimAdressable::setLastNotification().

Referenced by dec(), and setLast().

                                                      {
     if (__master) __master->setLastNotification(*this);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __notifiedDimChanged()

void gum::Instantiation::__notifiedDimChanged ( const Sequence< const DiscreteVariable * > & v )

private

This function is called by the master (if any) when changes arise in its vars list.

Warning: No implementation of this method?

Parameters

v	the new vars list

◆ __reorder()

INLINE void gum::Instantiation::__reorder ( const Sequence< const DiscreteVariable * > & v )

private

Reorder vars of this instantiation giving the order in v.

In the new order variables common to v and *this are placed first, then variables only in *this.

The variables only in v are ignored.

Parameters

v	The new order of variables in this Instantiation.

Definition at line 756 of file instantiation_inl.h.

References __swap(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::atPos(), contains(), pos(), and gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::size().

Referenced by reorder(), and synchronizeWithMaster().

                                                           {
     Idx max = original.size();
     Idx position = 0;
     for (Idx i = 0; i < max; ++i) {
       const DiscreteVariable* pv = original.atPos(i);
 
       if (contains(pv)) {
         auto p = pos(*pv);
         GUM_ASSERT(p >= position);   // this var should not be
                                      // already placed.
         __swap(position, p);
         position++;
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __swap()

INLINE void gum::Instantiation::__swap	(	Idx	i,
		Idx	j
	)

private

Swap two variables in the Instantiation.

Parameters

i	The first variable.
j	The second variable.

Definition at line 732 of file instantiation_inl.h.

References __vals, and __vars.

Referenced by __reorder().

                                                 {
     if (i == j) return;
 
     __vars.swap(i, j);
 
     Idx v;
     v = __vals[i];
     __vals[i] = __vals[j];
     __vals[j] = v;
   }

Here is the caller graph for this function:

◆ _replace()

INLINE void gum::Instantiation::_replace	(	const DiscreteVariable *	x,
		const DiscreteVariable *	y
	)

finalprotectedvirtual

Replace x by y.

Parameters

x	The variable to replace.
y	The variable replacing x.

Implements gum::MultiDimInterface.

Definition at line 804 of file instantiation_inl.h.

References __vars.

                                                                  {
     __vars.setAtPos(__vars.pos(x), y);
   }

◆ actAsSlave()

bool gum::Instantiation::actAsSlave ( MultiDimAdressable & aMD )

Tries to register the Instantiation to a MultiDimAdressable.

The function will actually register the Instantiation if and only if it has precisely the same variables as the MultiDimAdressable (by precisely, we mean a physical equality, that is, the variables are at the same places in memory).

Parameters

aMD	The multidimensional array which will be the master of *this

Returns: Returns true if and only if the Instantiation has been associated successfully to aMD.

Exceptions

OperationNotAllowed Raised if this instantiation has already a master.

Definition at line 248 of file instantiation.cpp.

References __master, GUM_ERROR, and gum::MultiDimAdressable::registerSlave().

Referenced by __init(), Instantiation(), and operator=().

                                                         {
     // if __master : not allowed
     if (__master != nullptr) {
       GUM_ERROR(OperationNotAllowed, "in slave Instantiation");
     }
 
     __master = &aMD;
 
     // perform the registration
     if (aMD.registerSlave(*this)) {
       return true;
     } else {
       __master = nullptr;
       return false;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add()

INLINE void gum::Instantiation::add ( const DiscreteVariable & v )

finalvirtual

Adds a new variable in the Instantiation.

If variable v already belongs to the Instantiation tuple of variables, then DuplicateElement is thrown in this case. The value of the new variable is set to that of index 0, that is, the first possible value for the variable. Since an instantiation must share the same set of variables with his master an OperationNotAllowed is raised if you try to add a variable of a slaved instantiation.

Warning: Variable v is known to the Instantiation only by a pointer to it. As a result, this is not a copy of v that is used by the Instantiation, but rather v itself. As such, v should never be deleted from memory until the Instantiation is removed.

Parameters

v	The new variable added to this Instantiation.

Exceptions

DuplicateElement	Raised if v is already in this Instantiation.
InvalidArgument	Raised if the name of v is already used in this Instantiation.
OperationNotAllowed	Raised if this is a slave Instantiation.

Implements gum::MultiDimInterface.

Definition at line 125 of file instantiation_inl.h.

References __add(), __master, __vars, GUM_ERROR, and gum::Variable::name().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__addVariable(), gum::SamplingInference< GUM_SCALAR >::_addVarSample(), gum::WeightedSampling< GUM_SCALAR >::_draw(), gum::ImportanceSampling< GUM_SCALAR >::_draw(), gum::AbstractSimulator::_randomState(), gum::SamplingInference< GUM_SCALAR >::contextualize(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::Potential< GUM_SCALAR >::fillWith(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), gum::GibbsOperator< GUM_SCALAR >::monteCarloSample(), gum::FMDPSimulator::perform(), and gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByColumns().

                                                           {
     // if __master : not allowed
     if (__master) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation"); }
 
     // 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& vv : __vars) {
       if (vv->name() == v.name()) {
         GUM_ERROR(InvalidArgument,
                   "Var with name <" << v.name()
                                     << "> already exists in this instantiation");
       }
     }
 
     // actually add the new dimension
     __add(v);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addWithMaster()

INLINE void gum::Instantiation::addWithMaster	(	const MultiDimAdressable *	m,
		const DiscreteVariable &	v
	)

Call Instantiation::__add(const DiscreteVariable&) by master.

Parameters

m	The master of this instantiation.
v	The varaible to add.

Exceptions

OperationNotAllowed Raised if m is not hte master of this instantiation.

Definition at line 775 of file instantiation_inl.h.

References __add(), __master, and GUM_ERROR.

                                                                         {
     if (m != __master) {
       GUM_ERROR(OperationNotAllowed, "only master can do this");
     }
 
     __add(v);
   }

Here is the call graph for this function:

◆ chgVal() [1/5]

INLINE Instantiation & gum::Instantiation::chgVal	(	const DiscreteVariable &	v,
		Idx	newval
	)

Assign newval to variable v in the Instantiation.

Consider the values of v as an array indexed from 0 to n of values (which might be anything from real numbers to strings, etc). Parameter newval indicates the index in this array of the new value taken by v.

In addition to modifying the value of the variable, the Instantiation informs its master of the modification. This function also unsets the overflow flag.

Parameters

v	The variable whose value is assigned.
newval	The index of the value assigned.

Returns: Returns a reference to *this in order to chain the chgVal.

Exceptions

NotFound	Raised if variable v does not belong to the instantiation.
OutOfBound	Raised if newval is not a possible value for v.

Definition at line 53 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, gum::DiscreteVariable::domainSize(), GUM_ERROR, and gum::Variable::name().

                                                                               {
     try {
       // check that the variable does belong to the instantiation and that the
       // new
       // value is possible.
       Idx varPos = __vars.pos(&v);   // throws NotFound if v doesn't belong to this
 
       if (newVal >= v.domainSize()) { GUM_ERROR(OutOfBounds, ""); }
 
       // if we were in overflow, indicate that we are not anymore
       __overflow = false;
 
       __chgVal(varPos, newVal);
 
       return *this;
     } catch (NotFound&) {
       std::string name = "instantiation does not contain this DiscreteVariable: ";
       GUM_ERROR(NotFound, name + v.name());
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ chgVal() [2/5]

INLINE Instantiation & gum::Instantiation::chgVal	(	const DiscreteVariable *	v,
		Idx	newval
	)

Assign newval to variable v in the Instantiation.

Consider the values of v as an array indexed from 0 to n of values (which might be anything from real numbers to strings, etc). Parameter newval indicates the index in this array of the new value taken by v.

In addition to modifying the value of the variable, the Instantiation informs its master of the modification. This function also unsets the overflow flag.

Parameters

v	The variable whose value is assigned.
newval	The index of the value assigned.

Returns: Returns a reference to *this in order to chain the chgVal.

Exceptions

NotFound	Raised if variable v does not belong to the instantiation.
OutOfBound	Raised if newval is not a possible value for v.

Definition at line 75 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, gum::DiscreteVariable::domainSize(), GUM_ERROR, and gum::Variable::name().

                                                                               {
     try {
       // check that the variable does belong to the instantiation and that the
       // new
       // value is possible.
       Idx varPos = __vars.pos(v);   // throws NotFound if v doesn't belong to this
 
       if (newVal >= v->domainSize()) { GUM_ERROR(OutOfBounds, ""); }
 
       // if we were in overflow, indicate that we are not anymore
       __overflow = false;
 
       __chgVal(varPos, newVal);
 
       return *this;
     } catch (NotFound&) {
       std::string name = "instantiation does not contain this DiscreteVariable: ";
       GUM_ERROR(NotFound, name + v->name());
     }
   }

Here is the call graph for this function:

◆ chgVal() [3/5]

INLINE Instantiation & gum::Instantiation::chgVal	(	Idx	varPos,
		Idx	newval
	)

Assign newval to variable at position varPos in the Instantiation.

Consider the values of v as an array indexed from 0 to n of values (which might be anything from real numbers to strings, etc). Parameter newval indicates the index in this array of the new value taken by v.

In addition to modifying the value of the variable, the Instantiation informs its master of the modification. This function also unsets the overflow flag.

Parameters

varPos	The index of the variable whose value is assigned in the tuple of variables of the Instantiation.
newval	The index of the value assigned.

Returns: A reference to *this in order to chain the chgVal.

Exceptions

NotFound	Raised if the variable does not belong to this
OutOfBound	Raised if newval is not a possible value for the variable

Definition at line 98 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, domainSize(), and GUM_ERROR.

                                                                     {
     // check that the variable does belong to the instantiation and that the new
     // value is possible.
     if (__vals.size() <= varPos) { GUM_ERROR(NotFound, ""); }
 
     if (newVal >= __vars[varPos]->domainSize()) { GUM_ERROR(OutOfBounds, ""); }
 
     // if we were in overflow, indicate that we are not anymore
     __overflow = false;
 
     __chgVal(varPos, newVal);
 
     return *this;
   }

Here is the call graph for this function:

◆ chgVal() [4/5]

INLINE Instantiation & gum::Instantiation::chgVal	(	const std::string &	var,
		Idx	newval
	)

Assign newval to variable at position varPos in the Instantiation.

Consider the values of v as an array indexed from 0 to n of values (which might be anything from real numbers to strings, etc). Parameter newval indicates the index in this array of the new value taken by v.

In addition to modifying the value of the variable, the Instantiation informs its master of the modification. This function also unsets the overflow flag.

Parameters

var	the name of the variable whose value is assigned in the tuple of variables of the Instantiation.
newval	The index of the value assigned.

Returns: A reference to *this in order to chain the chgVal.

Exceptions

NotFound	Raised if the variable does not belong to this
NotFound	Raised if newval is not a possible value for the variable

Definition at line 113 of file instantiation_inl.h.

References chgVal(), and variable().

                                                                               {
     return chgVal(variable(var), newVal);
   }

Here is the call graph for this function:

◆ chgVal() [5/5]

INLINE Instantiation & gum::Instantiation::chgVal	(	const std::string &	var,
		const std::string &	newval
	)

Assign newval to variable at position varPos in the Instantiation.

Consider the values of v as an array indexed from 0 to n of values (which might be anything from real numbers to strings, etc). Parameter newval indicates the index in this array of the new value taken by v.

In addition to modifying the value of the variable, the Instantiation informs its master of the modification. This function also unsets the overflow flag.

Parameters

var	the name of the variable whose value is assigned in the tuple of variables of the Instantiation.
newval	The label of the value assigned.

Returns: A reference to *this in order to chain the chgVal.

Exceptions

NotFound	Raised if the variable does not belong to this
OutOfBound	Raised if newval is not a possible value for the variable

Definition at line 117 of file instantiation_inl.h.

References chgVal(), pos(), and variable().

                                                                        {
     const auto& vv = variable(var);
     Idx         pos = vv.index(newVal);
     return chgVal(vv, pos);
   }

Here is the call graph for this function:

◆ clear()

INLINE void gum::Instantiation::clear ( )

Erase all variables from an Instantiation.

Exceptions

OperationNotAllowed Raised if the instantiation is a slave.

Definition at line 163 of file instantiation_inl.h.

References __master, __vals, __vars, and GUM_ERROR.

Referenced by gum::WeightedSampling< GUM_SCALAR >::_draw(), gum::MonteCarloSampling< GUM_SCALAR >::_draw(), and gum::ImportanceSampling< GUM_SCALAR >::_draw().

                                    {
     if (__master) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation"); }
 
     __vars.clear();
     __vals.clear();
   }

Here is the caller graph for this function:

◆ contains() [1/2]

INLINE bool gum::Instantiation::contains ( const DiscreteVariable & v ) const

finalvirtual

Indicates whether a given variable belongs to the Instantiation.

Parameters

v	The variable for which the test is made.

Returns: Returns true if v is in the Instantiation.

Implements gum::MultiDimInterface.

Definition at line 35 of file instantiation_inl.h.

References __vars.

Referenced by __reorder(), gum::MultiDimWithOffset< GUM_SCALAR >::_getOffs(), decIn(), decOut(), gum::MultiDimContainer< GUM_SCALAR >::extractFrom(), incIn(), incOut(), operator=(), operator==(), gum::MultiDimImplementation< std::string >::registerSlave(), setFirstIn(), setFirstOut(), setLastIn(), setLastOut(), setVals(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                                                      {
     return __vars.exists(&v);
   }

Here is the caller graph for this function:

◆ contains() [2/2]

INLINE bool gum::Instantiation::contains ( const DiscreteVariable * v ) const

Indicates whether a given variable belongs to the Instantiation.

Parameters

v	A pointer on the variable for which the test is made.

Returns: Returns true if *v is in the Instantiation.

Definition at line 40 of file instantiation_inl.h.

References __vars.

                                                                      {
     return __vars.exists(v);
   }

◆ dec()

INLINE void gum::Instantiation::dec ( )

Operator decrement.

Note that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). If the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. If we already reached the end() or the rend() of the possible values, function inc() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Usage example:

for(Instantiation i.setLast();! i.rend(); i.dec()) {
  // code
}

Definition at line 272 of file instantiation_inl.h.

References __masterDecNotification(), __masterLastNotification(), __overflow, __vals, __vars, and nbrDim().

Referenced by operator--(), and operator-=().

                                  {
     Size p = nbrDim();
     if (p == 0) { __overflow = true; }
 
     if (__overflow) return;
     p -= 1;
     Idx cpt = 0;
     // if we are in overflow, do nothing
 
     // perform the increment
     while (true) {
       Idx v = __vals[cpt];
 
       if (v == 0) {
         __vals[cpt] = __vars[cpt]->domainSize() - 1;
 
         if (cpt == p) {
           __overflow = true;
 
           __masterLastNotification();
 
           return;
         } else
           ++cpt;
       } else {
         --__vals[cpt];
         break;
       }
     }
 
     __masterDecNotification();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decIn()

INLINE void gum::Instantiation::decIn ( const Instantiation & i )

Operator decrement for the variables in i.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated.

Note also that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). Finally, let us mention that the value of instantiation i is not taken into account, that is, only the variables belonging to i are taken into account. The next value of *this is thus computed w.r.t. to the current value of *this. If we already reached the end() or the rend() of the possible values, function incIn() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

i	The set of variables to decrement in this Instantiation.

Definition at line 403 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, contains(), domainSize(), nbrDim(), pos(), and variable().

                                                          {
     Size p = i.nbrDim() - 1;
     Idx  i_cpt = 0;
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     while (true) {
       // verify that __vars[cpt] belongs to i before incrementing its value
       const DiscreteVariable& v = i.variable(i_cpt);
 
       if (!contains(v)) {
         if (i_cpt == p) {
           __overflow = true;
           return;
         } else
           ++i_cpt;
       } else {
         Idx cpt = pos(v);
         Idx iv = __vals[cpt];
 
         if (iv == 0) {
           __chgVal(cpt, __vars[cpt]->domainSize() - 1);
 
           if (i_cpt == p) {
             __overflow = true;
             return;
           } else
             ++i_cpt;
         } else {
           __chgVal(cpt, iv - 1);
           return;
         }
       }
     }
   }

Here is the call graph for this function:

◆ decNotVar()

INLINE void gum::Instantiation::decNotVar ( const DiscreteVariable & v )

Operator decrement for vars which are not v.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated.

Note also that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). If we already reached the end() or the rend() of the possible values, function incNotVar() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

v	The varaible not to decrement in this Instantiation.

Definition at line 596 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, domainSize(), and nbrDim().

                                                                 {
     Size p = nbrDim() - 1;
     Idx  cpt = 0;
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     while (true) {
       if (__vars[cpt] == &v) {
         if (cpt == p) {
           __overflow = true;
           return;
         } else
           ++cpt;
       } else {
         Idx iv = __vals[cpt];
 
         if (iv == 0) {
           __chgVal(cpt, __vars[cpt]->domainSize() - 1);
 
           if (cpt == p) {
             __overflow = true;
             return;
           } else
             ++cpt;
         } else {
           __chgVal(cpt, iv - 1);
           return;
         }
       }
     }
   }

Here is the call graph for this function:

◆ decOut()

INLINE void gum::Instantiation::decOut ( const Instantiation & i )

Operator decrement for the variables not in i.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. Note also that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). Finally, let us mention that the value of instantiation i is not taken into account, that is, only the variables not belonging to i are taken into account. The next value of *this is thus computed w.r.t. to the current value of *this. If we already reached the end() or the rend() of the possible values, function incerr() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

i	The set of variables to not decrement in this Instantiation.

Definition at line 509 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, contains(), domainSize(), and nbrDim().

                                                           {
     Size p = nbrDim() - 1;
     Idx  cpt = 0;
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     while (true) {
       if (i.contains(__vars[cpt])) {
         if (cpt == p) {
           __overflow = true;
           return;
         } else
           ++cpt;
       } else {
         Idx v = __vals[cpt];
 
         if (v == 0) {
           __chgVal(cpt, __vars[cpt]->domainSize() - 1);
 
           if (cpt == p) {
             __overflow = true;
             return;
           } else
             ++cpt;
         } else {
           __chgVal(cpt, v - 1);
           return;
         }
       }
     }
   }

Here is the call graph for this function:

◆ decVar()

INLINE void gum::Instantiation::decVar ( const DiscreteVariable & v )

Operator decrement for variable v only.

This function decrement only variable v. Trying to decrement the last possible value results in an overflow (no exception is thrown in this case). If we already reached the end() or the rend() of the possible values, function incVar() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

v	The variable to decrement in this Instantiation.

Exceptions

NotFound Raised if variable v does not belong to the Instantiation.

Definition at line 682 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, and gum::DiscreteVariable::domainSize().

                                                              {
     // get the position of the variable
     Idx cpt = __vars.pos(&v);
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     Idx p = __vals[cpt];
 
     if (p == 0) {
       __chgVal(cpt, v.domainSize() - 1);
       __overflow = true;
     } else {
       __chgVal(cpt, p - 1);
     }
   }

Here is the call graph for this function:

◆ domainSize()

INLINE Size gum::Instantiation::domainSize ( ) const

finalvirtual

Returns the product of the variable's domain size in the Instantiation.

Returns: Returns the product of the variable's domain size in the Instantiation.

Implements gum::MultiDimInterface.

Definition at line 172 of file instantiation_inl.h.

References __vars.

Referenced by chgVal(), decIn(), decNotVar(), decOut(), inc(), incIn(), incNotVar(), incOut(), setLast(), setLastIn(), setLastOut(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                               {
     // @todo enhance the cplxity with a member domainSize ?
     Size s = 1;
 
     for (const auto var : __vars)
       s *= var->domainSize();
 
     return s;
   }

Here is the caller graph for this function:

◆ empty()

INLINE bool gum::Instantiation::empty ( ) const

finalvirtual

Returns true if the instantiation is empty.

Returns: Returns true if the instantiation is empty.

Implements gum::MultiDimInterface.

Definition at line 801 of file instantiation_inl.h.

References __vals.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), and gum::AbstractSimulator::hasReachEnd().

801 { return __vals.empty(); }

gum::Instantiation::__vals

std::vector< Idx > __vals

The current instantiation: the value of the tuple.

Definition: instantiation.h:1133

Here is the caller graph for this function:

◆ end()

INLINE bool gum::Instantiation::end ( ) const

Returns true if the Instantiation reached the end.

Function end() should be used as in:

for(Instantiation i.setFirst();! i.end(); ++i) {
  // code
}

Returns: Returns true if the Instantiation reached the end.

Definition at line 227 of file instantiation_inl.h.

References inOverflow().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::prm::PRMFormAttribute< GUM_SCALAR >::__fillCpf(), gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), gum::prm::PRMSystem< double >::__groundPotential(), gum::prm::StructuredBayesBall< GUM_SCALAR >::__isHardEvidence(), gum::BayesNetInference< GUM_SCALAR >::__isHardEvidence(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__threadUpdate(), gum::InfluenceDiagram< GUM_SCALAR >::_copyTables(), gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), gum::prm::PRMFormAttribute< GUM_SCALAR >::_type(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::_type(), gum::prm::PRMInference< double >::addEvidence(), gum::MultiDimContainer< GUM_SCALAR >::apply(), gum::prm::PRMFormAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::o3prmr::O3prmrInterpreter::checkObserve(), gum::BayesNetInference< GUM_SCALAR >::chgEvidence(), gum::MultiDimBucket< GUM_SCALAR >::compute(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copy(), gum::MultiDimContainer< GUM_SCALAR >::copyFrom(), gum::learning::DAG2BNLearner< ALLOC >::createBN(), gum::Potential< GUM_SCALAR >::draw(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::MultiDimContainer< GUM_SCALAR >::extractFrom(), gum::Potential< GUM_SCALAR >::fillWith(), gum::Potential< GUM_SCALAR >::findAll(), gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), gum::JointTargetedInference< GUM_SCALAR >::I(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), gum::Potential< GUM_SCALAR >::KL(), gum::Potential< GUM_SCALAR >::normalizeAsCPT(), gum::prm::PRMInference< double >::operator=(), gum::learning::DAG2BNLearner< ALLOC >::operator=(), gum::IBayesNet< double >::operator==(), gum::MultiDimContainer< GUM_SCALAR >::operator==(), gum::FMDPSimulator::perform(), gum::MultiDimContainer< GUM_SCALAR >::populate(), gum::prm::PRMInference< double >::PRMInference(), gum::prm::o3prmr::O3prmrInterpreter::query(), gum::MultiDimContainer< GUM_SCALAR >::reduce(), gum::Estimator< GUM_SCALAR >::setFromLBP(), gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked(), gum::prm::PRMFormAttribute< GUM_SCALAR >::swap(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::swap(), and gum::MultiDimContainer< GUM_SCALAR >::toString().

227 { return inOverflow(); }

gum::Instantiation::inOverflow

bool inOverflow() const

Indicates whether the current value of the tuple is correct or not.

Definition: instantiation_inl.h:224

Here is the call graph for this function:

◆ erase()

INLINE void gum::Instantiation::erase ( const DiscreteVariable & v )

finalvirtual

Removes a variable from the Instantiation.

If variable v does not belong to the Instantiation tuple of variables, then NotFound is thrown. Since an instantiation must share the same set of variables with his master an OperationNotAllowed is raised if you try to remove a variable from a slaved instantiation.

Parameters

v	The variable to remove from this Instantiation.

Exceptions

NotFound	Raised if v does not belong to this Instantiation.
OperationNotAllowed	Raised if the instantiation is a slave.

Implements gum::MultiDimInterface.

Definition at line 149 of file instantiation_inl.h.

References __erase(), __master, __vars, and GUM_ERROR.

Referenced by gum::GibbsOperator< GUM_SCALAR >::__drawVarMonteCarlo(), gum::MultiDimBucket< GUM_SCALAR >::__eraseVariable(), gum::GibbsOperator< GUM_SCALAR >::__GibbsSample(), gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), and gum::credal::CredalNet< GUM_SCALAR >::toString().

                                                             {
     // if __master : not allowed
     if (__master) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation"); }
 
     // check that the variable does actually belong to the Instantiation
     if (!__vars.exists(&v)) {
       GUM_ERROR(NotFound, "Var does not exist in this instantiation");
     }
 
     // actually delete the dimension
     __erase(v);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseWithMaster()

void gum::Instantiation::eraseWithMaster	(	const MultiDimAdressable *	m,
		const DiscreteVariable &	v
	)

Call Instantiation::__erase(const DiscreteVariable&) by master.

Parameters

m	The master of this instantiation.
v	The variable to remove.

Exceptions

OperationNotAllowed Raised if m is not the master of this instantiation.

Definition at line 236 of file instantiation.cpp.

References __erase(), __master, GUM_ERROR, and gum::MultiDimAdressable::setChangeNotification().

                                                                    {
     if (m != __master) {
       GUM_ERROR(OperationNotAllowed, "only master can do this");
     }
 
     __erase(v);
 
     if (__master) __master->setChangeNotification(*this);
   }

Here is the call graph for this function:

◆ forgetMaster()

bool gum::Instantiation::forgetMaster ( )

Deassociate the master MultiDimAdressable, if any.

Returns: Returns true if and only if the Instantiation has been unregistered.

Definition at line 220 of file instantiation.cpp.

References __master, and gum::MultiDimAdressable::unregisterSlave().

Referenced by gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), gum::credal::CredalNet< GUM_SCALAR >::setCPT(), and gum::credal::CredalNet< GUM_SCALAR >::toString().

                                    {
     if (__master) {
       __master->unregisterSlave(*this);
       __master = nullptr;
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hamming()

Idx gum::Instantiation::hamming ( ) const

Returns the hamming distance of this instantiation.

Returns: Returns the hamming distance of this instantiation.

Definition at line 167 of file instantiation.cpp.

References __vars, and val().

                                    {
     Idx res = 0;
 
     for (const auto var : __vars)
       res += val(*var);
 
     return res;
   }

Here is the call graph for this function:

◆ inc()

INLINE void gum::Instantiation::inc ( )

Operator increment.

Note that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). If the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. If we already reached the end() or the rend() of the possible values, function inc() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Usage example:

for(Instantiation i.setFirst();! i.end(); i.inc()) {
  // code
}

Definition at line 240 of file instantiation_inl.h.

References __masterFirstNotification(), __masterIncNotification(), __overflow, __vals, __vars, domainSize(), and nbrDim().

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::__fillCpf(), gum::prm::PRMSystem< double >::__groundPotential(), gum::prm::StructuredBayesBall< GUM_SCALAR >::__isHardEvidence(), gum::BayesNetInference< GUM_SCALAR >::__isHardEvidence(), gum::InfluenceDiagram< GUM_SCALAR >::_copyTables(), gum::prm::GroundedInference< GUM_SCALAR >::_evidenceAdded(), gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), gum::prm::PRMFormAttribute< GUM_SCALAR >::_type(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::_type(), gum::prm::PRMInference< double >::addEvidence(), gum::prm::PRMFormAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::o3prmr::O3prmrInterpreter::checkObserve(), gum::BayesNetInference< GUM_SCALAR >::chgEvidence(), gum::MultiDimBucket< GUM_SCALAR >::compute(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copy(), gum::Potential< GUM_SCALAR >::draw(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), gum::Potential< GUM_SCALAR >::KL(), gum::prm::PRMInference< double >::marginal(), operator++(), operator+=(), gum::prm::PRMInference< double >::operator=(), gum::IBayesNet< double >::operator==(), gum::prm::PRMInference< double >::PRMInference(), gum::prm::o3prmr::O3prmrInterpreter::query(), gum::prm::PRMFormAttribute< GUM_SCALAR >::swap(), and gum::prm::PRMScalarAttribute< GUM_SCALAR >::swap().

                                  {
     Size p = nbrDim();
     if (p == 0) { __overflow = true; }
 
     if (__overflow) return;
     p -= 1;
     Idx cpt = 0;
     // if we are in overflow, do nothing
 
     // perform the increment
     while (true) {
       Idx v = __vals[cpt];
 
       if (v + 1 == __vars[cpt]->domainSize()) {
         __vals[cpt] = 0;
 
         if (cpt == p) {
           __overflow = true;
           __masterFirstNotification();
           return;
         } else
           ++cpt;
       } else {
         ++__vals[cpt];
         break;
       }
     }
 
     __masterIncNotification();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ incIn()

INLINE void gum::Instantiation::incIn ( const Instantiation & i )

Operator increment for the variables in i.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated.

Note also that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). Finally, let us mention that the value of instantiation i is not taken into account, that is, only the variables belonging to i are taken into account. The next value of *this is thus computed w.r.t. to the current value of *this. If we already reached the end() or the rend() of the possible values, function incIn() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

i	The set of variables to increment in this Instantiation.

Definition at line 358 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, contains(), domainSize(), nbrDim(), pos(), and variable().

Referenced by gum::MultiDimContainer< GUM_SCALAR >::copyFrom(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                                          {
     // if i is empty, overflow and do nothing
     if (i.nbrDim() == 0) {
       __overflow = true;
       return;
     }
 
     // if we are in overflow, do nothing
     if (__overflow) return;
 
     Size p = i.nbrDim() - 1;
 
     Idx i_cpt = 0;
 
     while (true) {
       // verify that __vars[cpt] belongs to i before incrementing its value
       const DiscreteVariable& v = i.variable(i_cpt);
 
       if (!contains(v)) {
         if (i_cpt == p) {
           __overflow = true;
           return;
         } else
           ++i_cpt;
       } else {
         Idx cpt = pos(v);
         Idx iv = __vals[cpt];
 
         if (iv + 1 == __vars[cpt]->domainSize()) {
           __chgVal(cpt, 0);
 
           if (i_cpt == p) {
             __overflow = true;
             return;
           } else
             ++i_cpt;
         } else {
           __chgVal(cpt, iv + 1);
           return;
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ incNotVar()

INLINE void gum::Instantiation::incNotVar ( const DiscreteVariable & v )

Operator increment for vars which are not v.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. Note also that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). If we already reached the end() or the rend() of the possible values, function incNotVar() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

v	The variable not to increment in this Instantiation.

Definition at line 562 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, domainSize(), and nbrDim().

Referenced by gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), and gum::Potential< GUM_SCALAR >::normalizeAsCPT().

                                                                 {
     Size p = nbrDim() - 1;
     Idx  cpt = 0;
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     while (true) {
       if (__vars[cpt] == &v) {
         if (cpt == p) {
           __overflow = true;
           return;
         } else
           ++cpt;
       } else {
         Idx iv = __vals[cpt];
 
         if (iv + 1 == __vars[cpt]->domainSize()) {
           __chgVal(cpt, 0);
 
           if (cpt == p) {
             __overflow = true;
             return;
           } else
             ++cpt;
         } else {
           __chgVal(cpt, iv + 1);
           return;
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ incOut()

INLINE void gum::Instantiation::incOut ( const Instantiation & i )

Operator increment for the variables not in i.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated.

Note also that this operator never throws an exception when it reaches the end of the possible values of the tuple of variables of the Instantiation. To know if we reached the end, use function end(). Finally, let us mention that the value of instantiation i is not taken into account, that is, only the variables not belonging to i are taken into account. The next value of *this is thus computed w.r.t. to the current value of *this. If we already reached the end() or the rend() of the possible values, function incerr() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

i	The set of variable to not increment in this Instantiation.

Definition at line 475 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, contains(), domainSize(), and nbrDim().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::MultiDimContainer< GUM_SCALAR >::extractFrom(), gum::FMDPSimulator::perform(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                                           {
     Size p = nbrDim() - 1;
     Idx  cpt = 0;
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     while (true) {
       if (i.contains(__vars[cpt])) {
         if (cpt == p) {
           __overflow = true;
           return;
         } else
           ++cpt;
       } else {
         Idx v = __vals[cpt];
 
         if (v + 1 == __vars[cpt]->domainSize()) {
           __chgVal(cpt, 0);
 
           if (cpt == p) {
             __overflow = true;
             return;
           } else
             ++cpt;
         } else {
           __chgVal(cpt, v + 1);
           return;
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ incVar()

INLINE void gum::Instantiation::incVar ( const DiscreteVariable & v )

Operator increment for variable v only.

This function increment only variable v. Trying to increment the last possible value results in an overflow (no exception is thrown in this case). If we already reached the end() or the rend() of the possible values, function incVar() will perform nothing (this prevents looping inadvertently several times within the same loop). To unset the end flag, use functions unsetOverflow(), unsetEnd() or one of the setFirst() or setLast().

Parameters

v	The variable to increment in this Instantiation.

Exceptions

NotFound Raised if variable v does not belong to the Instantiation.

Definition at line 664 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, and gum::DiscreteVariable::domainSize().

Referenced by gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), and gum::Potential< GUM_SCALAR >::normalizeAsCPT().

                                                              {
     // get the position of the variable
     Idx cpt = __vars.pos(&v);
     // if we are in overflow, do nothing
 
     if (__overflow) return;
 
     Idx p = __vals[cpt];
 
     if (p + 1 == v.domainSize()) {
       __chgVal(cpt, 0);
       __overflow = true;
     } else {
       __chgVal(cpt, p + 1);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inOverflow()

INLINE bool gum::Instantiation::inOverflow ( ) const

Indicates whether the current value of the tuple is correct or not.

The function inOverflow() is used to flag overflowed operation (for instance, ++ on the last value or – on the first value will produce an incorrect value of the tuple. Hence inOverflow() is used as an end()/rend() function for loops on Instantiation.

for(Instantiation i.setFirst(); !i.inOverflow(); ++i) {
  // code...
}

Definition at line 224 of file instantiation_inl.h.

References __overflow.

Referenced by end(), operator==(), and rend().

224 { return __overflow; }

gum::Instantiation::__overflow

bool __overflow

Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...

Definition: instantiation.h:1140

Here is the caller graph for this function:

◆ isMaster() [1/2]

INLINE bool gum::Instantiation::isMaster ( const MultiDimAdressable * m ) const

Indicates whether m is the master of this instantiation.

Returns: Returns true if m is the master of this instantiation.

Definition at line 715 of file instantiation_inl.h.

References __master.

Referenced by gum::MultiDimArray< GUM_SCALAR >::_get(), gum::MultiDimSparse< GUM_SCALAR >::get(), gum::MultiDimBijArray< GUM_SCALAR >::get(), gum::MultiDimBucket< GUM_SCALAR >::get(), isMaster(), operator=(), gum::MultiDimSparse< GUM_SCALAR >::set(), and gum::MultiDimWithOffset< GUM_SCALAR >::toString().

                                                                        {
     return (__master == m);
   }

Here is the caller graph for this function:

◆ isMaster() [2/2]

INLINE bool gum::Instantiation::isMaster ( const MultiDimAdressable & m ) const

Indicates whether m is the master of this instantiation.

Returns: Returns true if m is the master of this instantiation.

Definition at line 720 of file instantiation_inl.h.

References isMaster().

                                                                        {
     return isMaster(&m);
   }

Here is the call graph for this function:

◆ isSlave()

INLINE bool gum::Instantiation::isSlave ( ) const

Indicates whether the Instantiation has a master.

Returns: Returns true if the Instantiation has a master.

Definition at line 712 of file instantiation_inl.h.

References __master.

712 { return (__master != 0); }

gum::Instantiation::__master

MultiDimAdressable * __master

The master, if any, contains precisely the set of variables to be instantiated.

Definition: instantiation.h:1127

◆ nbrDim()

INLINE Idx gum::Instantiation::nbrDim ( ) const

finalvirtual

Returns the number of variables in the Instantiation.

Returns: Returns the number of variables in the Instantiation.

Implements gum::MultiDimInterface.

Definition at line 188 of file instantiation_inl.h.

References __vars.

Referenced by gum::aggregator::Amplitude< GUM_SCALAR >::_buildValue(), gum::aggregator::Median< GUM_SCALAR >::_buildValue(), gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), gum::InfluenceDiagram< GUM_SCALAR >::_copyTables(), dec(), decIn(), decNotVar(), decOut(), gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), inc(), incIn(), incNotVar(), incOut(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), operator=(), operator==(), gum::MultiDimImplementation< std::string >::registerSlave(), gum::credal::CredalNet< GUM_SCALAR >::setCPT(), setFirst(), setFirstIn(), setFirstNotVar(), setFirstOut(), setLast(), setLastIn(), setLastNotVar(), setLastOut(), setVals(), and gum::Estimator< GUM_SCALAR >::update().

188 { return __vars.size(); }

gum::Instantiation::__vars

Sequence< const DiscreteVariable *> __vars

The tuple of variables to be instantiated.

Definition: instantiation.h:1130

Here is the caller graph for this function:

◆ operator++()

INLINE Instantiation & gum::Instantiation::operator++ ( )

Alias of Instantiation::inc().

Returns: Returns this Instantiation.

Definition at line 306 of file instantiation_inl.h.

References inc().

                                                   {
     inc();
     return *this;
   }

Here is the call graph for this function:

◆ operator+=()

INLINE Instantiation & gum::Instantiation::operator+= ( Size depl )

Calls depl times Instantiation::inc().

Returns: Returns this Instantiation.

Definition at line 318 of file instantiation_inl.h.

References inc().

                                                            {
     //@todo : this code should be improved !!!
     for (Idx i = 0; i < depl; i++)
       inc();
 
     return *this;
   }

Here is the call graph for this function:

◆ operator--()

INLINE Instantiation & gum::Instantiation::operator-- ( )

Alias of Instantiation::dec().

Returns: Returns this Instantiation.

Definition at line 312 of file instantiation_inl.h.

References dec().

                                                   {
     dec();
     return *this;
   }

Here is the call graph for this function:

◆ operator-=()

INLINE Instantiation & gum::Instantiation::operator-= ( Size depl )

Calls depl times Instantiation::dec().

Returns: Returns this Instantiation.

Definition at line 327 of file instantiation_inl.h.

References dec().

                                                            {
     //@todo : this code should be improved !!!
     for (Idx i = 0; i < depl; i++)
       dec();
 
     return *this;
   }

Here is the call graph for this function:

◆ operator=()

Instantiation & gum::Instantiation::operator= ( const Instantiation & aI )

Copy operator.

If this is a slave but not with the same as aI's master: if aI and this does not share the same variables then an OperationNotAllowed will we be raised. Otherwise calls this->setVals( aI ).

If this is not a slave, copies aI.

Parameters

aI	The Instantiation to copy.

Exceptions

OperationNotAllowed Raised if copy is not allowed.

Definition at line 116 of file instantiation.cpp.

References __master, __overflow, __vals, __vars, actAsSlave(), contains(), GUM_ERROR, isMaster(), nbrDim(), setVals(), and variable().

                                                                  {
     if (__master) {
       if (!aI.isMaster(__master)) {   // aI as the same master.
         if (nbrDim() != aI.nbrDim()) {
           GUM_ERROR(OperationNotAllowed, "in slave Instantiation");
         }
 
         for (Idx i = 0; i < nbrDim(); i++) {
           if ((!contains(aI.variable(i))) || (!aI.contains(variable(i)))) {
             GUM_ERROR(OperationNotAllowed, "in slave Instantiation");
           }
         }
       }
 
       setVals(aI);
     } else {
       // copy the content of aI
       __vars = aI.__vars;
       __vals = aI.__vals;
       __overflow = aI.__overflow;
 
       if (aI.__master) actAsSlave(*aI.__master);
     }
 
     return *this;
   }

Here is the call graph for this function:

◆ operator==()

INLINE bool gum::Instantiation::operator== ( const Instantiation & other ) const

operator==

Definition at line 827 of file instantiation_inl.h.

References contains(), inOverflow(), nbrDim(), val(), and variablesSequence().

                                                                         {
     if (inOverflow() && other.inOverflow()) return true;
     if (other.nbrDim() != nbrDim()) return false;
     for (const auto& k : variablesSequence()) {
       if (!other.contains(k)) return false;
       if (val(*k) != other.val(*k)) return false;
     }
     return true;
   }

Here is the call graph for this function:

◆ pos()

INLINE Idx gum::Instantiation::pos ( const DiscreteVariable & v ) const

finalvirtual

Returns the position of the variable v.

Returns: Returns the position of the variable v.

Parameters

v	The variable for which its position is return.

Exceptions

NotFound Raised if v does not belong to the instantiation.

Implements gum::MultiDimInterface.

Definition at line 183 of file instantiation_inl.h.

References __vars.

Referenced by __erase(), __reorder(), gum::prm::PRMFormAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::becomeCastDescendant(), chgVal(), decIn(), incIn(), and setVals().

                                                                {
     return __vars.pos(&k);
   }

Here is the caller graph for this function:

◆ rend()

INLINE bool gum::Instantiation::rend ( ) const

Returns true if the Instantiation reached the rend.

Function end() should be used as in:

for(Instantiation i.setLast();! i.rend(); --i) {
  // code
}

Returns: Returns true if the Instantiation reached the rend.

Definition at line 230 of file instantiation_inl.h.

References inOverflow().

230 { return inOverflow(); }

gum::Instantiation::inOverflow

bool inOverflow() const

Indicates whether the current value of the tuple is correct or not.

Definition: instantiation_inl.h:224

Here is the call graph for this function:

◆ reorder() [1/2]

INLINE void gum::Instantiation::reorder ( const Sequence< const DiscreteVariable * > & v )

Reorder vars of this instantiation giving the order in v.

In the new order variables common to v and *this are placed first, then variables only in *this.

The variables only in v are ignored.

Parameters

v	The new order of variables for this Instantiation.

Exceptions

OperationNotAllowed if slave instantiation

Definition at line 746 of file instantiation_inl.h.

References __master, __reorder(), and GUM_ERROR.

Referenced by gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), reorder(), and gum::credal::CredalNet< GUM_SCALAR >::setCPT().

                                                                                {
     if (__master != nullptr) {
       GUM_ERROR(OperationNotAllowed,
                 "Reordering impossible in slave instantiation");
     }
 
     __reorder(original);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reorder() [2/2]

INLINE void gum::Instantiation::reorder ( const Instantiation & i )

Calls reorder(const Sequence<const DiscreteVariable*>&) with i.variablesSequence()

Parameters

i	The sequence of variables with which to reorder this Instantiation.

Definition at line 441 of file instantiation_inl.h.

References reorder(), and variablesSequence().

                                                            {
     reorder(i.variablesSequence());
   }

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

◆ setFirst()

INLINE void gum::Instantiation::setFirst ( )

Assign the first values to the tuple of the Instantiation.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. This function naturally unsets the overFlow flag.

Definition at line 336 of file instantiation_inl.h.

References __masterFirstNotification(), __overflow, __vals, and nbrDim().

                                       {
     __overflow = false;
     Size s = nbrDim();
 
     for (Idx p = 0; p < s; ++p)
       __vals[p] = 0;
 
     __masterFirstNotification();
   }

Here is the call graph for this function:

◆ setFirstIn()

INLINE void gum::Instantiation::setFirstIn ( const Instantiation & i )

Assign the first values in the Instantiation for the variables in i.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. Note also that the value of instantiation i is not taken into account, that is, only the variables not belonging to i are taken into account. This function naturally unsets the overFlow flag.

Parameters

i	The variables to which their first value is assigned in this Instantiation.

Definition at line 446 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, contains(), and nbrDim().

Referenced by gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                                               {
     __overflow = false;
     Idx s = nbrDim();
 
     for (Size p = 0; p < s; ++p)
       if (i.contains(__vars[p])) __chgVal(p, 0);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFirstNotVar()

INLINE void gum::Instantiation::setFirstNotVar ( const DiscreteVariable & v )

Assign the first values to variables different of v.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. This function naturally unsets the overFlow flag.

Parameters

v	Tha variable that will not be set to its first value in this Instantiation.

Definition at line 630 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, nbrDim(), and setFirst().

Referenced by gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), and gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT().

                                                                      {
     __overflow = false;
     Idx s = nbrDim();
 
     for (Size p = 0; p < s; ++p) {
       if (__vars[p] == &v) {
         Idx oldval = __vals[p];
         setFirst();
         __chgVal(p, oldval);
         return;
       }
     }
 
     setFirst();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFirstOut()

INLINE void gum::Instantiation::setFirstOut ( const Instantiation & i )

Assign the first values in the Instantiation for the variables not in i.

Note that, if the Instantiation is related to a qum::MultiDimAdressable, then the corresponding value in the latter is updated. Note also that the value of instantiation i is not taken into account, that is, only the variables not belonging to i are taken into account. This function naturally unsets the overFlow flag.

Parameters

i	The variable that will not be set to their first value in this Instantiation.

Definition at line 544 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, contains(), and nbrDim().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::MultiDimContainer< GUM_SCALAR >::extractFrom(), gum::FMDPSimulator::perform(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                                                {
     __overflow = false;
     Idx s = nbrDim();
 
     for (Size p = 0; p < s; ++p)
       if (!i.contains(__vars[p])) __chgVal(p, 0);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFirstVar()

INLINE void gum::Instantiation::setFirstVar ( const DiscreteVariable & v )

Assign the first value in the Instantiation for var v.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. This function naturally unsets the overFlow flag.

Parameters

v	The variable that will be set to its first value in this Instantiation.

Definition at line 700 of file instantiation_inl.h.

References __chgVal(), __overflow, and __vars.

Referenced by gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), and gum::Potential< GUM_SCALAR >::normalizeAsCPT().

                                                                   {
     __overflow = false;
     __chgVal(__vars.pos(&v), 0);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setLast()

INLINE void gum::Instantiation::setLast ( )

Assign the last values in the Instantiation.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. This function naturally unsets the overFlow flag.

Definition at line 347 of file instantiation_inl.h.

References __masterLastNotification(), __overflow, __vals, __vars, domainSize(), and nbrDim().

Referenced by setLastNotVar().

                                      {
     __overflow = false;
     Size s = nbrDim();
 
     for (Idx p = 0; p < s; ++p)
       __vals[p] = __vars[p]->domainSize() - 1;
 
     __masterLastNotification();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setLastIn()

INLINE void gum::Instantiation::setLastIn ( const Instantiation & i )

Assign the last values in the Instantiation for the variables in i.

Where Di is the domain size of variable i in the Instantiation) for the i vars.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. Note also that the value of instantiation i is not taken into account, that is, only the variables belonging to i are taken into account. This function naturally unsets the overFlow flag.

Parameters

i	The variables to which their last value is assigned in this Instantiation.

Definition at line 466 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, contains(), domainSize(), and nbrDim().

                                                              {
     __overflow = false;
     Idx s = nbrDim();
 
     for (Size p = 0; p < s; ++p)
       if (i.contains(__vars[p])) __chgVal(p, __vars[p]->domainSize() - 1);
   }

Here is the call graph for this function:

◆ setLastNotVar()

INLINE void gum::Instantiation::setLastNotVar ( const DiscreteVariable & v )

Assign the last values to variables different of v.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. This function naturally unsets the overFlow flag.

Parameters

v	The variable that will not be set to its last value in this Instantiation.

Definition at line 647 of file instantiation_inl.h.

References __chgVal(), __overflow, __vals, __vars, nbrDim(), and setLast().

                                                                     {
     __overflow = false;
     Idx s = nbrDim();
 
     for (Size p = 0; p < s; ++p) {
       if (__vars[p] == &v) {
         Idx oldval = __vals[p];
         setLast();
         __chgVal(p, oldval);
         return;
       }
     }
 
     setLast();
   }

Here is the call graph for this function:

◆ setLastOut()

INLINE void gum::Instantiation::setLastOut ( const Instantiation & i )

Assign the last values in the Instantiation for the variables not in i.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. Note also that the value of instantiation i is not taken into account, that is, only the variables not belonging to i are taken into account. This function naturally unsets the overFlow flag.

Parameters

i	The variables that will not be set to their last value in this Instantiation.

Definition at line 553 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, contains(), domainSize(), and nbrDim().

                                                               {
     __overflow = false;
     Idx s = nbrDim();
 
     for (Size p = 0; p < s; ++p)
       if (!i.contains(__vars[p])) __chgVal(p, __vars[p]->domainSize() - 1);
   }

Here is the call graph for this function:

◆ setLastVar()

INLINE void gum::Instantiation::setLastVar ( const DiscreteVariable & v )

Assign the last value in the Instantiation for var v.

Note that, if the Instantiation is related to a MultiDimAdressable, then the corresponding value in the latter is updated. This function naturally unsets the overFlow flag.

Parameters

v	The variable that will be set to its last value in this Instantiation.

Definition at line 706 of file instantiation_inl.h.

References __chgVal(), __overflow, __vars, and gum::DiscreteVariable::domainSize().

                                                                  {
     __overflow = false;
     __chgVal(__vars.pos(&v), v.domainSize() - 1);
   }

Here is the call graph for this function:

◆ setVals()

INLINE Instantiation & gum::Instantiation::setVals ( const Instantiation & i )

Assign the values from i in the Instantiation.

For any variable in i and in *this, value of the variable in i is assigned to the variable in *this.

In addition of modifying the value of the variables in *this, the Instantiation informs its master of the modification. This function also unsets the overflow flag.

If no variables in i matches, then no value is changed.

Warning: Variables has to be "the same". Therefore chgValIn is usefull in a same domain variables (for instance a BN). However two identical variables will not be recognized as same (for instance between 2 BNs).

See also: Instantiation::setValsFrom for this kind of utilisation.

Parameters

i	A Instantiation in which the new values are searched.

Returns: Returns a reference to *this in order to chain the chgVal.

Definition at line 455 of file instantiation_inl.h.

References __chgVal(), __overflow, contains(), nbrDim(), pos(), val(), and variable().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::SimpleCPTDisturber< GUM_SCALAR >::disturbReducCPT(), gum::MultiDimContainer< GUM_SCALAR >::extractFrom(), gum::learning::DAG2BNLearner< ALLOC >::operator=(), operator=(), gum::prm::PRMFactory< GUM_SCALAR >::setCPFByRule(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

                                                                      {
     __overflow = false;
     Idx s = i.nbrDim();
 
     for (Size p = 0; p < s; ++p)
       if (contains(i.variable(p))) __chgVal(pos(i.variable(p)), i.val(p));
 
     return *this;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setValsFrom()

void gum::Instantiation::setValsFrom	(	const HashTable< const DiscreteVariable , const DiscreteVariable > &	map,
		const Instantiation &	external
	)

Assign the values of external in *this, using map as a bijection between external and this variables.

Parameters

map	Keys are variables in external.
external	An instantiation used to change the values in j.

Exceptions

NotFound Raised if a variable in external does not point to a variable in *this or in external.

Definition at line 176 of file instantiation.cpp.

References chgVal(), GUM_ERROR, gum::Variable::name(), and val().

                                     {
     for (const auto& elt : map) {
       const DiscreteVariable& var = *elt.second;
 
       try {
         Idx val = external.val(*elt.first);
 
         try {
           chgVal(var, val);
         } catch (NotFound&) {
           GUM_ERROR(NotFound,
                     var.name() << " : missing variable in instantiation");
         }
       } catch (NotFound&) {
         GUM_ERROR(NotFound,
                   var.name() << " : missing variable in external instantiation");
       }
     }
   }

Here is the call graph for this function:

◆ synchronizeWithMaster()

void gum::Instantiation::synchronizeWithMaster ( const MultiDimAdressable * m )

Force the variables sequence to be the same as the master one.

The master should be a friend to notify dimensions changes friend class MultiDimAdressable.

Parameters

m	The master of this instantiation.

Exceptions

OperationNotAllowed Raised if m is not the master of instantiation.

Definition at line 228 of file instantiation.cpp.

References __master, __reorder(), GUM_ERROR, and gum::MultiDimInterface::variablesSequence().

Referenced by gum::MultiDimImplementation< std::string >::registerSlave().

                                                                        {
     if (m != __master) {
       GUM_ERROR(OperationNotAllowed, "only master can do this");
     }
 
     __reorder(__master->variablesSequence());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toString()

std::string gum::Instantiation::toString ( ) const

Give a string version of instantiation.

Returns: Returns a string version of instantiation.

Definition at line 144 of file instantiation.cpp.

References __overflow, __vars, and val().

Referenced by gum::operator<<(), gum::MultiDimICIModel< GUM_SCALAR >::toString(), and gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString().

                                           {
     std::stringstream sstr;
     // check if the value of the instantiation is correct
 
     if (__overflow) { sstr << "<invalid>"; }
 
     sstr << "<";
 
     bool first = true;
 
     for (const auto var : __vars) {
       if (!first) sstr << "|";
 
       first = false;
       sstr << var->name() << ":" << var->label(val(*var));
     }
 
     sstr << ">";
 
     return sstr.str();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unsetEnd()

INLINE void gum::Instantiation::unsetEnd ( )

Alias for unsetOverflow().

See also: unsetOverflow().

Definition at line 237 of file instantiation_inl.h.

References __overflow.

Referenced by gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), and gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT().

237 { __overflow = false; }

gum::Instantiation::__overflow

bool __overflow

Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...

Definition: instantiation.h:1140

Here is the caller graph for this function:

◆ unsetOverflow()

INLINE void gum::Instantiation::unsetOverflow ( )

Removes the flag overflow.

See full documentation for details. (Recommended).

When we use multiple inner loops w.r.t. a given Instantiation, it may happen that one inner loop reaches the end() of the Instantiation while the outer loops do not have reached it. This means that the inner loop has toggled the overflow flag. To enable the other loops to go on, we must unset this flag using function unsetOverflow(). For instance, assume that Prob represents probability P(b|a,c), then normalizing this proba can be performed using the following code:

// assume the probability has been defined somewhere:
MultiDimArray<double> Prob;
// create 2 instantiations for the 2 necessary loops
Instantiation i(Prob), j;
j << a << c;
double delta;
// outer loop: loop over the values of b
for(i.setFirstIn(j); !i.end(); i.incIn(j))
{
  delta = 0.0;
  // inner loop: loop over the values of a and c
  for(i.setFirstOut(j); !i.end(); i.incerr(j))
    delta += dd[i];
  for(i.setFirstOut(j); !i.end(); i.incerr(j))
    dd[i] /= delta;
  // indicate that the end() reached after looping over a and c does not
  // correspond to an end() for the loop w.r.t. b
  i.unsetOverflow();
}

Definition at line 234 of file instantiation_inl.h.

References __overflow.

234 { __overflow = false; }

gum::Instantiation::__overflow

bool __overflow

Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...

Definition: instantiation.h:1140

◆ val() [1/2]

INLINE Idx gum::Instantiation::val ( Idx i ) const

Returns the current value of the variable at position i.

Warning: For speed issues, the function does not actually check whether the overflow flag is set before returning the current value of the variable as, usually, it is not necessary. If need be, use function inOverflow() to check.

Parameters

i	The index of the variable.

Returns: Returns the current value of the variable at position i.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 191 of file instantiation_inl.h.

References __vals, and GUM_ERROR.

Referenced by gum::BayesNetInference< GUM_SCALAR >::__isHardEvidence(), gum::aggregator::Amplitude< GUM_SCALAR >::_buildValue(), gum::aggregator::Median< GUM_SCALAR >::_buildValue(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::_buildValue(), gum::InfluenceDiagram< GUM_SCALAR >::_copyTables(), gum::MonteCarloSampling< GUM_SCALAR >::_draw(), gum::HashFunc< Instantiation >::castToSize(), gum::prm::o3prmr::O3prmrInterpreter::checkObserve(), gum::Potential< GUM_SCALAR >::draw(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::SDYNA::feedback(), gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), 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::MultiDimFunctionGraph< bool, ExactTerminalNodePolicy >::get(), hamming(), gum::AbstractSimulator::hasReachEnd(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), gum::IBayesNet< double >::operator==(), operator==(), gum::FMDPSimulator::perform(), gum::prm::o3prmr::O3prmrInterpreter::query(), gum::credal::CredalNet< GUM_SCALAR >::setCPT(), setVals(), setValsFrom(), gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked(), toString(), and gum::Estimator< GUM_SCALAR >::update().

                                            {
     if (i >= __vals.size()) {
       GUM_ERROR(NotFound, i << " is out of bound index for the instantiation.");
     }
 
     return __vals[i];
   }

◆ val() [2/2]

INLINE Idx gum::Instantiation::val ( const DiscreteVariable & var ) const

Returns the current value of a given variable.

Warning: For speed issues, the function does not actually check whether the overflow flag is set before returning the current value of the variable as, usually, it is not necessary. If need be, use function inOverflow() to check.

Parameters

var	The variable the value of which we wish to know.

Returns: Returns the current value of a given variable.

Exceptions

NotFound Raised it var does not belong to the instantiation.

Definition at line 200 of file instantiation_inl.h.

References __vals, and __vars.

                                                                  {
     return __vals[__vars.pos(&var)];
   }

◆ valFromPtr()

INLINE Idx gum::Instantiation::valFromPtr ( const DiscreteVariable * pvar ) const

Returns the current value of a given variable.

Warning: For speed issues, the function does not actually check whether the overflow flag is set before returning the current value of the variable as, usually, it is not necessary. If need be, use function inOverflow() to check.

Parameters

pvar	The variable for which the value is returned.

Returns: Returns the current value of a given variable.

Exceptions

NotFound Raised if var does not belong to the instantiation.

Definition at line 205 of file instantiation_inl.h.

References __vals, and __vars.

                                                                          {
     return __vals[__vars.pos(pvar)];
   }

Here is the caller graph for this function:

◆ variable() [1/2]

INLINE const DiscreteVariable & gum::Instantiation::variable ( Idx i ) const

finalvirtual

Returns the variable at position i in the tuple.

Parameters

i	The index of the variable

Returns: Returns the variable at position i in the tuple.

Exceptions

NotFound Raised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 210 of file instantiation_inl.h.

References __vars.

Referenced by gum::aggregator::Median< GUM_SCALAR >::_buildValue(), gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), gum::InfluenceDiagram< GUM_SCALAR >::_copyTables(), chgVal(), decIn(), gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), incIn(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), operator=(), gum::IBayesNet< double >::operator==(), gum::credal::CredalNet< GUM_SCALAR >::setCPT(), setVals(), and gum::Estimator< GUM_SCALAR >::update().

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

Here is the caller graph for this function:

◆ variable() [2/2]

INLINE const DiscreteVariable & gum::Instantiation::variable ( const std::string & name ) const

finalvirtual

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 215 of file instantiation_inl.h.

References __vars, and GUM_ERROR.

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

◆ variablesSequence()

INLINE const Sequence< const DiscreteVariable *> & gum::Instantiation::variablesSequence ( ) const

finalvirtual

Returns the sequence of DiscreteVariable of this instantiation.

Returns: Returns the sequence of DiscreteVariable of this instantiation.

Implements gum::MultiDimInterface.

Definition at line 726 of file instantiation_inl.h.

References __vars.

Referenced by gum::StatesCounter::__incState(), gum::StatesChecker::__insertState(), gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::HashFunc< Instantiation >::castToSize(), gum::SDYNA::feedback(), gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), gum::AbstractSimulator::hasReachEnd(), operator==(), reorder(), gum::StatesCounter::reset(), gum::StatesChecker::reset(), and gum::credal::CredalNet< GUM_SCALAR >::setCPT().

                                                       {
     return __vars;
   }

Here is the caller graph for this function:

Member Data Documentation

◆ __master

MultiDimAdressable* gum::Instantiation::__master

private

The master, if any, contains precisely the set of variables to be instantiated.

Definition at line 1127 of file instantiation.h.

Referenced by __masterChangeNotification(), __masterDecNotification(), __masterFirstNotification(), __masterIncNotification(), __masterLastNotification(), actAsSlave(), add(), addWithMaster(), clear(), erase(), eraseWithMaster(), forgetMaster(), Instantiation(), isMaster(), isSlave(), operator=(), reorder(), synchronizeWithMaster(), and ~Instantiation().

◆ __overflow

bool gum::Instantiation::__overflow

private

Indicates whether the current value of the tuple is valid when we loop sufficiently over values of the tuple, we may have browsed all the possible values and we have to know in a way or another that the tuple contains no more value. This is precisely the meaning of Boolean overflow.

Definition at line 1140 of file instantiation.h.

Referenced by __add(), chgVal(), dec(), decIn(), decNotVar(), decOut(), decVar(), inc(), incIn(), incNotVar(), incOut(), incVar(), inOverflow(), Instantiation(), operator=(), setFirst(), setFirstIn(), setFirstNotVar(), setFirstOut(), setFirstVar(), setLast(), setLastIn(), setLastNotVar(), setLastOut(), setLastVar(), setVals(), toString(), unsetEnd(), and unsetOverflow().

◆ __vals

std::vector< Idx > gum::Instantiation::__vals

private

The current instantiation: the value of the tuple.

Definition at line 1133 of file instantiation.h.

Referenced by __add(), __chgVal(), __erase(), __init(), __swap(), chgVal(), clear(), dec(), decIn(), decNotVar(), decOut(), decVar(), empty(), inc(), incIn(), incNotVar(), incOut(), incVar(), Instantiation(), operator=(), setFirst(), setFirstNotVar(), setLast(), setLastNotVar(), val(), and valFromPtr().

◆ __vars

Sequence< const DiscreteVariable* > gum::Instantiation::__vars

private

The tuple of variables to be instantiated.

Definition at line 1130 of file instantiation.h.

Referenced by __add(), __erase(), __init(), __masterChangeNotification(), __swap(), _replace(), add(), chgVal(), clear(), contains(), dec(), decIn(), decNotVar(), decOut(), decVar(), domainSize(), erase(), hamming(), inc(), incIn(), incNotVar(), incOut(), incVar(), Instantiation(), nbrDim(), operator=(), pos(), setFirstIn(), setFirstNotVar(), setFirstOut(), setFirstVar(), setLast(), setLastIn(), setLastNotVar(), setLastOut(), setLastVar(), toString(), val(), valFromPtr(), variable(), and variablesSequence().

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

agrum/multidim/instantiation.h
agrum/multidim/instantiation.cpp
agrum/multidim/instantiation_inl.h

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Instantiation() [1/6]

◆ Instantiation() [2/6]

◆ Instantiation() [3/6]

◆ Instantiation() [4/6]

◆ Instantiation() [5/6]

◆ Instantiation() [6/6]

◆ ~Instantiation()

Member Function Documentation

◆ __add()

◆ __chgVal()

◆ __erase()

◆ __init()

◆ __masterChangeNotification()

◆ __masterDecNotification()

◆ __masterFirstNotification()

◆ __masterIncNotification()

◆ __masterLastNotification()

◆ __notifiedDimChanged()

◆ __reorder()

◆ __swap()

◆ _replace()

◆ actAsSlave()

◆ add()

◆ addWithMaster()

◆ chgVal() [1/5]

◆ chgVal() [2/5]

◆ chgVal() [3/5]

◆ chgVal() [4/5]

◆ chgVal() [5/5]

◆ clear()

◆ contains() [1/2]

◆ contains() [2/2]

◆ dec()

◆ decIn()

◆ decNotVar()

◆ decOut()

◆ decVar()

◆ domainSize()

◆ empty()

◆ end()

◆ erase()

◆ eraseWithMaster()

◆ forgetMaster()

◆ hamming()

◆ inc()

◆ incIn()

◆ incNotVar()

◆ incOut()

◆ incVar()

◆ inOverflow()

◆ isMaster() [1/2]

◆ isMaster() [2/2]

◆ isSlave()

◆ nbrDim()

◆ operator++()

◆ operator+=()

◆ operator--()

◆ operator-=()

◆ operator=()

◆ operator==()

◆ pos()

◆ rend()

◆ reorder() [1/2]

◆ reorder() [2/2]

◆ replace()

◆ setFirst()

◆ setFirstIn()

◆ setFirstNotVar()

◆ setFirstOut()

◆ setFirstVar()

◆ setLast()

◆ setLastIn()

◆ setLastNotVar()

◆ setLastOut()

◆ setLastVar()

◆ setVals()