gum::MultiDimBucket< GUM_SCALAR > Class Template Reference

A multidim implementation for buckets. More...

#include <agrum/multidim/multiDimBucket.h>

Inheritance diagram for gum::MultiDimBucket< GUM_SCALAR >:

Collaboration diagram for gum::MultiDimBucket< GUM_SCALAR >:

Public Member Functions
const HashTable< const MultiDimContainer< GUM_SCALAR > *, Instantiation *> &	multidims () const
	Returns the MultiDimContainer and their respective Instantiation. More...
Constructor & destructor.
	MultiDimBucket (Size bufferSize=INT_MAX)
	Default constructor. More...
	MultiDimBucket (const MultiDimBucket< GUM_SCALAR > &source)
	Copy constructor. More...
virtual	~MultiDimBucket ()
	Destructor. More...
Bucket methods
void	add (const MultiDimContainer< GUM_SCALAR > &impl)
	Add a MultiDimContainer in the bucket. More...
void	add (const MultiDimContainer< GUM_SCALAR > *impl)
	Add a MultiDimContainer in the bucket. More...
void	erase (const MultiDimContainer< GUM_SCALAR > &impl)
	Remove a MultiDimContainer from this bucket. More...
void	erase (const MultiDimContainer< GUM_SCALAR > *impl)
	Remove a MultiDimContainer from this bucket. More...
bool	contains (const MultiDimContainer< GUM_SCALAR > &impl) const
	Returns true if the MultiDimContainer is in this bucket. More...
const Set< const DiscreteVariable *> &	allVariables () const
	Returns the sequence of all the variables contained in the bucket. More...
Size	bucketSize () const
	Returns the number of MultiDimContainer in in this bukcet. More...
bool	isBucketEmpty () const
	Returns true if this bucket is empty. More...
bool	bucketChanged () const
	Returns true if the bucket need re-computation since the last computation. More...
const MultiDimArray< GUM_SCALAR > &	bucket () const
	Returns the MultiDimArray used by this MultiDimBucket. More...
Size	bufferSize () const
	Returns the amount of memory allowed for this bucket. More...
void	setBufferSize (Size amount)
	Changes the amount of memory allowed for this bucket. More...
void	compute (bool force=false) const
	This method computes the final table of this bucket. More...
Inherited methods
virtual MultiDimContainer< GUM_SCALAR > *	newFactory () const override
	Default constructor. More...
const std::string &	name () const override
	Returns the real name of the multiDim implementation. More...
virtual void	add (const DiscreteVariable &v) override
	Adds a new var to the variables of the multidimensional matrix. More...
virtual void	erase (const DiscreteVariable &v) override
	Removes a var from the variables of the multidimensional matrix. More...
virtual Size	realSize () const override
	Returns the real number of parameters used for this table. More...
bool	contains (const DiscreteVariable &v) const override
	Returns true if var is in *this. More...
virtual GUM_SCALAR	get (const Instantiation &i) const override
	Returns the value pointed by i. More...
virtual void	changeNotification (const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval) override
	Listen to changes in a given Instantiation. More...
virtual void	setFirstNotification (const Instantiation &i) override
	Listen to setFirst in a given Instantiation. More...
virtual void	setLastNotification (const Instantiation &i) override
	Listen to setLast in a given Instantiation. More...
virtual void	setIncNotification (const Instantiation &i) override
	Listen to increment in a given Instantiation. More...
virtual void	setDecNotification (const Instantiation &i) override
	Listen to increment in each recorded Instantiation. More...
virtual void	setChangeNotification (const Instantiation &i) override
	Listen to an assignment of a value in a Instantiation. More...
virtual bool	registerSlave (Instantiation &i) override
	Register i as a slave of this MultiDimAdressable. More...
virtual bool	unregisterSlave (Instantiation &i) override
	Unregister i as a slave of this MultiDimAdressable. More...
virtual MultiDimAdressable &	getMasterRef () override
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer. More...
virtual const MultiDimAdressable &	getMasterRef () const override
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer. More...
virtual const std::string	toString (const Instantiation *i) const override
	Display the internal representation of i. More...
Accessors / Modifiers
virtual void	set (const Instantiation &i, const GUM_SCALAR &value) const
virtual void	fill (const GUM_SCALAR &) const
Accessors / Modifiers
const std::string &	basename () const
	Returns the base class name of this MultiDimImplementation. More...
float	compressionRate () const
	The compression ratio of the table (depending on the type of implementation). More...
MultiDimInterface implementation
virtual Idx	nbrDim () const override
	Returns the number of vars in the multidimensional container. More...
virtual Size	domainSize () const override
	Returns the product of the variables domain size. More...
virtual const Sequence< const DiscreteVariable *> &	variablesSequence () const override
	Returns a const ref to the sequence of DiscreteVariable*. More...
virtual const DiscreteVariable &	variable (Idx i) const override
	Returns a const ref to the ith var. More...
virtual const DiscreteVariable &	variable (const std::string &name) const override
	Returns the variable with the name. More...
virtual Idx	pos (const DiscreteVariable &v) const override
	Returns the index of a variable. More...
virtual bool	empty () const override
	Returns true if no var is in *this. More...
MultiDimContainer implementation
virtual void	beginMultipleChanges () override
	Call this method before doing important changes in this MultiDimContainer. More...
virtual void	endMultipleChanges () override
	Call this method after doing important changes in this MultiDimContainer. More...
virtual void	endMultipleChanges (const GUM_SCALAR &) override
	Call this method after doing important changes in this MultiDimContainer. More...
Accessors / Modifiers
GUM_SCALAR	operator[] (const Instantiation &i) const
	An [] operator using a Instantiation as argument. More...
virtual void	populate (const std::vector< GUM_SCALAR > &v) const
	Automatically fills this MultiDimContainer with the values in v. More...
virtual void	populate (std::initializer_list< GUM_SCALAR > l) const
	Automatically fills this MultiDimContainer with the values in l. More...
Copy methods.
virtual void	copyFrom (const MultiDimContainer< GUM_SCALAR > &src) const
	Basic copy of a MultiDimContainer. More...
virtual void	copyFrom (const MultiDimContainer< GUM_SCALAR > &src, Instantiation *p_i) const
	Basic copy of a MultiDimContainer. More...
virtual void	extractFrom (const MultiDimContainer< GUM_SCALAR > &src, const Instantiation &mask)
	Basic extraction of a MultiDimContainer. More...
virtual void	copy (const MultiDimContainer< GUM_SCALAR > &src)
	Removes all variables in this MultiDimContainer and copy the content of src, variables included. More...
Various methods.
virtual const std::string	toString () const
	Returns a representation of this MultiDimContainer. More...
bool	operator== (const MultiDimContainer< GUM_SCALAR > &p) const
	Test if this MultiDimContainer is equal to p. More...
bool	operator!= (const MultiDimContainer< GUM_SCALAR > &p) const
	Test if this MultiDimContainer is different of p. More...
virtual void	apply (std::function< GUM_SCALAR(GUM_SCALAR) > f) const
	Apply a function on every element of the container. More...
virtual GUM_SCALAR	reduce (std::function< GUM_SCALAR(GUM_SCALAR, GUM_SCALAR) > f, GUM_SCALAR base) const
	compute lfold for this container More...
Accessors / Modifiers
void	replace (const DiscreteVariable &x, const DiscreteVariable &y)
	Replace variables in this multidim. More...

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

Detailed Description

template<typename GUM_SCALAR>
class gum::MultiDimBucket< GUM_SCALAR >

A multidim implementation for buckets.

This class behaves in two different ways, depending on the value of memory allowed and the size of the resulting multidimensional table. If the table is above the allowed amount of memory then value are computed when demanded, having a cache for each registered instantiation to not compute several times in a row the same value.

If the memory allowed is enough to contain the bucket's table, then the resulting table is computed when a value is demanded for the first time.

Since a MultiDimArray is used as a buffer, an instantiation real master will be the internal buffer of a MultiDimBucket. This is why you should always call the Instantiation::isMaster() method with the reference retuned by MultiDimBucket::getMasterRef().

TODO handle slave switch between buffer and hashtable.

Template Parameters

GUM_SCALAR

The type of scalars stored in this multidimensional table.

Definition at line 72 of file multiDimBucket.h.

Constructor & Destructor Documentation

MultiDimBucket() [1/2]

template<typename GUM_SCALAR >

gum::MultiDimBucket< GUM_SCALAR >::MultiDimBucket ( Size  bufferSize = INT_MAX )

explicit

Default constructor.

The default amount of memory available for a bucket is 2^16 (65536) elements in the table.

Parameters

bufferSize

The amount of memory allowed for this bucket.

Definition at line 33 of file multiDimBucket_tpl.h.

                                                              :
      MultiDimReadOnly< GUM_SCALAR >(), __bufferSize(bufferSize), __bucket(0),
      __changed(false), __name("MultiDimBucket") {
    GUM_CONSTRUCTOR(MultiDimBucket);
  }

MultiDimBucket() [2/2]

template<typename GUM_SCALAR >

gum::MultiDimBucket< GUM_SCALAR >::MultiDimBucket

(

const MultiDimBucket< GUM_SCALAR > &

source

)

Copy constructor.

Parameters

source

The MultiDimBucket to copy.

Definition at line 40 of file multiDimBucket_tpl.h.

                                                 :
      MultiDimReadOnly< GUM_SCALAR >(source),
      __bufferSize(source.__bufferSize), __bucket(0),
      __multiDims(source.__multiDims), __allVariables(source.__allVariables),
      __allVarsInst(source.__allVarsInst), __changed(source.__changed),
      __name("MultiDimBucket") {
    GUM_CONS_CPY(MultiDimBucket);
  }

~MultiDimBucket()

template<typename GUM_SCALAR >

gum::MultiDimBucket< GUM_SCALAR >::~MultiDimBucket ( )

virtual

Destructor.

Definition at line 51 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, gum::MultiDimBucket< GUM_SCALAR >::__multiDims, and gum::BijectionIteratorSafe< T1, T2 >::second().

                                                {
    GUM_DESTRUCTOR(MultiDimBucket);
    typedef Bijection< Instantiation*, Instantiation* >::iterator_safe BiIter;

    for (BiIter iter = __instantiations.beginSafe();
         iter != __instantiations.endSafe();
         ++iter) {
      delete iter.second();
    }

    if (__bucket) { delete __bucket; }

    for (HashTableIteratorSafe< const MultiDimContainer< GUM_SCALAR >*,
                                Instantiation* > iter = __multiDims.beginSafe();
         iter != __multiDims.endSafe();
         ++iter) {
      delete iter.val();
    }
  }

Here is the call graph for this function:

Member Function Documentation

__addVariable()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::__addVariable ( const DiscreteVariable *  var )

private

Add a variable to __allVariables, and do nothing if var is already in the set.

Parameters

var	The DiscreteVariable to add.

Definition at line 432 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__allVariables, gum::MultiDimBucket< GUM_SCALAR >::__allVarsInst, and gum::Instantiation::add().

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

                                                                            {
    try {
      __allVariables.insert(var);
      __allVarsInst.add(*var);
    } catch (DuplicateElement&) {
      // Nothing to do then!
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__computeValue()

template<typename GUM_SCALAR >

GUM_SCALAR gum::MultiDimBucket< GUM_SCALAR >::__computeValue ( const Instantiation &  value ) const

private

Compute the value of the final table of this bucket given i.

If i variables are a subset of this bucket, then the missing values are supposed to be at 0.

Parameters

value

The value to compute.

Exceptions

SizeError

Raised if the bucket is empty.

Definition at line 515 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__allVarsInst, gum::MultiDimBucket< GUM_SCALAR >::__multiDims, gum::Instantiation::end(), gum::Exception::errorContent(), GUM_ERROR, gum::Instantiation::incOut(), gum::Instantiation::setFirstOut(), and gum::Instantiation::setVals().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::compute(), and gum::MultiDimBucket< GUM_SCALAR >::get().

                                       {
    try {
      GUM_SCALAR sum = (GUM_SCALAR)0;
      GUM_SCALAR current;
      __allVarsInst.setVals(value);

      for (__allVarsInst.setFirstOut(value); !__allVarsInst.end();
           __allVarsInst.incOut(value)) {
        current = (GUM_SCALAR)1;

        for (HashTableIteratorSafe< const MultiDimContainer< GUM_SCALAR >*,
                                    Instantiation* > iter =
                __multiDims.beginSafe();
             iter != __multiDims.endSafe();
             ++iter) {
          (iter.val())->setVals(__allVarsInst);
          current *= iter.key()->get(*(iter.val()));
        }

        sum += current;
      }

      return sum;
    } catch (NotFound& e) {
      std::cerr << std::endl << e.errorContent() << std::endl;
      // This happens if the bucket is empty.
      GUM_ERROR(SizeError, "This MultiDimBucket is empty.");
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__eraseBuffer()

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::__eraseBuffer ( )

private

Clean the buffer and switch it's instantiation to this bucket.

Definition at line 498 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::BijectionIteratorSafe< T1, T2 >::second().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimBucket< GUM_SCALAR >::add(), and gum::MultiDimBucket< GUM_SCALAR >::setBufferSize().

                                                   {
    if (__bucket) {
      typedef Bijection< Instantiation*, Instantiation* >::iterator_safe BiIter;

      for (BiIter iter = __instantiations.beginSafe();
           iter != __instantiations.endSafe();
           ++iter) {
        delete iter.second();
      }

      __instantiations.clear();
      delete __bucket;
      __bucket = 0;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__eraseVariable()

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::__eraseVariable ( const DiscreteVariable *  var )

private

Erase a variable from __allVariables if no other multidimensional table uses it in this bucket.

Parameters

var	The DiscreteVariable to remove.

Definition at line 442 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__allVariables, gum::MultiDimBucket< GUM_SCALAR >::__allVarsInst, gum::MultiDimBucket< GUM_SCALAR >::__multiDims, and gum::Instantiation::erase().

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

                                                                                {
    bool found = false;

    for (HashTableIteratorSafe< const MultiDimContainer< GUM_SCALAR >*,
                                Instantiation* > iter = __multiDims.beginSafe();
         iter != __multiDims.endSafe();
         ++iter) {
      if (iter.key()->contains(*var)) {
        found = true;
        break;
      }
    }

    // No one use it, we can safely remove it
    if (!found) {
      __allVariables.erase(var);
      __allVarsInst.erase(*var);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__initializeBuffer()

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer ( )

private

Initialize the internal buffer.

This method delete __bucket after saving it's slave instantiations.

Definition at line 463 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__changed, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, gum::MultiDimImplementation< GUM_SCALAR >::_slaves(), gum::MultiDimImplementation< GUM_SCALAR >::empty(), gum::BijectionIteratorSafe< T1, T2 >::second(), and gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Referenced by gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::erase(), and gum::MultiDimBucket< GUM_SCALAR >::setBufferSize().

                                                        {
    if (__bucket) {
      typedef Bijection< Instantiation*, Instantiation* >::iterator_safe BiIter;

      for (BiIter iter = __instantiations.beginSafe();
           iter != __instantiations.endSafe();
           ++iter) {
        delete iter.second();
      }

      __instantiations.clear();
      delete __bucket;
      __bucket = 0;
    }

    // Creating the table.
    __bucket = new MultiDimArray< GUM_SCALAR >();

    for (auto var : this->variablesSequence()) {
      __bucket->add(*var);
    }

    if (!this->_slaves().empty()) {
      for (List< Instantiation* >::const_iterator_safe iter =
              this->_slaves().cbeginSafe();
           iter != this->_slaves().cendSafe();
           ++iter) {
        __instantiations.insert(*iter, new Instantiation(*__bucket));
      }
    }

    __changed = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

_commitMultipleChanges() [1/2]

template<typename GUM_SCALAR>

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

protectedvirtualinherited

Synchronize content after MultipleChanges.

Parameters

value

Default value for uninitialized values.

Reimplemented in gum::MultiDimArray< GUM_SCALAR >.

Definition at line 257 of file multiDimImplementation_tpl.h.

                        {
    // empty!
  }

_commitMultipleChanges() [2/2]

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges ( )

overrideprotectedvirtual

Synchronize content after MultipleChanges.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 397 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__addVariable(), gum::MultiDimBucket< GUM_SCALAR >::__allVariables, gum::MultiDimBucket< GUM_SCALAR >::__allVarsInst, gum::MultiDimBucket< GUM_SCALAR >::__bufferSize, gum::MultiDimBucket< GUM_SCALAR >::__changed, gum::MultiDimBucket< GUM_SCALAR >::__eraseBuffer(), gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::MultiDimBucket< GUM_SCALAR >::__multiDims, gum::MultiDimImplementation< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimImplementation< GUM_SCALAR >::domainSize(), gum::Instantiation::empty(), gum::Instantiation::erase(), and gum::Instantiation::variablesSequence().

                                                            {
    MultiDimImplementation< GUM_SCALAR >::_commitMultipleChanges();

    if (this->domainSize() <= __bufferSize) {
      __initializeBuffer();
    } else {
      __eraseBuffer();
    }

    __allVariables.clear();

    while (!__allVarsInst.empty()) {
      __allVarsInst.erase(**(__allVarsInst.variablesSequence().beginSafe()));
    }

    for (   // HashTableIteratorSafe<const MultiDimContainer<GUM_SCALAR>*,
            // Instantiation*>
       auto iter = __multiDims.beginSafe(); iter != __multiDims.endSafe();
       ++iter) {
      for (auto var : iter.key()->variablesSequence()) {
        __addVariable(var);
      }
    }

    __changed = true;
  }

Here is the call graph for this function:

_get()

template<typename GUM_SCALAR >

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

overrideprotectedvirtual

Warning

This will raise en exception, you should directly use the get() and operator[]() methods.

Reimplemented from gum::MultiDimReadOnly< GUM_SCALAR >.

Definition at line 426 of file multiDimBucket_tpl.h.

References GUM_ERROR.

                                                                        {
    GUM_ERROR(OperationNotAllowed, "a MultiDimBucket is a read only MultiDim");
  }

_invert()

template<typename GUM_SCALAR >

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

protectedvirtualinherited

Inverts variables at position p1 and p2.

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

Parameters

p1	The first position.
p2	The second position.

Definition at line 316 of file multiDimImplementation_tpl.h.

                                                                          {
    __vars.swap(p1, p2);
  }

_isCommitNeeded()

template<typename GUM_SCALAR >

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

protectedinherited

Get the actual state of *this.

Returns

Returns true if a commit is needed.

Definition at line 271 of file multiDimImplementation_tpl.h.

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

_isInMultipleChangeMethod()

template<typename GUM_SCALAR >

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

protectedinherited

Get the actual change method of this MultiDimImplementation.

Returns

Returns true if in multiple changes.

Definition at line 265 of file multiDimImplementation_tpl.h.

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

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

Here is the caller graph for this function:

_replace()

template<typename GUM_SCALAR >

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

overrideprotectedvirtual

Replace variable x by y.

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

Parameters

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

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 563 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__allVariables, gum::MultiDimBucket< GUM_SCALAR >::__allVarsInst, gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, gum::MultiDimImplementation< GUM_SCALAR >::_replace(), gum::BijectionIteratorSafe< T1, T2 >::first(), and gum::MultiDimInterface::replace().

                                                                                {
    MultiDimImplementation< GUM_SCALAR >::_replace(x, y);
    typedef Bijection< Instantiation*, Instantiation* >::iterator_safe Iter;

    for (Iter iter = __instantiations.beginSafe();
         iter != __instantiations.endSafe();
         ++iter) {
      iter.first()->replace(*x, *y);
      iter.second()->replace(*x, *y);
    }

    if (__bucket) __bucket->replace(*x, *y);

    __allVariables.erase(x);
    __allVariables.insert(y);
    __allVarsInst.replace(*x, *y);
  }

Here is the call graph for this function:

_slaves()

template<typename GUM_SCALAR >

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

protectedinherited

Returns a constant reference over the list of slaved instantiations.

Returns

Returns a constant reference over the list of slaved instantiations.

Definition at line 278 of file multiDimImplementation_tpl.h.

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

                                                                   {
    return __slaveInstantiations;
  }

Here is the caller graph for this function:

add() [1/3]

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::add

(

const MultiDimContainer< GUM_SCALAR > &

impl

)

Add a MultiDimContainer in the bucket.

Parameters

impl	The MultiDimContainer to copy.

Exceptions

DuplicateElement

Raised if impl is already in the bucket.

Definition at line 72 of file multiDimBucket_tpl.h.

Referenced by gum::prm::SVE< GUM_SCALAR >::__eliminateDelayedVariables().

                                                  {
    this->add(&impl);
  }

Here is the caller graph for this function:

add() [2/3]

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::add

(

const MultiDimContainer< GUM_SCALAR > *

impl

)

Add a MultiDimContainer in the bucket.

Parameters

impl	The MultiDimContainer to add.

Exceptions

DuplicateElement

Raised if impl is already in the bucket.

Definition at line 78 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__addVariable(), gum::MultiDimBucket< GUM_SCALAR >::__changed, gum::MultiDimBucket< GUM_SCALAR >::__multiDims, and gum::MultiDimInterface::variablesSequence().

                                                  {
    __multiDims.insert(impl, new Instantiation(*impl));

    if (!MultiDimImplementation< GUM_SCALAR >::_isInMultipleChangeMethod()) {
      for (const auto var : impl->variablesSequence()) {
        __addVariable(var);
      }
    }

    __changed = true;
  }

Here is the call graph for this function:

add() [3/3]

template<typename GUM_SCALAR >

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

overridevirtual

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

See also

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

Warning

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

Parameters

v	The new var.

Exceptions

DuplicateElement	Raised if the variable already belongs to the sequence of variables.
OperationNotAllowed	Raised if this object is non mutable.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 181 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__bufferSize, gum::MultiDimBucket< GUM_SCALAR >::__eraseBuffer(), gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::MultiDimImplementation< GUM_SCALAR >::add(), and gum::MultiDimImplementation< GUM_SCALAR >::domainSize().

                                                                         {
    MultiDimImplementation< GUM_SCALAR >::add(v);

    if (!MultiDimImplementation< GUM_SCALAR >::_isInMultipleChangeMethod()) {
      if (this->domainSize() <= __bufferSize) {
        if (__bucket)
          __bucket->add(v);
        else
          __initializeBuffer();
      } else if (__bucket) {
        __eraseBuffer();
      }
    }
  }

Here is the call graph for this function:

allVariables()

template<typename GUM_SCALAR >

INLINE const Set< const DiscreteVariable *> & gum::MultiDimBucket< GUM_SCALAR >::allVariables

(

)

const

Returns the sequence of all the variables contained in the bucket.

Returns

Returns the sequence of all the variables contained in the bucket.

Definition at line 124 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__allVariables.

Referenced by gum::prm::SVE< GUM_SCALAR >::__eliminateDelayedVariables().

                                                                {
    return __allVariables;
  }

Here is the caller graph for this function:

apply()

template<typename GUM_SCALAR >

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

virtualinherited

Apply a function on every element of the container.

Parameters

f	the function to apply

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

Definition at line 193 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

basename()

template<typename GUM_SCALAR >

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

inherited

Returns the base class name of this MultiDimImplementation.

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

Definition at line 296 of file multiDimImplementation_tpl.h.

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

beginMultipleChanges()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Call this method before doing important changes in this MultiDimContainer.

Warning

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 226 of file multiDimImplementation_tpl.h.

                                                                         {
    __internalChangeMethod = __InternalChangeMethod::MULTIPLE_CHANGE;
  }

bucket()

template<typename GUM_SCALAR >

INLINE const MultiDimArray< GUM_SCALAR > & gum::MultiDimBucket< GUM_SCALAR >::bucket

(

)

const

Returns the MultiDimArray used by this MultiDimBucket.

Returns

Returns the MultiDimArray used by this MultiDimBucket.

Exceptions

OperationNotAllowed

Raised if the bucket has not been built.

Definition at line 554 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, and GUM_ERROR.

                                                          {
    if (__bucket) {
      return *__bucket;
    } else {
      GUM_ERROR(OperationNotAllowed, "bucket not used.");
    }
  }

bucketChanged()

template<typename GUM_SCALAR >

INLINE bool gum::MultiDimBucket< GUM_SCALAR >::bucketChanged

(

)

const

Returns true if the bucket need re-computation since the last computation.

Returns

Returns true if the bucket need re-computation since the last computation.

Definition at line 139 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__changed.

                                                                {
    return __changed;
  }

bucketSize()

template<typename GUM_SCALAR >

INLINE Size gum::MultiDimBucket< GUM_SCALAR >::bucketSize

(

)

const

Returns the number of MultiDimContainer in in this bukcet.

Returns

Returns the number of MultiDimContainer in in this bukcet.

Definition at line 129 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__multiDims.

                                                             {
    return __multiDims.size();
  }

bufferSize()

template<typename GUM_SCALAR >

INLINE Size gum::MultiDimBucket< GUM_SCALAR >::bufferSize

(

)

const

Returns the amount of memory allowed for this bucket.

Returns

Returns the amount of memory allowed for this bucket.

Definition at line 144 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bufferSize.

                                                             {
    return __bufferSize;
  }

changeNotification()

template<typename GUM_SCALAR >

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

overridevirtual

Listen to changes in a given Instantiation.

Parameters

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

Implements gum::MultiDimAdressable.

Definition at line 243 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimBucket< GUM_SCALAR >::__slavesValue.

                                           {
    if (__bucket) {
      try {
        __bucket->changeNotification(
           *(__instantiations).second(const_cast< Instantiation* >(&i)),
           var,
           oldval,
           newval);
      } catch (NotFound&) {
        // Then i is not a slave of this
      }
    } else {
      __slavesValue.erase(&i);
    }
  }

compressionRate()

template<typename GUM_SCALAR >

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

inherited

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

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

Warning

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

Returns

Returns the compression ration of the table.

Definition at line 290 of file multiDimImplementation_tpl.h.

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

compute()

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::compute

(

bool

force = false

)

const

This method computes the final table of this bucket.

A flag is used to prevent unnecessary computation if the table has already been computed.

If the size of the final table is above the amount of authorized memory, an OperationNotAllowed is raised.

Remember that this method is constant because the content of a multidimensional table is mutable.

Parameters

force

If true (default set at false) then the final table is re-computed.

Exceptions

OperationNotAllowed	Raised if the size of the final table is above the authorized amount of memory.
SizeError	Raised if the bucket is empty.

Definition at line 160 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__changed, gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::MultiDimBucket< GUM_SCALAR >::__slavesValue, gum::Instantiation::end(), gum::Instantiation::inc(), and gum::Instantiation::setFirst().

Referenced by gum::prm::copyPotential(), and gum::MultiDimBucket< GUM_SCALAR >::get().

                                                             {
    if ((__bucket) && (__changed || force)) {
      Instantiation values(*__bucket);

      for (values.setFirst(); !values.end(); values.inc()) {
        __bucket->set(values, __computeValue(values));
      }
    } else if ((__bucket == 0) && __changed) {
      __slavesValue.clear();
      __changed = false;
    }

    __changed = false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

contains() [1/2]

template<typename GUM_SCALAR >

INLINE bool gum::MultiDimBucket< GUM_SCALAR >::contains

(

const MultiDimContainer< GUM_SCALAR > &

impl

)

const

Returns true if the MultiDimContainer is in this bucket.

Parameters

impl	The impl to test for existence.

Returns

Returns true if the MultiDimContainer is in this bucket.

Definition at line 117 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__multiDims.

                                                        {
    return __multiDims.exists(&impl);
  }

contains() [2/2]

template<typename GUM_SCALAR >

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

overridevirtual

Returns true if var is in *this.

Parameters

v	A DiscreteVariable.

Returns

Returns true if var is in *this.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 217 of file multiDimBucket_tpl.h.

References gum::MultiDimImplementation< GUM_SCALAR >::contains().

                                                                           {
    return MultiDimImplementation< GUM_SCALAR >::contains(v);
  }

Here is the call graph for this function:

content() [1/2]

template<typename GUM_SCALAR >

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

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 339 of file multiDimImplementation_tpl.h.

                                                                   {
    return this;
  }

content() [2/2]

template<typename GUM_SCALAR >

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

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 332 of file multiDimImplementation_tpl.h.

                                                       {
    return this;
  }

copy()

template<typename GUM_SCALAR >

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

virtualinherited

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

Parameters

src	The MultiDimContainer to copy.

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

Definition at line 279 of file multiDimContainer_tpl.h.

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

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

                                                 {
    this->beginMultipleChanges();

    Size nbr = this->nbrDim();

    for (Idx i = 0; i < nbr; i++) {
      this->erase(this->variable(0));
    }

    for (Idx i = 0; i < src.nbrDim(); i++) {
      this->add(src.variable(i));
    }

    this->endMultipleChanges();
    this->copyFrom(src);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

copyFrom() [1/2]

template<typename GUM_SCALAR >

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

virtualinherited

Basic copy of a MultiDimContainer.

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

Parameters

src	The MultiDimContainer src which values are copied. This is a full copy with no verification of dimensions.

Exceptions

OperationNotAllowed

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

Reimplemented in gum::aggregator::MultiDimAggregator< GUM_SCALAR >, gum::MultiDimICIModel< GUM_SCALAR >, and gum::MultiDimArray< GUM_SCALAR >.

Definition at line 262 of file multiDimContainer_tpl.h.

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

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

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

    Instantiation i_dest(*this);
    Instantiation i_src(src);

    for (i_dest.setFirst(), i_src.setFirst(); !i_dest.end(); ++i_dest, ++i_src) {
      set(i_dest, src[i_src]);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

copyFrom() [2/2]

template<typename GUM_SCALAR >

void gum::MultiDimContainer< GUM_SCALAR >::copyFrom ( const MultiDimContainer< GUM_SCALAR > &  src, Instantiation *  p_i  ) const

virtualinherited

Basic copy of a MultiDimContainer.

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

Parameters

src	The MultiDimContainer src which values are copied.
p_i	Give the order to iterate in this MultiDimContainer during the copy (nullptr will correctly copy if this is a reorganization of src).

Exceptions

OperationNotAllowed

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

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

Definition at line 215 of file multiDimContainer_tpl.h.

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

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

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

Here is the call graph for this function:

domainSize()

template<typename GUM_SCALAR >

INLINE Size gum::MultiDimImplementation< GUM_SCALAR >::domainSize ( ) const

overridevirtualinherited

Returns the product of the variables domain size.

Returns

Returns the product of the variables domain size.

Implements gum::MultiDimInterface.

Definition at line 177 of file multiDimImplementation_tpl.h.

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

                                                                     {
    return __domainSize;
  }

Here is the caller graph for this function:

empty()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns true if no var is in *this.

Returns

Returns true if no var is in *this.

Implements gum::MultiDimInterface.

Definition at line 220 of file multiDimImplementation_tpl.h.

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

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

Here is the caller graph for this function:

endMultipleChanges() [1/2]

template<typename GUM_SCALAR >

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

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 231 of file multiDimImplementation_tpl.h.

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

    __internalChangeMethod = __InternalChangeMethod::DIRECT_CHANGE;
  }

endMultipleChanges() [2/2]

template<typename GUM_SCALAR>

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

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 241 of file multiDimImplementation_tpl.h.

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

    __internalChangeMethod = __InternalChangeMethod::DIRECT_CHANGE;
  }

erase() [1/3]

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::erase

(

const MultiDimContainer< GUM_SCALAR > &

impl

)

Remove a MultiDimContainer from this bucket.

Parameters

impl	The MultiDimContainer to remove.

Definition at line 92 of file multiDimBucket_tpl.h.

                                                  {
    this->erase(&impl);
  }

erase() [2/3]

template<typename GUM_SCALAR >

void gum::MultiDimBucket< GUM_SCALAR >::erase

(

const MultiDimContainer< GUM_SCALAR > *

impl

)

Remove a MultiDimContainer from this bucket.

Parameters

impl	The MultiDimContainer to remove.

Definition at line 98 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__changed, gum::MultiDimBucket< GUM_SCALAR >::__eraseVariable(), gum::MultiDimBucket< GUM_SCALAR >::__multiDims, and gum::MultiDimInterface::variablesSequence().

                                                  {
    try {
      delete __multiDims[impl];
      __multiDims.erase(impl);

      if (!MultiDimImplementation< GUM_SCALAR >::_isInMultipleChangeMethod()) {
        for (auto var : impl->variablesSequence()) {
          __eraseVariable(var);
        }
      }

      __changed = true;
    } catch (NotFound&) {
      // Do nothing
    }
  }

Here is the call graph for this function:

erase() [3/3]

template<typename GUM_SCALAR >

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

overridevirtual

Removes a var from the variables of the multidimensional matrix.

See also

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

Exceptions

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

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 197 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__bufferSize, gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::MultiDimImplementation< GUM_SCALAR >::domainSize(), and gum::MultiDimImplementation< GUM_SCALAR >::erase().

                                                                           {
    MultiDimImplementation< GUM_SCALAR >::erase(v);

    if ((!MultiDimImplementation< GUM_SCALAR >::_isInMultipleChangeMethod())
        && (this->domainSize() <= __bufferSize)) {
      if (__bucket) {
        __bucket->erase(v);
      } else {
        __initializeBuffer();
      }
    }
  }

Here is the call graph for this function:

extractFrom()

template<typename GUM_SCALAR >

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

virtualinherited

Basic extraction of a MultiDimContainer.

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

Parameters

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

Definition at line 237 of file multiDimContainer_tpl.h.

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

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

                                                                             {
    this->beginMultipleChanges();

    Size nbr = this->nbrDim();

    for (Idx i = 0; i < nbr; i++) {
      this->erase(this->variable(0));
    }

    for (Idx i = 0; i < src.nbrDim(); i++) {
      if (!imask.contains(src.variable(i))) this->add(src.variable(i));
    }

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

    this->endMultipleChanges();

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

Here is the call graph for this function:

Here is the caller graph for this function:

fill()

template<typename GUM_SCALAR >

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

virtualinherited

Warning

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 64 of file multiDimReadOnly_tpl.h.

References GUM_ERROR.

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

get()

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::MultiDimBucket< GUM_SCALAR >::get ( const Instantiation &  i ) const

overridevirtual

Returns the value pointed by i.

Warning

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

Parameters

i	An Instantiation of this MultiDimContainer.

Returns

Returns the value pointe by i.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 223 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::MultiDimBucket< GUM_SCALAR >::__instantiations, gum::MultiDimBucket< GUM_SCALAR >::__slavesValue, gum::MultiDimBucket< GUM_SCALAR >::compute(), and gum::Instantiation::isMaster().

                                                                       {
    compute();

    if (__bucket) {
      try {
        return __bucket->get(
           *(__instantiations.second(const_cast< Instantiation* >(&i))));
      } catch (NotFound&) { return __bucket->get(i); }
    } else if (i.isMaster(this)) {
      if (!__slavesValue.exists(&i)) {
        __slavesValue.insert(&i, __computeValue(i));
      }

      return __slavesValue[&i];
    } else {
      return __computeValue(i);
    }
  }

Here is the call graph for this function:

getMasterRef() [1/2]

template<typename GUM_SCALAR >

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

overridevirtual

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

Returns

Returns the ref to content as MultiDimAdressable&

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 370 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket.

                                                                        {
    if (__bucket) {
      return *__bucket;
    } else {
      return *this;
    }
  }

getMasterRef() [2/2]

template<typename GUM_SCALAR >

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

overridevirtual

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

Returns

Returns the master of this MultiDimAdressable.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 380 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket.

                                                                {
    if (__bucket) {
      return *__bucket;
    } else {
      return *this;
    }
  }

isBucketEmpty()

template<typename GUM_SCALAR >

INLINE bool gum::MultiDimBucket< GUM_SCALAR >::isBucketEmpty

(

)

const

Returns true if this bucket is empty.

Returns

Returns true if this bucket is empty.

Definition at line 134 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__multiDims.

                                                                {
    return __multiDims.empty();
  }

multidims()

template<typename GUM_SCALAR >

INLINE const HashTable< const MultiDimContainer< GUM_SCALAR > *, Instantiation *> & gum::MultiDimBucket< GUM_SCALAR >::multidims

(

)

const

Returns the MultiDimContainer and their respective Instantiation.

Returns

Returns the MultiDimContainer and their respective Instantiation.

Definition at line 584 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__multiDims.

                                                             {
    return __multiDims;
  }

name()

template<typename GUM_SCALAR >

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

overridevirtual

Returns the real name of the multiDim implementation.

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

Returns

Returns the real name of the multiDim implementation

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 176 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__name.

                                                            {
    return __name;
  }

nbrDim()

template<typename GUM_SCALAR >

INLINE Idx gum::MultiDimImplementation< GUM_SCALAR >::nbrDim ( ) const

overridevirtualinherited

Returns the number of vars in the multidimensional container.

Returns

Returns the number of vars in the multidimensional container.

Implements gum::MultiDimInterface.

Definition at line 172 of file multiDimImplementation_tpl.h.

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

                                                                {
    return __vars.size();
  }

Here is the caller graph for this function:

newFactory()

template<typename GUM_SCALAR >

INLINE MultiDimContainer< GUM_SCALAR > * gum::MultiDimBucket< GUM_SCALAR >::newFactory ( ) const

overridevirtual

Default constructor.

Implements gum::MultiDimReadOnly< GUM_SCALAR >.

Definition at line 548 of file multiDimBucket_tpl.h.

                                                        {
    return new MultiDimBucket< GUM_SCALAR >;
  }

operator!=()

template<typename GUM_SCALAR >

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

inherited

Test if this MultiDimContainer is different of p.

Parameters

p	The MultiDimContainer to test for inequality.

Returns

Returns true if this MultiDimContainer is different of p.

Definition at line 157 of file multiDimContainer_tpl.h.

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

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

                                                                         {
    return !operator==(p);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

operator==()

template<typename GUM_SCALAR >

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

inherited

Test if this MultiDimContainer is equal to p.

Parameters

p	The MultiDimContainer to test for equality.

Returns

Returns true if this MultiDimContainer is equal to p.

Definition at line 126 of file multiDimContainer_tpl.h.

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

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

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

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

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

    Instantiation i(*this);

    AlmostDifferent< GUM_SCALAR > cmp;

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

    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

operator[]()

template<typename GUM_SCALAR >

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

inherited

An [] operator using a Instantiation as argument.

Warning

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

Parameters

i	An Instantiation.

Returns

Returns the adressed (GUM_SCALAR) value.

Definition at line 79 of file multiDimContainer_tpl.h.

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

                                                             {
    return get(i);
  }

Here is the caller graph for this function:

populate() [1/2]

template<typename GUM_SCALAR >

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

virtualinherited

Automatically fills this MultiDimContainer with the values in v.

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

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

Parameters

v	Vector of values.

Exceptions

SizeError

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

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

Definition at line 163 of file multiDimContainer_tpl.h.

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

                                             {
    if (domainSize() != v.size()) {
      GUM_ERROR(SizeError, "Sizes do not match in populate");
    }

    Size cpt = 0;

    Instantiation i(*this);

    for (i.setFirst(); !i.end(); ++i, ++cpt)
      set(i, v[cpt]);
  }

Here is the call graph for this function:

populate() [2/2]

template<typename GUM_SCALAR >

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

virtualinherited

Automatically fills this MultiDimContainer with the values in l.

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

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

Parameters

l	contains the data.

Exceptions

SizeError

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

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

Definition at line 178 of file multiDimContainer_tpl.h.

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

                                                {
    if (domainSize() != l.size()) {
      GUM_ERROR(SizeError, "Sizes do not match in populate");
    }

    Instantiation i(*this);
    // insert all the elements
    for (const auto& elt : l) {
      set(i, elt);
      ++i;
    }
  }

Here is the call graph for this function:

pos()

template<typename GUM_SCALAR >

INLINE Idx gum::MultiDimImplementation< GUM_SCALAR >::pos ( const DiscreteVariable &  v ) const

overridevirtualinherited

Returns the index of a variable.

Parameters

v	The variable for which the index is returned.

Returns

Returns the index of a variable.

Exceptions

NotFound

Raised if v is not in this multidimensional matrix.

Implements gum::MultiDimInterface.

Definition at line 200 of file multiDimImplementation_tpl.h.

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

                                                                                  {
    return __vars.pos(&v);
  }

Here is the caller graph for this function:

realSize()

template<typename GUM_SCALAR >

INLINE Size gum::MultiDimBucket< GUM_SCALAR >::realSize ( ) const

overridevirtual

Returns the real number of parameters used for this table.

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

See also

MultiDimImplementation::compressionRate()

Returns

Returns the real number of parameters used for this table.

Implements gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 211 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket.

                                                           {
    return (__bucket) ? __bucket->realSize() : (Size)0;
  }

reduce()

template<typename GUM_SCALAR >

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

virtualinherited

compute lfold for this container

Parameters

f	the function to apply
base	the initial value

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

Definition at line 202 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

registerSlave()

template<typename GUM_SCALAR >

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

overridevirtual

Register i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to enslave.

Returns

Returns true if i becomes a slave of this MultiDimAdressable.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 339 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimImplementation< GUM_SCALAR >::registerSlave().

                                                                          {
    if (__bucket) {
      try {
        __instantiations.insert(&i, new Instantiation(*__bucket));
      } catch (DuplicateElement&) { return false; }
    }

    return MultiDimImplementation< GUM_SCALAR >::registerSlave(i);
  }

Here is the call graph for this function:

replace()

INLINE void gum::MultiDimInterface::replace ( const DiscreteVariable &  x, const DiscreteVariable &  y  )

inherited

Replace variables in this multidim.

If x is in this MultiDim and y has the same domain size, then x will be replace by y in this MultiDim.

Parameters

x	The variable in this which will be replaced.
y	The variable replacing y.

Exceptions

NotFound	Raised if x does not belong to this MultiDim.
OperationNotAllowed	If y and x are not interchangeable.
DuplicateElement	If y is already in this MultiDim.

Definition at line 33 of file multiDimInterface_inl.h.

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

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

                                                             {
    if (!contains(x)) { GUM_ERROR(NotFound, "could not find the variable"); }

    if (contains(y)) {
      GUM_ERROR(DuplicateElement, "variable " << y << " already in MultiDim");
    }

    if (x.domainSize() != y.domainSize()) {
      GUM_ERROR(OperationNotAllowed, "incompatible variables");
    }

    _replace(&x, &y);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

set()

template<typename GUM_SCALAR >

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

virtualinherited

Warning

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

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 56 of file multiDimReadOnly_tpl.h.

References GUM_ERROR.

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

setBufferSize()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::setBufferSize

(

Size

amount

)

Changes the amount of memory allowed for this bucket.

If the new amount is not enough for the current size of this bucket, then internal buffer is deleted. In the other case, the internal buffer is created but not computed.

Parameters

amount

The amount of memory allowed for this bucket.

Definition at line 149 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__bufferSize, gum::MultiDimBucket< GUM_SCALAR >::__eraseBuffer(), gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), and gum::MultiDimImplementation< GUM_SCALAR >::domainSize().

                                                                      {
    __bufferSize = ammount;

    if ((this->domainSize() > __bufferSize) && (__bucket != 0)) {
      __eraseBuffer();
    } else if (__bucket == 0) {
      __initializeBuffer();
    }
  }

Here is the call graph for this function:

setChangeNotification()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::setChangeNotification ( const Instantiation &  i )

overridevirtual

Listen to an assignment of a value in a Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 325 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimBucket< GUM_SCALAR >::__slavesValue.

                                                                               {
    if (__bucket) {
      try {
        __bucket->setChangeNotification(
           *(__instantiations.second(const_cast< Instantiation* >(&i))));
      } catch (NotFound&) {
        // Then i is not a slave of this
      }
    } else {
      __slavesValue.erase(&i);
    }
  }

setDecNotification()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::setDecNotification ( const Instantiation &  i )

overridevirtual

Listen to increment in each recorded Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 310 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimBucket< GUM_SCALAR >::__slavesValue.

                                                                            {
    if (__bucket) {
      try {
        __bucket->setDecNotification(
           *(__instantiations.second(const_cast< Instantiation* >(&i))));
      } catch (NotFound&) {
        // Then i is not a slave of this
      }
    } else {
      __slavesValue.erase(&i);
    }
  }

setFirstNotification()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::setFirstNotification ( const Instantiation &  i )

overridevirtual

Listen to setFirst in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 265 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimBucket< GUM_SCALAR >::__slavesValue.

                                                                              {
    if (__bucket) {
      try {
        __bucket->setFirstNotification(
           *(__instantiations).second(const_cast< Instantiation* >(&i)));
      } catch (NotFound&) {
        // Then i is not a slave of this
      }
    } else {
      __slavesValue.erase(&i);
    }
  }

setIncNotification()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::setIncNotification ( const Instantiation &  i )

overridevirtual

Listen to increment in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 295 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimBucket< GUM_SCALAR >::__slavesValue.

                                                                            {
    if (__bucket) {
      try {
        __bucket->setIncNotification(
           *(__instantiations.second(const_cast< Instantiation* >(&i))));
      } catch (NotFound&) {
        // Then i is not a slave of this
      }
    } else {
      __slavesValue.erase(&i);
    }
  }

setLastNotification()

template<typename GUM_SCALAR >

INLINE void gum::MultiDimBucket< GUM_SCALAR >::setLastNotification ( const Instantiation &  i )

overridevirtual

Listen to setLast in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 280 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, and gum::MultiDimBucket< GUM_SCALAR >::__slavesValue.

                                                                             {
    if (__bucket) {
      try {
        __bucket->setLastNotification(
           *(__instantiations).second(const_cast< Instantiation* >(&i)));
      } catch (NotFound&) {
        // Then i is not a slave of this
      }
    } else {
      __slavesValue.erase(&i);
    }
  }

toString() [1/2]

template<typename GUM_SCALAR >

INLINE const std::string gum::MultiDimBucket< GUM_SCALAR >::toString ( const Instantiation *  i ) const

overridevirtual

Display the internal representation of i.

Returns

Returns an internal representation of i.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 390 of file multiDimBucket_tpl.h.

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

toString() [2/2]

template<typename GUM_SCALAR >

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

virtualinherited

Returns a representation of this MultiDimContainer.

Returns

Returns a representation of this MultiDimContainer.

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

Definition at line 102 of file multiDimContainer_tpl.h.

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

Referenced by gum::operator<<().

                                                                  {
    // we create a new instantiation and iterate over it to display the whole
    // content of the array
    if (this->nbrDim() == 0) { return "[]"; }

    std::stringstream ss;
    Instantiation     inst(const_cast< MultiDimContainer* >(this));

    bool first = true;

    for (inst.setFirst(); !inst.end(); ++inst) {
      if (!first) { ss << " /"; }
      first = false;

      ss << inst << " :: " << get(inst);
    }

    return ss.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

unregisterSlave()

template<typename GUM_SCALAR >

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

overridevirtual

Unregister i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to free.

Returns

Returns true, whatever happens.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 350 of file multiDimBucket_tpl.h.

References gum::MultiDimBucket< GUM_SCALAR >::__bucket, gum::MultiDimBucket< GUM_SCALAR >::__instantiations, gum::MultiDimBucket< GUM_SCALAR >::__slavesValue, and gum::MultiDimImplementation< GUM_SCALAR >::unregisterSlave().

                                                                            {
    MultiDimReadOnly< GUM_SCALAR >::unregisterSlave(i);

    if (__bucket) {
      try {
        delete __instantiations.second(&i);
        __instantiations.eraseFirst(&i);
        return true;
      } catch (NotFound&) { return false; }
    } else {
      if (__slavesValue.exists(&i)) {
        __slavesValue.erase(&i);
        return true;
      } else {
        return false;
      }
    }
  }

Here is the call graph for this function:

variable() [1/2]

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns a const ref to the ith var.

param i An index of this multidimensional matrix.

Returns

Returns a const ref to the ith var.

Exceptions

NotFound

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

Implements gum::MultiDimInterface.

Definition at line 183 of file multiDimImplementation_tpl.h.

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

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

Here is the caller graph for this function:

variable() [2/2]

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns the variable with the name.

Parameters

name	The index of the variable

Returns

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

Exceptions

NotFound

Raised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 188 of file multiDimImplementation_tpl.h.

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

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

variablesSequence()

template<typename GUM_SCALAR >

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

overridevirtualinherited

Returns a const ref to the sequence of DiscreteVariable*.

Returns

Returns a const ref to the sequence of DiscreteVariable*.

Implements gum::MultiDimInterface.

Definition at line 214 of file multiDimImplementation_tpl.h.

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

                                                                             {
    return __vars;
  }

Here is the caller graph for this function:

Member Data Documentation

__allVariables

template<typename GUM_SCALAR>

Set< const DiscreteVariable* > gum::MultiDimBucket< GUM_SCALAR >::__allVariables

private

The set of all variables of the multidims in this bucket.

Definition at line 294 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__addVariable(), gum::MultiDimBucket< GUM_SCALAR >::__eraseVariable(), gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimBucket< GUM_SCALAR >::_replace(), and gum::MultiDimBucket< GUM_SCALAR >::allVariables().

__allVarsInst

template<typename GUM_SCALAR>

Instantiation gum::MultiDimBucket< GUM_SCALAR >::__allVarsInst

mutableprivate

Instantiation over all variable in this.

Definition at line 297 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__addVariable(), gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::MultiDimBucket< GUM_SCALAR >::__eraseVariable(), gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), and gum::MultiDimBucket< GUM_SCALAR >::_replace().

__bucket

template<typename GUM_SCALAR>

MultiDimArray< GUM_SCALAR >* gum::MultiDimBucket< GUM_SCALAR >::__bucket

private

The result table of this bucket.

Definition at line 287 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__eraseBuffer(), gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::MultiDimBucket< GUM_SCALAR >::_replace(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::bucket(), gum::MultiDimBucket< GUM_SCALAR >::changeNotification(), gum::MultiDimBucket< GUM_SCALAR >::compute(), gum::MultiDimBucket< GUM_SCALAR >::erase(), gum::MultiDimBucket< GUM_SCALAR >::get(), gum::MultiDimBucket< GUM_SCALAR >::getMasterRef(), gum::MultiDimBucket< GUM_SCALAR >::realSize(), gum::MultiDimBucket< GUM_SCALAR >::registerSlave(), gum::MultiDimBucket< GUM_SCALAR >::setBufferSize(), gum::MultiDimBucket< GUM_SCALAR >::setChangeNotification(), gum::MultiDimBucket< GUM_SCALAR >::setDecNotification(), gum::MultiDimBucket< GUM_SCALAR >::setFirstNotification(), gum::MultiDimBucket< GUM_SCALAR >::setIncNotification(), gum::MultiDimBucket< GUM_SCALAR >::setLastNotification(), gum::MultiDimBucket< GUM_SCALAR >::unregisterSlave(), and gum::MultiDimBucket< GUM_SCALAR >::~MultiDimBucket().

__bufferSize

template<typename GUM_SCALAR>

Size gum::MultiDimBucket< GUM_SCALAR >::__bufferSize

private

The number of element allowed in __bucket.

Definition at line 280 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::bufferSize(), gum::MultiDimBucket< GUM_SCALAR >::erase(), and gum::MultiDimBucket< GUM_SCALAR >::setBufferSize().

__changed

template<typename GUM_SCALAR>

bool gum::MultiDimBucket< GUM_SCALAR >::__changed

mutableprivate

Flag used to know if changes has occurred in the bucket since last computation.

Definition at line 340 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::bucketChanged(), gum::MultiDimBucket< GUM_SCALAR >::compute(), and gum::MultiDimBucket< GUM_SCALAR >::erase().

__instantiations

template<typename GUM_SCALAR>

Bijection< Instantiation*, Instantiation* > gum::MultiDimBucket< GUM_SCALAR >::__instantiations

private

Bijection between instantiations registered on this and their equivalent on __bucket.

Definition at line 284 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__eraseBuffer(), gum::MultiDimBucket< GUM_SCALAR >::__initializeBuffer(), gum::MultiDimBucket< GUM_SCALAR >::_replace(), gum::MultiDimBucket< GUM_SCALAR >::changeNotification(), gum::MultiDimBucket< GUM_SCALAR >::get(), gum::MultiDimBucket< GUM_SCALAR >::registerSlave(), gum::MultiDimBucket< GUM_SCALAR >::setChangeNotification(), gum::MultiDimBucket< GUM_SCALAR >::setDecNotification(), gum::MultiDimBucket< GUM_SCALAR >::setFirstNotification(), gum::MultiDimBucket< GUM_SCALAR >::setIncNotification(), gum::MultiDimBucket< GUM_SCALAR >::setLastNotification(), gum::MultiDimBucket< GUM_SCALAR >::unregisterSlave(), and gum::MultiDimBucket< GUM_SCALAR >::~MultiDimBucket().

__multiDims

template<typename GUM_SCALAR>

HashTable< const MultiDimContainer< GUM_SCALAR >*, Instantiation* > gum::MultiDimBucket< GUM_SCALAR >::__multiDims

mutableprivate

The set of MultiDimContainer in this bucket.

Definition at line 291 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::__computeValue(), gum::MultiDimBucket< GUM_SCALAR >::__eraseVariable(), gum::MultiDimBucket< GUM_SCALAR >::_commitMultipleChanges(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::bucketSize(), gum::MultiDimBucket< GUM_SCALAR >::contains(), gum::MultiDimBucket< GUM_SCALAR >::erase(), gum::MultiDimBucket< GUM_SCALAR >::isBucketEmpty(), gum::MultiDimBucket< GUM_SCALAR >::multidims(), and gum::MultiDimBucket< GUM_SCALAR >::~MultiDimBucket().

__name

template<typename GUM_SCALAR>

std::string gum::MultiDimBucket< GUM_SCALAR >::__name

private

The class name.

Definition at line 347 of file multiDimBucket.h.

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

__slavesValue

template<typename GUM_SCALAR>

HashTable< const Instantiation*, GUM_SCALAR > gum::MultiDimBucket< GUM_SCALAR >::__slavesValue

mutableprivate

This table is used to keep the last value computed for an instantiation when the value are computed on the fly.

Definition at line 344 of file multiDimBucket.h.

Referenced by gum::MultiDimBucket< GUM_SCALAR >::changeNotification(), gum::MultiDimBucket< GUM_SCALAR >::compute(), gum::MultiDimBucket< GUM_SCALAR >::get(), gum::MultiDimBucket< GUM_SCALAR >::setChangeNotification(), gum::MultiDimBucket< GUM_SCALAR >::setDecNotification(), gum::MultiDimBucket< GUM_SCALAR >::setFirstNotification(), gum::MultiDimBucket< GUM_SCALAR >::setIncNotification(), gum::MultiDimBucket< GUM_SCALAR >::setLastNotification(), and gum::MultiDimBucket< GUM_SCALAR >::unregisterSlave().

---

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

• agrum/multidim/implementations/multiDimBucket.h
• agrum/multidim/implementations/multiDimBucket_tpl.h