gum::Instantiation Class Reference

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

#include <agrum/tools/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	erase (const std::string &name)
	Returns the number of variables in 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	val (const std::string &name) const
	Returns the number of variables in the Instantiation. 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 std::string &name) const
	Returns the number of variables in 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 82 of file instantiation.h.

Constructor & Destructor Documentation

Instantiation() [1/6]

gum::Instantiation::Instantiation

(

)

Default constructor: creates an empty tuple.

Definition at line 39 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                               : _master_(nullptr), _overflow_(false) {
    GUM_CONSTRUCTOR(Instantiation);
  }

Here is the call graph for this function:

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 98 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                                               :
      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 67 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                    : _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 73 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                          : _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 80 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                    : _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 90 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                                : _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 44 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                            {
    _vars_.insert(&v);
    _vals_.push_back(0);
    _overflow_ = false;
  }

Here is the call 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 44 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                            {
    Idx oldVal     = _vals_[varPos];
    _vals_[varPos] = newVal;

    _masterChangeNotification_(varPos, newVal, oldVal);
  }

Here is the call 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 769 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                              {
    // 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:

_init_()

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

private

Initialize this Instantiation.

Parameters

master

This Instantiation's master.

Definition at line 51 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                       {
    // 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:

_masterChangeNotification_()

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

private

Definition at line 189 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

_masterDecNotification_()

void gum::Instantiation::_masterDecNotification_ ( ) const

private

Definition at line 203 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

_masterFirstNotification_()

void gum::Instantiation::_masterFirstNotification_ ( ) const

private

Definition at line 193 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

_masterIncNotification_()

void gum::Instantiation::_masterIncNotification_ ( ) const

private

Definition at line 197 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

_masterLastNotification_()

void gum::Instantiation::_masterLastNotification_ ( ) const

private

Definition at line 200 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 736 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                   {
    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:

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

References gum::Set< Key, Alloc >::emplace().

                                                {
    if (i == j) return;

    _vars_.swap(i, j);

    Idx v;
    v         = _vals_[i];
    _vals_[i] = _vals_[j];
    _vals_[j] = v;
  }

Here is the call graph for this function:

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 231 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                        {
    // 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:

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

References gum::Set< Key, Alloc >::emplace().

                                                          {
    // 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:

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                                                   {
    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() [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 73 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                                    {
    // 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 110 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                   {
    if (_master_) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation") }

    _vars_.clear();
    _vals_.clear();
  }

Here is the call graph for this function:

contains() [1/3]

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

References gum::Set< Key, Alloc >::emplace().

{ return _vars_.exists(&v); }

Here is the call graph for this function:

contains() [2/3]

INLINE bool gum::Instantiation::contains

(

const std::string &

name

)

const

Returns the number of variables in the Instantiation.

Returns

Returns the number of variables in the Instantiation.

Definition at line 36 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                 {
    return contains(variable(name));
  }

Here is the call graph for this function:

contains() [3/3]

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

References gum::Set< Key, Alloc >::emplace().

{ return _vars_.exists(v); }

Here is the call graph for this function:

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

References gum::Set< Key, Alloc >::emplace().

                                 {
    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:

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                             {
    // 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 166 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                              {
    Size s = 1;

    for (const auto var: _vars_)
      s *= var->domainSize();

    return s;
  }

Here is the call 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 777 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return _vals_.empty(); }

Here is the call 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 218 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return inOverflow(); }

Here is the call graph for this function:

erase() [1/2]

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

References gum::Set< Key, Alloc >::emplace().

                                                            {
    // 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:

erase() [2/2]

INLINE void gum::Instantiation::erase

(

const std::string &

name

)

Returns the number of variables in the Instantiation.

Returns

Returns the number of variables in the Instantiation.

Definition at line 154 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ erase(variable(name)); }

Here is the call 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 222 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
    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 208 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 160 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                 {
    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:

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

References gum::Set< Key, Alloc >::emplace().

                                                         {
    // 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:

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

References gum::Set< Key, Alloc >::emplace().

                                                                {
    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:

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

References gum::Set< Key, Alloc >::emplace().

                                                          {
    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:

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

References gum::Set< Key, Alloc >::emplace().

                                                             {
    // 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:

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

References gum::Set< Key, Alloc >::emplace().

{ return _overflow_; }

Here is the call 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 702 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return (_master_ == m); }

Here is the call 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 705 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

{ return (_master_ != nullptr); }

Here is the call graph for this function:

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

References gum::Set< Key, Alloc >::emplace().

{ return _vars_.size(); }

Here is the call graph for this function:

operator++()

INLINE Instantiation & gum::Instantiation::operator++

(

)

Alias of Instantiation::inc().

Returns

Returns this Instantiation.

Definition at line 297 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                           {
    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 111 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

{ return _vars_.pos(&k); }

Here is the call 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 221 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return inOverflow(); }

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

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
    if (_master_ != nullptr) {
      GUM_ERROR(OperationNotAllowed, "Reordering impossible in slave instantiation")
    }

    _reorder_(original);
  }

Here is the call 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 430 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                                                      {
    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:

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

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 325 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                      {
    _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 433 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

                                                                  {
    _overflow_ = false;
    _chgVal_(_vars_.pos(&v), 0);
  }

Here is the call 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 336 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

                                                             {
    _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 634 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                    {
    _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 540 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                              {
    _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 693 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                 {
    _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 442 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

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 169 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
    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 216 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                                       {
    if (m != _master_) { GUM_ERROR(OperationNotAllowed, "only master can do this") }

    _reorder_(_master_->variablesSequence());
  }

Here is the call 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 137 of file instantiation.cpp.

References gum::Set< Key, Alloc >::emplace().

                                          {
    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:

unsetEnd()

INLINE void gum::Instantiation::unsetEnd

(

)

Alias for unsetOverflow().

See also

unsetOverflow().

Definition at line 228 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ _overflow_ = false; }

Here is the call 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 225 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ _overflow_ = false; }

Here is the call graph for this function:

val() [1/3]

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

References gum::Set< Key, Alloc >::emplace().

                                           {
    if (i >= _vals_.size()) {
      GUM_ERROR(NotFound, i << " is out of bound index for the instantiation.")
    }

    return _vals_[i];
  }

Here is the call graph for this function:

val() [2/3]

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

References gum::Set< Key, Alloc >::emplace().

                                                                 {
    return _vals_[_vars_.pos(&var)];
  }

Here is the call graph for this function:

val() [3/3]

INLINE Idx gum::Instantiation::val

(

const std::string &

name

)

const

Returns the number of variables in the Instantiation.

Returns

Returns the number of variables in the Instantiation.

Definition at line 195 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

{ return val(variable(name)); }

Here is the call graph for this function:

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

References gum::Set< Key, Alloc >::emplace().

                                                                         {
    return _vals_[_vars_.pos(pvar)];
  }

Here is the call 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 204 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 206 of file instantiation_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
    for (const auto& v: _vars_) {
      if (v->name() == name) return *v;
    }

    GUM_ERROR(NotFound, "'" << name << "' can not be found in the instantiation.")
  }

Here is the call graph for this function:

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

References gum::Set< Key, Alloc >::emplace().

                                                                                           {
    return _vars_;
  }

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

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

_vals_

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

private

The current instantiation: the value of the tuple.

Definition at line 1133 of file instantiation.h.

_vars_

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

private

The tuple of variables to be instantiated.

Definition at line 1130 of file instantiation.h.

---

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

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