aGrUM  0.13.2
gum::Instantiation Class Reference

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...
 
Instantiationoperator= (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 DiscreteVariablevariable (Idx i) const final
 Returns the variable at position i in the tuple. More...
 
const DiscreteVariablevariable (const std::string &name) const final
 Returns the variable with the name. More...
 
InstantiationchgVal (const DiscreteVariable &v, Idx newval)
 Assign newval to variable v in the Instantiation. More...
 
InstantiationchgVal (const DiscreteVariable *v, Idx newval)
 Assign newval to variable v in the Instantiation. More...
 
InstantiationchgVal (Idx varPos, Idx newval)
 Assign newval to variable at position varPos in the Instantiation. More...
 
InstantiationchgVal (const std::string &var, Idx newval)
 Assign newval to variable at position varPos in the Instantiation. More...
 
InstantiationchgVal (const std::string &var, const std::string &newval)
 Assign newval to variable at position varPos in the Instantiation. More...
 
InstantiationsetVals (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...
 
Instantiationoperator++ ()
 Alias of Instantiation::inc(). More...
 
Instantiationoperator-- ()
 Alias of Instantiation::dec(). More...
 
Instantiationoperator+= (Size depl)
 Calls depl times Instantiation::inc(). More...
 
Instantiationoperator-= (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 80 of file instantiation.h.

Constructor & Destructor Documentation

gum::Instantiation::Instantiation ( )

Default constructor: creates an empty tuple.

Definition at line 42 of file instantiation.cpp.

42  : __master(nullptr), __overflow(false) {
43  GUM_CONSTRUCTOR(Instantiation);
44  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.
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
aIThe Instantiation we copy.
notifyMasterWhether or not notify master if exits.

Definition at line 105 of file instantiation.cpp.

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

105  :
106  MultiDimInterface(), __master(0), __overflow(false) {
107  // for debugging purposes
108  GUM_CONS_CPY(Instantiation);
109  // copy the content of aI
110  __vars = aI.__vars;
111  __vals = aI.__vals;
112  __overflow = aI.__overflow;
113 
114  if (aI.__master && notifyMaster) actAsSlave(*aI.__master);
115  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.
bool actAsSlave(MultiDimAdressable &aMD)
Tries to register the Instantiation to a MultiDimAdressable.
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
aMDThe array the variables of which are those of the Instantiation.

Definition at line 70 of file instantiation.cpp.

References __init().

70  :
71  __master(0), __overflow(false) {
72  // for debugging purposes
73  GUM_CONSTRUCTOR(Instantiation);
74  __init(&d);
75  }
void __init(MultiDimAdressable *master)
Initialize this Instantiation.
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.

+ Here is the call graph for this function:

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
aMDThe array the variables of which are those of the Instantiation.

Definition at line 77 of file instantiation.cpp.

References __init().

77  :
78  __master(0), __overflow(false) {
79  // for debugging purposes
80  GUM_CONSTRUCTOR(Instantiation);
81  __init(const_cast< MultiDimAdressable* >(&d));
82  }
void __init(MultiDimAdressable *master)
Initialize this Instantiation.
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.

+ Here is the call graph for this function:

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
aMDThe array the variables of which are those of the Instantiation.

Definition at line 85 of file instantiation.cpp.

References __init().

85  :
86  __master(0), __overflow(false) {
87  // for debugging purposes
88  GUM_CONSTRUCTOR(Instantiation);
89 
90  if (d) __init(d);
91  }
void __init(MultiDimAdressable *master)
Initialize this Instantiation.
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.

+ Here is the call graph for this function:

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
aMDThe array the variables of which are those of the Instantiation.

Definition at line 96 of file instantiation.cpp.

References __init().

96  :
97  __master(0), __overflow(false) {
98  // for debugging purposes
99  GUM_CONSTRUCTOR(Instantiation);
100 
101  if (const_d) __init(const_cast< MultiDimAdressable* >(const_d));
102  }
void __init(MultiDimAdressable *master)
Initialize this Instantiation.
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.

+ Here is the call graph for this function:

gum::Instantiation::~Instantiation ( )

Destructor.

Definition at line 47 of file instantiation.cpp.

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

47  {
48  GUM_DESTRUCTOR(Instantiation);
49  // unregister the Instantiation from its __master
50 
51  if (__master) __master->unregisterSlave(*this);
52  }
virtual bool unregisterSlave(Instantiation &i)=0
Unregister i as a slave of this MultiDimAdressable.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
Instantiation()
Default constructor: creates an empty tuple.

+ Here is the call graph for this function:

Member Function Documentation

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
vThe new var.
Exceptions
DuplicateElementRaised if v is already in this Instantiation.

Definition at line 783 of file instantiation_inl.h.

References __overflow, __vals, and __vars.

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

783  {
784  __vars.insert(&v);
785  __vals.push_back(0);
786  __overflow = false;
787  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the caller graph for this function:

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
varPosThe variable to change.
newValThe variable new value.

Definition at line 42 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().

42  {
43  Idx oldVal = __vals[varPos];
44  __vals[varPos] = newVal;
45 
46  __masterChangeNotification(varPos, newVal, oldVal);
47  }
void __masterChangeNotification(Idx varPos, Idx newVal, Idx oldVal) const
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vThe variable to be erased from the tuple.

Definition at line 790 of file instantiation_inl.h.

References __vals, __vars, and pos().

Referenced by erase(), and eraseWithMaster().

790  {
791  // get the position of the variable
792  Idx pos = __vars.pos(&v);
793  __vars.erase(&v);
794  __vals.erase(__vals.begin() + pos);
795  }
Idx pos(const DiscreteVariable &v) const final
Returns the position of the variable v.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Initialize this Instantiation.

Parameters
masterThis Instantiation's master.

Definition at line 54 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().

54  {
55  // for speed issues
56  assert(master != nullptr);
57 
58  const Sequence< const DiscreteVariable* >& v = master->variablesSequence();
59  __vars.resize(v.size());
60  __vals.reserve(v.size());
61  // fill the instantiation
62 
63  for (const auto var : v)
64  __add(*var);
65 
66  actAsSlave(master->getMasterRef());
67  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
bool actAsSlave(MultiDimAdressable &aMD)
Tries to register the Instantiation to a MultiDimAdressable.
void __add(const DiscreteVariable &v)
Adds a new var to the sequence of vars.
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 200 of file instantiation.cpp.

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

Referenced by __chgVal().

202  {
203  if (__master)
204  __master->changeNotification(*this, __vars[varPos], oldVal, newVal);
205  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
virtual void changeNotification(const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval)=0
Listen to changes in a given Instantiation.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void gum::Instantiation::__masterDecNotification ( ) const
private

Definition at line 217 of file instantiation.cpp.

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

Referenced by dec().

217  {
218  if (__master) __master->setDecNotification(*this);
219  }
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
virtual void setDecNotification(const Instantiation &i)=0
Listen to increment in each recorded Instantiation.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void gum::Instantiation::__masterFirstNotification ( ) const
private

Definition at line 207 of file instantiation.cpp.

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

Referenced by inc(), and setFirst().

207  {
209  }
virtual void setFirstNotification(const Instantiation &i)=0
Listen to setFirst in a given Instantiation.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void gum::Instantiation::__masterIncNotification ( ) const
private

Definition at line 211 of file instantiation.cpp.

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

Referenced by inc().

211  {
212  if (__master) __master->setIncNotification(*this);
213  }
virtual void setIncNotification(const Instantiation &i)=0
Listen to increment in a given Instantiation.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void gum::Instantiation::__masterLastNotification ( ) const
private

Definition at line 214 of file instantiation.cpp.

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

Referenced by dec(), and setLast().

214  {
216  }
virtual void setLastNotification(const Instantiation &i)=0
Listen to setLast in a given Instantiation.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vthe new vars list
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
vThe new order of variables in this Instantiation.

Definition at line 754 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().

754  {
755  Idx max = original.size();
756  Idx position = 0;
757  for (Idx i = 0; i < max; ++i) {
758  const DiscreteVariable* pv = original.atPos(i);
759 
760  if (contains(pv)) {
761  auto p = pos(*pv);
762  GUM_ASSERT(p >= position); // this var should not be
763  // already placed.
764  __swap(position, p);
765  position++;
766  }
767  }
768  }
Idx pos(const DiscreteVariable &v) const final
Returns the position of the variable v.
bool contains(const DiscreteVariable &v) const final
Indicates whether a given variable belongs to the Instantiation.
void __swap(Idx i, Idx j)
Swap two variables in the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Swap two variables in the Instantiation.

Parameters
iThe first variable.
jThe second variable.

Definition at line 729 of file instantiation_inl.h.

References __vals, and __vars.

Referenced by __reorder().

729  {
730  if (i == j) return;
731 
732  __vars.swap(i, j);
733 
734  Idx v;
735  v = __vals[i];
736  __vals[i] = __vals[j];
737  __vals[j] = v;
738  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the caller graph for this function:

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

Replace x by y.

Parameters
xThe variable to replace.
yThe variable replacing x.

Implements gum::MultiDimInterface.

Definition at line 801 of file instantiation_inl.h.

References __vars.

802  {
803  __vars.setAtPos(__vars.pos(x), y);
804  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
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
aMDThe 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
OperationNotAllowedRaised if this instantiation has already a master.

Definition at line 250 of file instantiation.cpp.

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

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

250  {
251  // if __master : not allowed
252  if (__master != nullptr) {
253  GUM_ERROR(OperationNotAllowed, "in slave Instantiation");
254  }
255 
256  __master = &aMD;
257 
258  // perform the registration
259  if (aMD.registerSlave(*this)) {
260  return true;
261  } else {
262  __master = nullptr;
263  return false;
264  }
265  }
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vThe new variable added to this Instantiation.
Exceptions
DuplicateElementRaised if v is already in this Instantiation.
InvalidArgumentRaised if the name of v is already used in this Instantiation.
OperationNotAllowedRaised if this is a slave Instantiation.

Implements gum::MultiDimInterface.

Definition at line 122 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::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), gum::GibbsOperator< GUM_SCALAR >::monteCarloSample(), gum::FMDPSimulator::perform(), and gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByColumns().

122  {
123  // if __master : not allowed
124  if (__master) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation"); }
125 
126  // check if the variable already belongs to the tuple of variables
127  // of the Instantiation
128  if (__vars.exists(&v)) {
129  GUM_ERROR(DuplicateElement,
130  "Var <" << v.name() << "> already exists in this instantiation");
131  }
132 
133  for (const auto& vv : __vars) {
134  if (vv->name() == v.name()) {
135  GUM_ERROR(InvalidArgument,
136  "Var with name <" << v.name()
137  << "> already exists in this instantiation");
138  }
139  }
140 
141  // actually add the new dimension
142  __add(v);
143  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
void __add(const DiscreteVariable &v)
Adds a new var to the sequence of vars.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

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

Parameters
mThe master of this instantiation.
vThe varaible to add.
Exceptions
OperationNotAllowedRaised if m is not hte master of this instantiation.

Definition at line 772 of file instantiation_inl.h.

References __add(), __master, and GUM_ERROR.

773  {
774  if (m != __master) {
775  GUM_ERROR(OperationNotAllowed, "only master can do this");
776  }
777 
778  __add(v);
779  }
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
void __add(const DiscreteVariable &v)
Adds a new var to the sequence of vars.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

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
vThe variable whose value is assigned.
newvalThe index of the value assigned.
Returns
Returns a reference to *this in order to chain the chgVal.
Exceptions
NotFoundRaised if variable v does not belong to the instantiation.
OutOfBoundRaised if newval is not a possible value for v.

Definition at line 50 of file instantiation_inl.h.

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

Referenced by gum::BayesNetInference< GUM_SCALAR >::__createHardEvidence(), gum::GibbsOperator< GUM_SCALAR >::__drawVarMonteCarlo(), gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable(), gum::GibbsOperator< GUM_SCALAR >::__GibbsSample(), gum::TaxiSimulator::__performFillUp(), gum::TaxiSimulator::__performGoEast(), gum::TaxiSimulator::__performGoNorth(), gum::TaxiSimulator::__performGoSouth(), gum::TaxiSimulator::__performGoWest(), gum::TaxiSimulator::__performPickUp(), gum::TaxiSimulator::__performPutDown(), gum::SamplingInference< GUM_SCALAR >::_addVarSample(), gum::MultiDimWithOffset< GUM_SCALAR >::_computeInstantiationValue(), gum::InfluenceDiagram< GUM_SCALAR >::_copyTables(), gum::WeightedSampling< GUM_SCALAR >::_draw(), gum::ImportanceSampling< GUM_SCALAR >::_draw(), gum::AbstractSimulator::_randomState(), chgVal(), gum::SamplingInference< GUM_SCALAR >::contextualize(), gum::learning::BNDatabaseGenerator< GUM_SCALAR >::drawSamples(), gum::Potential< GUM_SCALAR >::fillWith(), gum::GibbsOperator< GUM_SCALAR >::monteCarloSample(), gum::FMDPSimulator::perform(), gum::TaxiSimulator::perform(), gum::prm::PRMFactory< GUM_SCALAR >::setCPFByRule(), gum::BayesNetFactory< GUM_SCALAR >::setParentModality(), and setValsFrom().

51  {
52  try {
53  // check that the variable does belong to the instantiation and that the
54  // new
55  // value is possible.
56  Idx varPos = __vars.pos(&v); // throws NotFound if v doesn't belong to this
57 
58  if (newVal >= v.domainSize()) { GUM_ERROR(OutOfBounds, ""); }
59 
60  // if we were in overflow, indicate that we are not anymore
61  __overflow = false;
62 
63  __chgVal(varPos, newVal);
64 
65  return *this;
66  } catch (NotFound&) {
67  std::string name = "instantiation does not contain this DiscreteVariable: ";
68  GUM_ERROR(NotFound, name + v.name());
69  }
70  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vThe variable whose value is assigned.
newvalThe index of the value assigned.
Returns
Returns a reference to *this in order to chain the chgVal.
Exceptions
NotFoundRaised if variable v does not belong to the instantiation.
OutOfBoundRaised if newval is not a possible value for v.

Definition at line 72 of file instantiation_inl.h.

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

73  {
74  try {
75  // check that the variable does belong to the instantiation and that the
76  // new
77  // value is possible.
78  Idx varPos = __vars.pos(v); // throws NotFound if v doesn't belong to this
79 
80  if (newVal >= v->domainSize()) { GUM_ERROR(OutOfBounds, ""); }
81 
82  // if we were in overflow, indicate that we are not anymore
83  __overflow = false;
84 
85  __chgVal(varPos, newVal);
86 
87  return *this;
88  } catch (NotFound&) {
89  std::string name = "instantiation does not contain this DiscreteVariable: ";
90  GUM_ERROR(NotFound, name + v->name());
91  }
92  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

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
varPosThe index of the variable whose value is assigned in the tuple of variables of the Instantiation.
newvalThe index of the value assigned.
Returns
A reference to *this in order to chain the chgVal.
Exceptions
NotFoundRaised if the variable does not belong to this
OutOfBoundRaised if newval is not a possible value for the variable

Definition at line 95 of file instantiation_inl.h.

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

95  {
96  // check that the variable does belong to the instantiation and that the new
97  // value is possible.
98  if (__vals.size() <= varPos) { GUM_ERROR(NotFound, ""); }
99 
100  if (newVal >= __vars[varPos]->domainSize()) { GUM_ERROR(OutOfBounds, ""); }
101 
102  // if we were in overflow, indicate that we are not anymore
103  __overflow = false;
104 
105  __chgVal(varPos, newVal);
106 
107  return *this;
108  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
varthe name of the variable whose value is assigned in the tuple of variables of the Instantiation.
newvalThe index of the value assigned.
Returns
A reference to *this in order to chain the chgVal.
Exceptions
NotFoundRaised if the variable does not belong to this
NotFoundRaised if newval is not a possible value for the variable

Definition at line 110 of file instantiation_inl.h.

References chgVal(), and variable().

110  {
111  return chgVal(variable(var), newVal);
112  }
Instantiation & chgVal(const DiscreteVariable &v, Idx newval)
Assign newval to variable v in the Instantiation.
const DiscreteVariable & variable(Idx i) const final
Returns the variable at position i in the tuple.

+ Here is the call graph for this function:

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
varthe name of the variable whose value is assigned in the tuple of variables of the Instantiation.
newvalThe label of the value assigned.
Returns
A reference to *this in order to chain the chgVal.
Exceptions
NotFoundRaised if the variable does not belong to this
OutOfBoundRaised if newval is not a possible value for the variable

Definition at line 114 of file instantiation_inl.h.

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

115  {
116  const auto& vv = variable(var);
117  Idx pos = vv.index(newVal);
118  return chgVal(vv, pos);
119  }
Idx pos(const DiscreteVariable &v) const final
Returns the position of the variable v.
Instantiation & chgVal(const DiscreteVariable &v, Idx newval)
Assign newval to variable v in the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43
const DiscreteVariable & variable(Idx i) const final
Returns the variable at position i in the tuple.

+ Here is the call graph for this function:

INLINE void gum::Instantiation::clear ( )

Erase all variables from an Instantiation.

Exceptions
OperationNotAllowedRaised if the instantiation is a slave.

Definition at line 160 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().

160  {
161  if (__master) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation"); }
162 
163  __vars.clear();
164  __vals.clear();
165  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the caller graph for this function:

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

Indicates whether a given variable belongs to the Instantiation.

Parameters
vThe variable for which the test is made.
Returns
Returns true if v is in the Instantiation.

Implements gum::MultiDimInterface.

Definition at line 32 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< GUM_SCALAR >::registerSlave(), setFirstIn(), setFirstOut(), setLastIn(), setLastOut(), setVals(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

32  {
33  return __vars.exists(&v);
34  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.

+ Here is the caller graph for this function:

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

Indicates whether a given variable belongs to the Instantiation.

Parameters
vA pointer on the variable for which the test is made.
Returns
Returns true if *v is in the Instantiation.

Definition at line 37 of file instantiation_inl.h.

References __vars.

37  {
38  return __vars.exists(v);
39  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
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 269 of file instantiation_inl.h.

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

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

269  {
270  Size p = nbrDim();
271  if (p == 0) { __overflow = true; }
272 
273  if (__overflow) return;
274  p -= 1;
275  Idx cpt = 0;
276  // if we are in overflow, do nothing
277 
278  // perform the increment
279  while (true) {
280  Idx v = __vals[cpt];
281 
282  if (v == 0) {
283  __vals[cpt] = __vars[cpt]->domainSize() - 1;
284 
285  if (cpt == p) {
286  __overflow = true;
287 
289 
290  return;
291  } else
292  ++cpt;
293  } else {
294  --__vals[cpt];
295  break;
296  }
297  }
298 
300  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __masterDecNotification() const
void __masterLastNotification() const
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
iThe set of variables to decrement in this Instantiation.

Definition at line 400 of file instantiation_inl.h.

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

400  {
401  Size p = i.nbrDim() - 1;
402  Idx i_cpt = 0;
403  // if we are in overflow, do nothing
404 
405  if (__overflow) return;
406 
407  while (true) {
408  // verify that __vars[cpt] belongs to i before incrementing its value
409  const DiscreteVariable& v = i.variable(i_cpt);
410 
411  if (!contains(v)) {
412  if (i_cpt == p) {
413  __overflow = true;
414  return;
415  } else
416  ++i_cpt;
417  } else {
418  int cpt = pos(v);
419  Idx iv = __vals[cpt];
420 
421  if (iv == 0) {
422  __chgVal(cpt, __vars[cpt]->domainSize() - 1);
423 
424  if (i_cpt == p) {
425  __overflow = true;
426  return;
427  } else
428  ++i_cpt;
429  } else {
430  __chgVal(cpt, iv - 1);
431  return;
432  }
433  }
434  }
435  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx pos(const DiscreteVariable &v) const final
Returns the position of the variable v.
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
bool contains(const DiscreteVariable &v) const final
Indicates whether a given variable belongs to the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
vThe varaible not to decrement in this Instantiation.

Definition at line 593 of file instantiation_inl.h.

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

593  {
594  Size p = nbrDim() - 1;
595  Idx cpt = 0;
596  // if we are in overflow, do nothing
597 
598  if (__overflow) return;
599 
600  while (true) {
601  if (__vars[cpt] == &v) {
602  if (cpt == p) {
603  __overflow = true;
604  return;
605  } else
606  ++cpt;
607  } else {
608  Idx iv = __vals[cpt];
609 
610  if (iv == 0) {
611  __chgVal(cpt, __vars[cpt]->domainSize() - 1);
612 
613  if (cpt == p) {
614  __overflow = true;
615  return;
616  } else
617  ++cpt;
618  } else {
619  __chgVal(cpt, iv - 1);
620  return;
621  }
622  }
623  }
624  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
iThe set of variables to not decrement in this Instantiation.

Definition at line 506 of file instantiation_inl.h.

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

506  {
507  Size p = nbrDim() - 1;
508  Idx cpt = 0;
509  // if we are in overflow, do nothing
510 
511  if (__overflow) return;
512 
513  while (true) {
514  if (i.contains(__vars[cpt])) {
515  if (cpt == p) {
516  __overflow = true;
517  return;
518  } else
519  ++cpt;
520  } else {
521  Idx v = __vals[cpt];
522 
523  if (v == 0) {
524  __chgVal(cpt, __vars[cpt]->domainSize() - 1);
525 
526  if (cpt == p) {
527  __overflow = true;
528  return;
529  } else
530  ++cpt;
531  } else {
532  __chgVal(cpt, v - 1);
533  return;
534  }
535  }
536  }
537  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
vThe variable to decrement in this Instantiation.
Exceptions
NotFoundRaised if variable v does not belong to the Instantiation.

Definition at line 679 of file instantiation_inl.h.

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

679  {
680  // get the position of the variable
681  Idx cpt = __vars.pos(&v);
682  // if we are in overflow, do nothing
683 
684  if (__overflow) return;
685 
686  Idx p = __vals[cpt];
687 
688  if (p == 0) {
689  __chgVal(cpt, v.domainSize() - 1);
690  __overflow = true;
691  } else {
692  __chgVal(cpt, p - 1);
693  }
694  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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 169 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().

169  {
170  // @todo enhance the cplxity with a member domainSize ?
171  Size s = 1;
172 
173  for (const auto var : __vars)
174  s *= var->domainSize();
175 
176  return s;
177  }
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.

+ Here is the caller graph for this function:

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

References __vals.

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

798 { return __vals.empty(); }
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the caller graph for this function:

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 224 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< GUM_SCALAR >::__groundPotential(), gum::prm::StructuredBayesBall< GUM_SCALAR >::__isHardEvidence(), gum::BayesNetInference< GUM_SCALAR >::__isHardEvidence(), gum::learning::DAG2BNLearner::__probaVarReordering(), 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< GUM_SCALAR >::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::prm::PRMFormAttribute< GUM_SCALAR >::copyCpf(), gum::MultiDimContainer< GUM_SCALAR >::copyFrom(), 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::Potential< GUM_SCALAR >::KL(), gum::Potential< GUM_SCALAR >::normalizeAsCPT(), gum::prm::PRMInference< GUM_SCALAR >::operator=(), gum::IBayesNet< GUM_SCALAR >::operator==(), gum::MultiDimContainer< GUM_SCALAR >::operator==(), gum::FMDPSimulator::perform(), gum::MultiDimContainer< GUM_SCALAR >::populate(), gum::prm::PRMInference< GUM_SCALAR >::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().

224 { return inOverflow(); }
bool inOverflow() const
Indicates whether the current value of the tuple is correct or not.

+ Here is the call graph for this function:

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
vThe variable to remove from this Instantiation.
Exceptions
NotFoundRaised if v does not belong to this Instantiation.
OperationNotAllowedRaised if the instantiation is a slave.

Implements gum::MultiDimInterface.

Definition at line 146 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().

146  {
147  // if __master : not allowed
148  if (__master) { GUM_ERROR(OperationNotAllowed, "in slave Instantiation"); }
149 
150  // check that the variable does actually belong to the Instantiation
151  if (!__vars.exists(&v)) {
152  GUM_ERROR(NotFound, "Var does not exist in this instantiation");
153  }
154 
155  // actually delete the dimension
156  __erase(v);
157  }
void __erase(const DiscreteVariable &v)
Removes a variable from the sequence of vars.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

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

Parameters
mThe master of this instantiation.
vThe variable to remove.
Exceptions
OperationNotAllowedRaised if m is not the master of this instantiation.

Definition at line 238 of file instantiation.cpp.

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

239  {
240  if (m != __master) {
241  GUM_ERROR(OperationNotAllowed, "only master can do this");
242  }
243 
244  __erase(v);
245 
247  }
void __erase(const DiscreteVariable &v)
Removes a variable from the sequence of vars.
virtual void setChangeNotification(const Instantiation &i)=0
Listen to an assignment of a value in a Instantiation.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

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 222 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().

222  {
223  if (__master) {
224  __master->unregisterSlave(*this);
225  __master = nullptr;
226  }
227  return true;
228  }
virtual bool unregisterSlave(Instantiation &i)=0
Unregister i as a slave of this MultiDimAdressable.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Idx gum::Instantiation::hamming ( ) const

Returns the hamming distance of this instantiation.

Returns
Returns the hamming distance of this instantiation.

Definition at line 169 of file instantiation.cpp.

References __vars, and val().

169  {
170  Idx res = 0;
171 
172  for (const auto var : __vars)
173  res += val(*var);
174 
175  return res;
176  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
unsigned long Idx
Type for indexes.
Definition: types.h:43
Idx val(Idx i) const
Returns the current value of the variable at position i.

+ Here is the call graph for this function:

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 237 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< GUM_SCALAR >::__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< GUM_SCALAR >::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::prm::PRMFormAttribute< GUM_SCALAR >::copyCpf(), gum::Potential< GUM_SCALAR >::draw(), gum::Potential< GUM_SCALAR >::KL(), gum::prm::PRMInference< GUM_SCALAR >::marginal(), operator++(), operator+=(), gum::prm::PRMInference< GUM_SCALAR >::operator=(), gum::IBayesNet< GUM_SCALAR >::operator==(), gum::prm::PRMInference< GUM_SCALAR >::PRMInference(), gum::prm::o3prmr::O3prmrInterpreter::query(), gum::prm::PRMFormAttribute< GUM_SCALAR >::swap(), and gum::prm::PRMScalarAttribute< GUM_SCALAR >::swap().

237  {
238  Size p = nbrDim();
239  if (p == 0) { __overflow = true; }
240 
241  if (__overflow) return;
242  p -= 1;
243  Idx cpt = 0;
244  // if we are in overflow, do nothing
245 
246  // perform the increment
247  while (true) {
248  Idx v = __vals[cpt];
249 
250  if (v + 1 == __vars[cpt]->domainSize()) {
251  __vals[cpt] = 0;
252 
253  if (cpt == p) {
254  __overflow = true;
256  return;
257  } else
258  ++cpt;
259  } else {
260  ++__vals[cpt];
261  break;
262  }
263  }
264 
266  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __masterFirstNotification() const
void __masterIncNotification() const
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
iThe set of variables to increment in this Instantiation.

Definition at line 355 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(), gum::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

355  {
356  // if i is empty, overflow and do nothing
357  if (i.nbrDim() == 0) {
358  __overflow = true;
359  return;
360  }
361 
362  // if we are in overflow, do nothing
363  if (__overflow) return;
364 
365  Size p = i.nbrDim() - 1;
366 
367  Idx i_cpt = 0;
368 
369  while (true) {
370  // verify that __vars[cpt] belongs to i before incrementing its value
371  const DiscreteVariable& v = i.variable(i_cpt);
372 
373  if (!contains(v)) {
374  if (i_cpt == p) {
375  __overflow = true;
376  return;
377  } else
378  ++i_cpt;
379  } else {
380  int cpt = pos(v);
381  Idx iv = __vals[cpt];
382 
383  if (iv + 1 == __vars[cpt]->domainSize()) {
384  __chgVal(cpt, 0);
385 
386  if (i_cpt == p) {
387  __overflow = true;
388  return;
389  } else
390  ++i_cpt;
391  } else {
392  __chgVal(cpt, iv + 1);
393  return;
394  }
395  }
396  }
397  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx pos(const DiscreteVariable &v) const final
Returns the position of the variable v.
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
bool contains(const DiscreteVariable &v) const final
Indicates whether a given variable belongs to the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vThe variable not to increment in this Instantiation.

Definition at line 559 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(), and gum::Potential< GUM_SCALAR >::normalizeAsCPT().

559  {
560  Size p = nbrDim() - 1;
561  Idx cpt = 0;
562  // if we are in overflow, do nothing
563 
564  if (__overflow) return;
565 
566  while (true) {
567  if (__vars[cpt] == &v) {
568  if (cpt == p) {
569  __overflow = true;
570  return;
571  } else
572  ++cpt;
573  } else {
574  Idx iv = __vals[cpt];
575 
576  if (iv + 1 == __vars[cpt]->domainSize()) {
577  __chgVal(cpt, 0);
578 
579  if (cpt == p) {
580  __overflow = true;
581  return;
582  } else
583  ++cpt;
584  } else {
585  __chgVal(cpt, iv + 1);
586  return;
587  }
588  }
589  }
590  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
iThe set of variable to not increment in this Instantiation.

Definition at line 472 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::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), gum::FMDPSimulator::perform(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

472  {
473  Size p = nbrDim() - 1;
474  Idx cpt = 0;
475  // if we are in overflow, do nothing
476 
477  if (__overflow) return;
478 
479  while (true) {
480  if (i.contains(__vars[cpt])) {
481  if (cpt == p) {
482  __overflow = true;
483  return;
484  } else
485  ++cpt;
486  } else {
487  Idx v = __vals[cpt];
488 
489  if (v + 1 == __vars[cpt]->domainSize()) {
490  __chgVal(cpt, 0);
491 
492  if (cpt == p) {
493  __overflow = true;
494  return;
495  } else
496  ++cpt;
497  } else {
498  __chgVal(cpt, v + 1);
499  return;
500  }
501  }
502  }
503  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vThe variable to increment in this Instantiation.
Exceptions
NotFoundRaised if variable v does not belong to the Instantiation.

Definition at line 661 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(), and gum::Potential< GUM_SCALAR >::normalizeAsCPT().

661  {
662  // get the position of the variable
663  Idx cpt = __vars.pos(&v);
664  // if we are in overflow, do nothing
665 
666  if (__overflow) return;
667 
668  Idx p = __vals[cpt];
669 
670  if (p + 1 == v.domainSize()) {
671  __chgVal(cpt, 0);
672  __overflow = true;
673  } else {
674  __chgVal(cpt, p + 1);
675  }
676  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

References __overflow.

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

221 { return __overflow; }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...

+ Here is the caller graph for this function:

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 712 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().

712  {
713  return (__master == m);
714  }
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.

+ Here is the caller graph for this function:

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

References isMaster().

717  {
718  return isMaster(&m);
719  }
bool isMaster(const MultiDimAdressable *m) const
Indicates whether m is the master of this instantiation.

+ Here is the call graph for this function:

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

References __master.

709 { return (__master != 0); }
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
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 185 of file instantiation_inl.h.

References __vars.

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

185 { return __vars.size(); }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.

+ Here is the caller graph for this function:

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

Alias of Instantiation::inc().

Returns
Returns this Instantiation.

Definition at line 303 of file instantiation_inl.h.

References inc().

303  {
304  inc();
305  return *this;
306  }
void inc()
Operator increment.

+ Here is the call graph for this function:

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

Calls depl times Instantiation::inc().

Returns
Returns this Instantiation.

Definition at line 315 of file instantiation_inl.h.

References inc().

315  {
316  //@todo : this code should be improved !!!
317  for (Idx i = 0; i < depl; i++)
318  inc();
319 
320  return *this;
321  }
void inc()
Operator increment.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

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

Alias of Instantiation::dec().

Returns
Returns this Instantiation.

Definition at line 309 of file instantiation_inl.h.

References dec().

309  {
310  dec();
311  return *this;
312  }
void dec()
Operator decrement.

+ Here is the call graph for this function:

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

Calls depl times Instantiation::dec().

Returns
Returns this Instantiation.

Definition at line 324 of file instantiation_inl.h.

References dec().

324  {
325  //@todo : this code should be improved !!!
326  for (Idx i = 0; i < depl; i++)
327  dec();
328 
329  return *this;
330  }
void dec()
Operator decrement.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

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
aIThe Instantiation to copy.
Exceptions
OperationNotAllowedRaised if copy is not allowed.

Definition at line 118 of file instantiation.cpp.

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

118  {
119  if (__master) {
120  if (!aI.isMaster(__master)) { // aI as the same master.
121  if (nbrDim() != aI.nbrDim()) {
122  GUM_ERROR(OperationNotAllowed, "in slave Instantiation");
123  }
124 
125  for (Idx i = 0; i < nbrDim(); i++) {
126  if ((!contains(aI.variable(i))) || (!aI.contains(variable(i)))) {
127  GUM_ERROR(OperationNotAllowed, "in slave Instantiation");
128  }
129  }
130  }
131 
132  setVals(aI);
133  } else {
134  // copy the content of aI
135  __vars = aI.__vars;
136  __vals = aI.__vals;
137  __overflow = aI.__overflow;
138 
139  if (aI.__master) actAsSlave(*aI.__master);
140  }
141 
142  return *this;
143  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
Instantiation & setVals(const Instantiation &i)
Assign the values from i in the Instantiation.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
bool contains(const DiscreteVariable &v) const final
Indicates whether a given variable belongs to the Instantiation.
bool actAsSlave(MultiDimAdressable &aMD)
Tries to register the Instantiation to a MultiDimAdressable.
unsigned long Idx
Type for indexes.
Definition: types.h:43
const DiscreteVariable & variable(Idx i) const final
Returns the variable at position i in the tuple.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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

operator==

Definition at line 818 of file instantiation_inl.h.

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

818  {
819  if (inOverflow() && other.inOverflow()) return true;
820  if (other.nbrDim() != nbrDim()) return false;
821  for (const auto& k : variablesSequence()) {
822  if (!other.contains(k)) return false;
823  if (val(*k) != other.val(*k)) return false;
824  }
825  return true;
826  }
bool inOverflow() const
Indicates whether the current value of the tuple is correct or not.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
const Sequence< const DiscreteVariable * > & variablesSequence() const final
Returns the sequence of DiscreteVariable of this instantiation.
Idx val(Idx i) const
Returns the current value of the variable at position i.

+ Here is the call graph for this function:

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
vThe variable for which its position is return.
Exceptions
NotFoundRaised if v does not belong to the instantiation.

Implements gum::MultiDimInterface.

Definition at line 180 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().

180  {
181  return __vars.pos(&k);
182  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.

+ Here is the caller graph for this function:

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

References inOverflow().

227 { return inOverflow(); }
bool inOverflow() const
Indicates whether the current value of the tuple is correct or not.

+ Here is the call graph for this function:

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
vThe new order of variables for this Instantiation.
Exceptions
OperationNotAllowedif slave instantiation

Definition at line 743 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().

743  {
744  if (__master != nullptr) {
745  GUM_ERROR(OperationNotAllowed,
746  "Reordering impossible in slave instantiation");
747  }
748 
749  __reorder(original);
750  }
void __reorder(const Sequence< const DiscreteVariable * > &v)
Reorder vars of this instantiation giving the order in v.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

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

Parameters
iThe sequence of variables with which to reorder this Instantiation.

Definition at line 438 of file instantiation_inl.h.

References reorder(), and variablesSequence().

438  {
439  reorder(i.variablesSequence());
440  }
void reorder(const Sequence< const DiscreteVariable * > &v)
Reorder vars of this instantiation giving the order in v.

+ Here is the call graph for this function:

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
xThe variable in this which will be replaced.
yThe variable replacing y.
Exceptions
NotFoundRaised if x does not belong to this MultiDim.
OperationNotAllowedIf y and x are not interchangeable.
DuplicateElementIf y is already in this MultiDim.

Definition at line 33 of file multiDimInterface_inl.h.

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

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

34  {
35  if (!contains(x)) { GUM_ERROR(NotFound, "could not find the variable"); }
36 
37  if (contains(y)) {
38  GUM_ERROR(DuplicateElement, "variable already in MultiDim");
39  }
40 
41  if (x.domainSize() != y.domainSize()) {
42  GUM_ERROR(OperationNotAllowed, "incompatible variables");
43  }
44 
45  _replace(&x, &y);
46  }
virtual bool contains(const DiscreteVariable &v) const =0
Returns true if var is in *this.
virtual void _replace(const DiscreteVariable *x, const DiscreteVariable *y)=0
This is called by MultiDimContainer::replace() to proceed with the replacing between x and y...
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

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

Referenced by gum::prm::PRMFormAttribute< GUM_SCALAR >::__fillCpf(), gum::prm::PRMSystem< GUM_SCALAR >::__groundPotential(), gum::credal::CredalNet< GUM_SCALAR >::__intervalToCredal(), gum::prm::StructuredBayesBall< GUM_SCALAR >::__isHardEvidence(), gum::BayesNetInference< GUM_SCALAR >::__isHardEvidence(), gum::learning::DAG2BNLearner::__probaVarReordering(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__threadUpdate(), 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< GUM_SCALAR >::addEvidence(), gum::MultiDimContainer< GUM_SCALAR >::apply(), gum::prm::PRMFormAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::becomeCastDescendant(), gum::credal::CredalNet< GUM_SCALAR >::bnToCredal(), gum::prm::o3prmr::O3prmrInterpreter::checkObserve(), gum::BayesNetInference< GUM_SCALAR >::chgEvidence(), gum::MultiDimBucket< GUM_SCALAR >::compute(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copy(), gum::prm::PRMFormAttribute< GUM_SCALAR >::copyCpf(), gum::MultiDimContainer< GUM_SCALAR >::copyFrom(), gum::Potential< GUM_SCALAR >::draw(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::credal::CredalNet< GUM_SCALAR >::fillConstraint(), gum::Potential< GUM_SCALAR >::fillWith(), gum::Potential< GUM_SCALAR >::findAll(), gum::JointTargetedInference< GUM_SCALAR >::I(), gum::credal::CredalNet< GUM_SCALAR >::idmLearning(), gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal(), gum::credal::CredalNet< GUM_SCALAR >::intervalToCredalWithFiles(), gum::Potential< GUM_SCALAR >::KL(), gum::credal::CredalNet< GUM_SCALAR >::lagrangeNormalization(), gum::prm::PRMInference< GUM_SCALAR >::marginal(), gum::Potential< GUM_SCALAR >::normalizeAsCPT(), gum::prm::PRMInference< GUM_SCALAR >::operator=(), gum::IBayesNet< GUM_SCALAR >::operator==(), gum::MultiDimContainer< GUM_SCALAR >::operator==(), gum::MultiDimContainer< GUM_SCALAR >::populate(), gum::prm::PRMInference< GUM_SCALAR >::PRMInference(), gum::prm::o3prmr::O3prmrInterpreter::query(), gum::MultiDimContainer< GUM_SCALAR >::reduce(), setFirstNotVar(), gum::Estimator< GUM_SCALAR >::setFromLBP(), gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked(), gum::prm::PRMFormAttribute< GUM_SCALAR >::swap(), gum::prm::PRMScalarAttribute< GUM_SCALAR >::swap(), gum::MultiDimContainer< GUM_SCALAR >::toString(), and gum::credal::CredalNet< GUM_SCALAR >::toString().

333  {
334  __overflow = false;
335  Size s = nbrDim();
336 
337  for (Idx p = 0; p < s; ++p)
338  __vals[p] = 0;
339 
341  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
void __masterFirstNotification() const
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
iThe variables to which their first value is assigned in this Instantiation.

Definition at line 443 of file instantiation_inl.h.

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

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

443  {
444  __overflow = false;
445  Idx s = nbrDim();
446 
447  for (Size p = 0; p < s; ++p)
448  if (i.contains(__vars[p])) __chgVal(p, 0);
449  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vTha variable that will not be set to its first value in this Instantiation.

Definition at line 627 of file instantiation_inl.h.

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

Referenced by gum::BayesNetFactory< GUM_SCALAR >::__fillProbaWithValuesTable().

627  {
628  __overflow = false;
629  Idx s = nbrDim();
630 
631  for (Size p = 0; p < s; ++p) {
632  if (__vars[p] == &v) {
633  Idx oldval = __vals[p];
634  setFirst();
635  __chgVal(p, oldval);
636  return;
637  }
638  }
639 
640  setFirst();
641  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
void setFirst()
Assign the first values to the tuple of the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
iThe variable that will not be set to their first value in this Instantiation.

Definition at line 541 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::SimpleCPTGenerator< GUM_SCALAR >::generateCPT(), gum::FMDPSimulator::perform(), and gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked().

541  {
542  __overflow = false;
543  Idx s = nbrDim();
544 
545  for (Size p = 0; p < s; ++p)
546  if (!i.contains(__vars[p])) __chgVal(p, 0);
547  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
vThe variable that will be set to its first value in this Instantiation.

Definition at line 697 of file instantiation_inl.h.

References __chgVal(), __overflow, and __vars.

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

697  {
698  __overflow = false;
699  __chgVal(__vars.pos(&v), 0);
700  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

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

Referenced by setLastNotVar().

344  {
345  __overflow = false;
346  Size s = nbrDim();
347 
348  for (Idx p = 0; p < s; ++p)
349  __vals[p] = __vars[p]->domainSize() - 1;
350 
352  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __masterLastNotification() const
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
iThe variables to which their last value is assigned in this Instantiation.

Definition at line 463 of file instantiation_inl.h.

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

463  {
464  __overflow = false;
465  Idx s = nbrDim();
466 
467  for (Size p = 0; p < s; ++p)
468  if (i.contains(__vars[p])) __chgVal(p, __vars[p]->domainSize() - 1);
469  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

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
vThe variable that will not be set to its last value in this Instantiation.

Definition at line 644 of file instantiation_inl.h.

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

644  {
645  __overflow = false;
646  Idx s = nbrDim();
647 
648  for (Size p = 0; p < s; ++p) {
649  if (__vars[p] == &v) {
650  Idx oldval = __vals[p];
651  setLast();
652  __chgVal(p, oldval);
653  return;
654  }
655  }
656 
657  setLast();
658  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
void setLast()
Assign the last values in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the call graph for this function:

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
iThe variables that will not be set to their last value in this Instantiation.

Definition at line 550 of file instantiation_inl.h.

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

550  {
551  __overflow = false;
552  Idx s = nbrDim();
553 
554  for (Size p = 0; p < s; ++p)
555  if (!i.contains(__vars[p])) __chgVal(p, __vars[p]->domainSize() - 1);
556  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Size domainSize() const final
Returns the product of the variable&#39;s domain size in the Instantiation.
Idx nbrDim() const final
Returns the number of variables in the Instantiation.
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

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
vThe variable that will be set to its last value in this Instantiation.

Definition at line 703 of file instantiation_inl.h.

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

703  {
704  __overflow = false;
705  __chgVal(__vars.pos(&v), v.domainSize() - 1);
706  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.

+ Here is the call graph for this function:

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
iA Instantiation in which the new values are searched.
Returns
Returns a reference to *this in order to chain the chgVal.

Definition at line 452 of file instantiation_inl.h.

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

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

452  {
453  __overflow = false;
454  Idx s = i.nbrDim();
455 
456  for (Size p = 0; p < s; ++p)
457  if (contains(i.variable(p))) __chgVal(pos(i.variable(p)), i.val(p));
458 
459  return *this;
460  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
unsigned long Size
In aGrUM, hashed values are unsigned long int.
Definition: types.h:50
Idx pos(const DiscreteVariable &v) const final
Returns the position of the variable v.
void __chgVal(Idx varPos, Idx newVal)
Modifies internally the value of a given variable of the sequence.
bool contains(const DiscreteVariable &v) const final
Indicates whether a given variable belongs to the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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
mapKeys are variables in external.
externalAn instantiation used to change the values in j.
Exceptions
NotFoundRaised if a variable in external does not point to a variable in *this or in external.

Definition at line 178 of file instantiation.cpp.

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

180  {
181  for (const auto& elt : map) {
182  const DiscreteVariable& var = *elt.second;
183 
184  try {
185  Idx val = external.val(*elt.first);
186 
187  try {
188  chgVal(var, val);
189  } catch (NotFound&) {
190  GUM_ERROR(NotFound,
191  var.name() << " : missing variable in instantiation");
192  }
193  } catch (NotFound&) {
194  GUM_ERROR(NotFound,
195  var.name() << " : missing variable in external instantiation");
196  }
197  }
198  }
Instantiation & chgVal(const DiscreteVariable &v, Idx newval)
Assign newval to variable v in the Instantiation.
unsigned long Idx
Type for indexes.
Definition: types.h:43
Idx val(Idx i) const
Returns the current value of the variable at position i.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

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
mThe master of this instantiation.
Exceptions
OperationNotAllowedRaised if m is not the master of instantiation.

Definition at line 230 of file instantiation.cpp.

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

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

230  {
231  if (m != __master) {
232  GUM_ERROR(OperationNotAllowed, "only master can do this");
233  }
234 
236  }
void __reorder(const Sequence< const DiscreteVariable * > &v)
Reorder vars of this instantiation giving the order in v.
MultiDimAdressable * __master
The master, if any, contains precisely the set of variables to be instantiated.
virtual const Sequence< const DiscreteVariable * > & variablesSequence() const =0
Returns a const ref to the sequence of DiscreteVariable*.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Give a string version of instantiation.

Returns
Returns a string version of instantiation.

Definition at line 146 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().

146  {
147  std::stringstream sstr;
148  // check if the value of the instantiation is correct
149 
150  if (__overflow) { sstr << "<invalid>"; }
151 
152  sstr << "<";
153 
154  bool first = true;
155 
156  for (const auto var : __vars) {
157  if (!first) sstr << "|";
158 
159  first = false;
160  sstr << var->name() << ":" << var->label(val(*var));
161  }
162 
163  sstr << ">";
164 
165  return sstr.str();
166  }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
Idx val(Idx i) const
Returns the current value of the variable at position i.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

INLINE void gum::Instantiation::unsetEnd ( )

Alias for unsetOverflow().

See also
unsetOverflow().

Definition at line 234 of file instantiation_inl.h.

References __overflow.

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

234 { __overflow = false; }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...

+ Here is the caller graph for this function:

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

References __overflow.

231 { __overflow = false; }
bool __overflow
Indicates whether the current value of the tuple is valid when we loop sufficiently over values of th...
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
iThe index of the variable.
Returns
Returns the current value of the variable at position i.
Exceptions
NotFoundRaised if the element cannot be found.

Definition at line 188 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::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::MultiDimNoisyAND< GUM_SCALAR >::get(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::get(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::get(), hamming(), gum::AbstractSimulator::hasReachEnd(), gum::HashFunc< Instantiation >::operator()(), gum::IBayesNet< GUM_SCALAR >::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().

188  {
189  if (i >= __vals.size()) {
190  GUM_ERROR(NotFound, i << " is out of bound index for the instantiation.");
191  }
192 
193  return __vals[i];
194  }
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66
std::vector< Idx > __vals
The current instantiation: the value of the tuple.
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
varThe variable the value of which we wish to know.
Returns
Returns the current value of a given variable.
Exceptions
NotFoundRaised it var does not belong to the instantiation.

Definition at line 197 of file instantiation_inl.h.

References __vals, and __vars.

197  {
198  return __vals[__vars.pos(&var)];
199  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
std::vector< Idx > __vals
The current instantiation: the value of the tuple.
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
pvarThe variable for which the value is returned.
Returns
Returns the current value of a given variable.
Exceptions
NotFoundRaised if var does not belong to the instantiation.

Definition at line 202 of file instantiation_inl.h.

References __vals, and __vars.

Referenced by gum::TaxiSimulator::__evalReward(), gum::StatesCounter::__incState(), gum::StatesChecker::__insertState(), gum::TaxiSimulator::__performFillUp(), gum::TaxiSimulator::__performGoEast(), gum::TaxiSimulator::__performGoNorth(), gum::TaxiSimulator::__performGoSouth(), gum::TaxiSimulator::__performGoWest(), gum::TaxiSimulator::__performPickUp(), gum::TaxiSimulator::__performPutDown(), gum::MultiDimWithOffset< GUM_SCALAR >::_getOffs(), gum::StatesChecker::addState(), gum::StatesCounter::incState(), and gum::TaxiSimulator::perform().

202  {
203  return __vals[__vars.pos(pvar)];
204  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
std::vector< Idx > __vals
The current instantiation: the value of the tuple.

+ Here is the caller graph for this function:

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

Returns the variable at position i in the tuple.

Parameters
iThe index of the variable
Returns
Returns the variable at position i in the tuple.
Exceptions
NotFoundRaised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 207 of file instantiation_inl.h.

References __vars.

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

207  {
208  return *(__vars.atPos(i));
209  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.

+ Here is the caller graph for this function:

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

Returns the variable with the name.

Parameters
nameThe index of the variable
Returns
Returns the variable qith the name in the tuple. This function is not O(1)
Exceptions
NotFoundRaised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 212 of file instantiation_inl.h.

References __vars, and GUM_ERROR.

212  {
213  for (const auto& v : __vars) {
214  if (v->name() == name) return *v;
215  }
216 
217  GUM_ERROR(NotFound, "'" << name << "' can not be found in the instantiation.")
218  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.
#define GUM_ERROR(type, msg)
Definition: exceptions.h:66
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 723 of file instantiation_inl.h.

References __vars.

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

723  {
724  return __vars;
725  }
Sequence< const DiscreteVariable * > __vars
The tuple of variables to be instantiated.

+ Here is the caller graph for this function:

Member Data Documentation

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 1137 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().

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

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