gum::MultiDimBijArray< GUM_SCALAR > Class Template Reference

Decorator of a MultiDimArray, using a bijection over the variables. More...

#include <agrum/base/multidim/multiDimBijArray.h>

Inheritance diagram for gum::MultiDimBijArray< GUM_SCALAR >:

Collaboration diagram for gum::MultiDimBijArray< GUM_SCALAR >:

Public Types
using	VarBijection = Bijection< const DiscreteVariable*, const DiscreteVariable* >

Public Member Functions
Constructors / Destructors
	MultiDimBijArray (const VarBijection &bijection, const MultiDimArray< GUM_SCALAR > &array)
	Class constructor.
	MultiDimBijArray (const VarBijection &bijection, const MultiDimBijArray< GUM_SCALAR > &array)
	Class constructor.
	MultiDimBijArray (const MultiDimBijArray< GUM_SCALAR > &from)
	Copy constructor.
virtual	~MultiDimBijArray ()
	Class destructor.
Modifiers – will raise OperationNotAllowed exceptions
MultiDimBijArray< GUM_SCALAR > &	operator= (const MultiDimBijArray< GUM_SCALAR > &from)
virtual void	set (const Instantiation &i, const GUM_SCALAR &value) const
virtual void	add (const DiscreteVariable &v)
	This will raise an exception: you can't change the variables in a MultiDimBijArray.
virtual void	erase (const DiscreteVariable &v)
	This will raise an exception: you can't change the variables in a MultiDimBijArray.
virtual void	fill (const GUM_SCALAR &d) const
	This will raise an exception: you can't change the data.
virtual void	populate (const std::vector< GUM_SCALAR > &v) const
	This will raise an exception: you can't change the variables in a MultiDimBijArray.
virtual void	populate (std::initializer_list< GUM_SCALAR > l) const
	This will raise an exception: you can't change the variables in a MultiDimBijArray.
Inherited methods
virtual const std::string &	name () const
	Returns the real name of the multiDim implementation.
virtual GUM_SCALAR	get (const Instantiation &i) const
	Returns the value pointed by i.
virtual Size	realSize () const
	Returns the real number of parameters used for this table.
virtual MultiDimBijArray< GUM_SCALAR > *	newFactory () const
	Class constructor.
Accessors and modifiers
virtual std::string	toString (const Instantiation *i) const
	Display the internal representation of i.
virtual void	changeNotification (const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval)
	Listen to changes in a given Instantiation.
virtual void	setChangeNotification (const Instantiation &i)
	Listen to an assignment of a value in a Instantiation.
virtual void	setFirstNotification (const Instantiation &i)
	Listen to setFirst in a given Instantiation.
virtual void	setLastNotification (const Instantiation &i)
	Listen to setLast in a given Instantiation.
void	setIncNotification (const Instantiation &i)
	Listen to increment in a given Instantiation.
void	setDecNotification (const Instantiation &i)
	Listen to increment in each recorded Instantiation.
virtual bool	registerSlave (Instantiation &i)
	Register i as a slave of this MultiDimAdressable.
virtual bool	unregisterSlave (Instantiation &i)
	Unregister i as a slave of this MultiDimAdressable.
Various methods.
virtual std::string	toString () const
	Returns a representation of this MultiDimContainer.
bool	operator== (const MultiDimContainer< GUM_SCALAR > &p) const
	Test if this MultiDimContainer is equal to p.
bool	operator!= (const MultiDimContainer< GUM_SCALAR > &p) const
	Test if this MultiDimContainer is different of p.
virtual void	apply (std::function< GUM_SCALAR(GUM_SCALAR) > f) const
	Apply a function on every element of the container.
virtual GUM_SCALAR	reduce (std::function< GUM_SCALAR(GUM_SCALAR, GUM_SCALAR) > f, GUM_SCALAR base) const
	compute lfold for this container
Access to offset in MultiDimWithOffset
Size	toOffset (const Instantiation &i) const
	Compute offset from an Instantiation (in this array).
Instantiation &	fromOffset (Instantiation &i, Size offset) const
	Set the Instantiation to the values corresponding to the offset (in this array).
Accessors / Modifiers
const std::string &	basename () const
	Returns the base class name of this MultiDimImplementation.
float	compressionRate () const
	The compression ratio of the table (depending on the type of implementation).
MultiDimInterface implementation
virtual Idx	nbrDim () const override
	Returns the number of vars in the multidimensional container.
virtual Size	domainSize () const override
	Returns the product of the variables domain size.
virtual const Sequence< const DiscreteVariable * > &	variablesSequence () const override
	Returns a const ref to the sequence of DiscreteVariable*.
const DiscreteVariable &	variable (Idx i) const override
	Returns a const ref to the ith var.
const DiscreteVariable &	variable (const std::string &name) const override
	Returns the variable with the name.
virtual Idx	pos (const DiscreteVariable &v) const override
	Returns the index of a variable.
virtual bool	contains (const DiscreteVariable &v) const override
	Returns true if var is in *this.
virtual bool	empty () const override
	Returns true if no var is in *this.
MultiDimContainer implementation
void	beginMultipleChanges () override
	Call this method before doing important changes in this MultiDimContainer.
void	endMultipleChanges () override
	Call this method after doing important changes in this MultiDimContainer.
void	endMultipleChanges (const GUM_SCALAR &) override
	Call this method after doing important changes in this MultiDimContainer.
Accessors / Modifiers
GUM_SCALAR	operator[] (const Instantiation &i) const
	An [] operator using a Instantiation as argument.
Copy methods.
virtual void	copyFrom (const MultiDimContainer< GUM_SCALAR > &src) const
	Basic copy of a MultiDimContainer.
virtual void	copyFrom (const MultiDimContainer< GUM_SCALAR > &src, Instantiation *p_i) const
	Basic copy of a MultiDimContainer.
virtual void	extractFrom (const MultiDimContainer< GUM_SCALAR > &src, const Instantiation &mask)
	Basic extraction of a MultiDimContainer.
virtual MultiDimAdressable &	getMasterRef ()
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer.
virtual const MultiDimAdressable &	getMasterRef () const
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer.
virtual void	copy (const MultiDimContainer< GUM_SCALAR > &src)
	Removes all variables in this MultiDimContainer and copy the content of src, variables included.
Accessors / Modifiers
void	replace (const DiscreteVariable &x, const DiscreteVariable &y)
	Replace variables in this multidim.

Protected Member Functions
virtual GUM_SCALAR &	get_ (const Instantiation &i) const
	Return a data, given a Instantiation.
virtual void	commitMultipleChanges_ ()
	Synchronize content after MultipleChanges.
virtual void	replace_ (const DiscreteVariable *x, const DiscreteVariable *y)
	Replace variable x by y.
Size	getOffs_ (const Instantiation &i) const
	Compute the offset of a Instantiation.
void	computeInstantiationValue_ (Instantiation &result, Size indice) const
	For a given index of a value in the vector values, this method computes the corresponding instantiation.
virtual const MultiDimImplementation< GUM_SCALAR > *	content () const final
	Returns the implementation for this object (may be *this).
virtual MultiDimImplementation< GUM_SCALAR > *	content () final
	Returns the implementation for this object (may be *this).
Fast large modifications in structures
virtual void	commitMultipleChanges_ (const GUM_SCALAR &value)
	Synchronize content after MultipleChanges.
bool	isInMultipleChangeMethod_ () const
	Get the actual change method of this MultiDimImplementation.
bool	isCommitNeeded_ () const
	Get the actual state of *this.
const List< Instantiation * > &	slaves_ () const
	Returns a constant reference over the list of slaved instantiations.
virtual void	invert_ (Idx p1, Idx p2)
	Inverts variables at position p1 and p2.

Protected Attributes
HashTable< const DiscreteVariable *, Size >	gaps_
	The gaps between consecutive values of a given variable.
HashTable< const Instantiation *, Size >	offsets_
	The position in the array of each slave Instantiation.

Private Types
enum class	_InternalChangeMethod_ : char { DIRECT_CHANGE , MULTIPLE_CHANGE }
	Used to represent in which change method this MultiDimImplementation is. More...
enum class	_InternalChangeState_ : char { NO_CHANGE , NOT_COMMITTED_CHANGE }
	Used to represent in which change state this MultiDimImplementation is. More...

Private Member Functions
void	_setNotCommitedChange_ ()
	Change the internalChangeState to NOT_COMMITTED_CHANGE.

Private Attributes
const MultiDimArray< GUM_SCALAR > &	_array_
	The true data.
std::string	_name_
	The class name.
Sequence< const DiscreteVariable * >	_vars_
	List of discrete variables (dimensions).
List< Instantiation * >	_slaveInstantiations_
	List of instantiations of the tuples (sequences) of variables.
_InternalChangeMethod_	_internalChangeMethod_
	The current change method.
_InternalChangeState_	_internalChangeState_
	The current change state.
Size	_domainSize_
	This MultiDimImplementation domain size.

Detailed Description

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

Decorator of a MultiDimArray, using a bijection over the variables.

Template Parameters

GUM_SCALAR

The type of scaler stored in this multidimensional table.

Definition at line 71 of file multiDimBijArray.h.

Member Typedef Documentation

VarBijection

template<typename GUM_SCALAR>

using gum::MultiDimBijArray< GUM_SCALAR >::VarBijection = Bijection< const DiscreteVariable*, const DiscreteVariable* >

Definition at line 73 of file multiDimBijArray.h.

Member Enumeration Documentation

_InternalChangeMethod_

template<typename GUM_SCALAR>

enum class gum::MultiDimImplementation::_InternalChangeMethod_ : char

strongprivateinherited

Used to represent in which change method this MultiDimImplementation is.

Enumerator
DIRECT_CHANGE
MULTIPLE_CHANGE

Definition at line 295 of file multiDimImplementation.h.

: char { DIRECT_CHANGE, MULTIPLE_CHANGE };

_InternalChangeState_

template<typename GUM_SCALAR>

enum class gum::MultiDimImplementation::_InternalChangeState_ : char

strongprivateinherited

Used to represent in which change state this MultiDimImplementation is.

Enumerator
NO_CHANGE
NOT_COMMITTED_CHANGE

Definition at line 298 of file multiDimImplementation.h.

: char { NO_CHANGE, NOT_COMMITTED_CHANGE };

Constructor & Destructor Documentation

MultiDimBijArray() [1/3]

template<typename GUM_SCALAR>

gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray	(	const VarBijection &	bijection,
		const MultiDimArray< GUM_SCALAR > &	array )

Class constructor.

Parameters

bijection	The bijection between variables in array and variable in this.
array	The MultiDimArray decorated by this MultiDimBijArray.

Definition at line 66 of file multiDimBijArray_tpl.h.

                                                                                             :
      MultiDimWithOffset< GUM_SCALAR >(), _array_(array), _name_("MultiDimBijArray") {
    GUM_CONSTRUCTOR(MultiDimBijArray);
 
    for (auto var: array.variablesSequence()) {
      MultiDimWithOffset< GUM_SCALAR >::add(*(bijection.second(var)));
    }
  }

References MultiDimBijArray(), gum::MultiDimWithOffset< GUM_SCALAR >::MultiDimWithOffset(), _array_, _name_, gum::MultiDimWithOffset< GUM_SCALAR >::add(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::second(), and gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Referenced by MultiDimBijArray(), MultiDimBijArray(), MultiDimBijArray(), ~MultiDimBijArray(), newFactory(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

MultiDimBijArray() [2/3]

template<typename GUM_SCALAR>

gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray	(	const VarBijection &	bijection,
		const MultiDimBijArray< GUM_SCALAR > &	array )

Class constructor.

Parameters

bijection	The bijection between variables in array and variable in this.
array	The MultiDimBijArray decorated by this MultiDimBijArray.

Definition at line 77 of file multiDimBijArray_tpl.h.

                                                                                                :
      MultiDimWithOffset< GUM_SCALAR >(), _array_(array._array_), _name_("MultiDimBijArray") {
    GUM_CONSTRUCTOR(MultiDimBijArray);
 
    for (auto var: array.variablesSequence()) {
      MultiDimWithOffset< GUM_SCALAR >::add(*(bijection.second(var)));
    }
  }

References MultiDimBijArray(), gum::MultiDimWithOffset< GUM_SCALAR >::MultiDimWithOffset(), _array_, _name_, gum::MultiDimWithOffset< GUM_SCALAR >::add(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::second(), and gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

MultiDimBijArray() [3/3]

template<typename GUM_SCALAR>

gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray

(

const MultiDimBijArray< GUM_SCALAR > &

from

)

Copy constructor.

The newly created matrix contains the same variables and the same values as from, but no instantiation is associated to it.

Parameters

from	The MultiDimBijArray to copy.

Definition at line 56 of file multiDimBijArray_tpl.h.

                                                                                             :
      MultiDimWithOffset< GUM_SCALAR >(), _array_(from._array_), _name_(from._name_) {
    GUM_CONS_CPY(MultiDimBijArray);
 
    for (auto var: from.variablesSequence()) {
      MultiDimWithOffset< GUM_SCALAR >::add(*var);
    }
  }

References MultiDimBijArray(), gum::MultiDimWithOffset< GUM_SCALAR >::MultiDimWithOffset(), _array_, _name_, gum::MultiDimWithOffset< GUM_SCALAR >::add(), and gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Here is the call graph for this function:

~MultiDimBijArray()

template<typename GUM_SCALAR>

INLINE gum::MultiDimBijArray< GUM_SCALAR >::~MultiDimBijArray ( )

virtual

Class destructor.

Definition at line 88 of file multiDimBijArray_tpl.h.

                                                           {
    GUM_DESTRUCTOR(MultiDimBijArray);
  }

References MultiDimBijArray().

Here is the call graph for this function:

Member Function Documentation

_setNotCommitedChange_()

template<typename GUM_SCALAR>

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

privateinherited

Change the internalChangeState to NOT_COMMITTED_CHANGE.

Definition at line 282 of file multiDimImplementation_tpl.h.

                                                                           {
    _internalChangeState_ = _InternalChangeState_::NOT_COMMITTED_CHANGE;
  }

References _internalChangeState_, and NOT_COMMITTED_CHANGE.

add()

template<typename GUM_SCALAR>

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

virtual

This will raise an exception: you can't change the variables in a MultiDimBijArray.

Parameters

v	The variable not added.

Exceptions

OperationNotAllowed

You can't add variable in a MultiDimBijArray.

Reimplemented from gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 109 of file multiDimBijArray_tpl.h.

                                                                           {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

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::MultiDimArray< GUM_SCALAR >, and gum::MultiDimDecorator< GUM_SCALAR >.

Definition at line 205 of file multiDimContainer_tpl.h.

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

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

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

                                                                         {
    _internalChangeMethod_ = _InternalChangeMethod_::MULTIPLE_CHANGE;
  }

References _internalChangeMethod_, and MULTIPLE_CHANGE.

changeNotification()

template<typename GUM_SCALAR>

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

virtualinherited

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 126 of file multiDimWithOffset_tpl.h.

                                                                                                 {
    GUM_ASSERT(offsets_.exists(&i));
    GUM_ASSERT(offsets_[&i] < this->domainSize());
    GUM_ASSERT(newval < var->domainSize());
    GUM_ASSERT(oldval < var->domainSize());
 
    if (newval >= oldval) {
      offsets_[&i] += gaps_[var] * (newval - oldval);
      GUM_ASSERT(offsets_[&i] < this->domainSize());
    } else {
      GUM_ASSERT(offsets_[&i] >= gaps_[var] * (oldval - newval));
      offsets_[&i] -= gaps_[var] * (oldval - newval);
    }
  }

References gum::MultiDimImplementation< GUM_SCALAR >::domainSize(), gaps_, and offsets_.

Here is the call graph for this function:

commitMultipleChanges_() [1/2]

template<typename GUM_SCALAR>

INLINE void gum::MultiDimBijArray< GUM_SCALAR >::commitMultipleChanges_ ( )

protectedvirtual

Synchronize content after MultipleChanges.

Reimplemented from gum::MultiDimImplementation< GUM_SCALAR >.

Definition at line 129 of file multiDimBijArray_tpl.h.

                                                                     {
    // Do nothing
  }

commitMultipleChanges_() [2/2]

template<typename GUM_SCALAR>

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

protectedvirtualinherited

Synchronize content after MultipleChanges.

Parameters

value

Default value for uninitialized values.

Reimplemented in gum::MultiDimArray< GUM_SCALAR >.

Definition at line 258 of file multiDimImplementation_tpl.h.

                                                                                            {
    // empty!
  }

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 ratio, 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 288 of file multiDimImplementation_tpl.h.

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

References domainSize(), and realSize().

Here is the call graph for this function:

computeInstantiationValue_()

template<typename GUM_SCALAR>

INLINE void gum::MultiDimWithOffset< GUM_SCALAR >::computeInstantiationValue_ ( Instantiation & result, Size indice ) const

protectedinherited

For a given index of a value in the vector values, this method computes the corresponding instantiation.

Parameters

result	the result of this methods, we assume that the given instantiation already contains all the variables contained in the MultiDimArray (if V is the set of variables of this tab, V must be a subset of variables in result or the exact set)
indice	The index in the vector values
result	the result of this methods, we assume that the given instantiation already contains all the variables contained in the multidimarray (if V is the set of variables of this tab, V must be a subset of variables in result or the exact set)
indice	indice in the vector values_

Definition at line 256 of file multiDimWithOffset_tpl.h.

                                                                                              {
    for (Idx i = 0; i < this->nbrDim(); ++i) {
      const DiscreteVariable& var        = this->variable(i);
      Idx                     domainSize = var.domainSize();
      result.chgVal(var, indice % domainSize);
      indice = indice / domainSize;
    }
 
    GUM_ASSERT(indice == 0);
  }

References gum::Instantiation::chgVal(), gum::DiscreteVariable::domainSize(), gum::MultiDimImplementation< GUM_SCALAR >::domainSize(), gum::MultiDimImplementation< GUM_SCALAR >::nbrDim(), and gum::MultiDimImplementation< GUM_SCALAR >::variable().

Referenced by fromOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

contains()

template<typename GUM_SCALAR>

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

overridevirtualinherited

Returns true if var is in *this.

Parameters

v	A DiscreteVariable.

Returns

Returns true if var is in *this.

Implements gum::MultiDimInterface.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 208 of file multiDimImplementation_tpl.h.

                                                                                            {
    return _vars_.exists(&v);
  }

Referenced by gum::MultiDimICIModel< GUM_SCALAR >::causalWeight(), and gum::MultiDimBucket< GUM_SCALAR >::contains().

Here is the caller graph for this function:

content() [1/2]

template<typename GUM_SCALAR>

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

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 332 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 325 of file multiDimImplementation_tpl.h.

                                                                                             {
    return this;
  }

References MultiDimImplementation().

Here is the call graph for this function:

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< bool >, gum::MultiDimFunctionGraph< bool, ExactTerminalNodePolicy >, gum::MultiDimFunctionGraph< double >, gum::MultiDimFunctionGraph< double, ExactTerminalNodePolicy >, gum::MultiDimFunctionGraph< gum::ActionSet, gum::SetTerminalNodePolicy >, gum::MultiDimFunctionGraph< GUM_SCALAR, ExactTerminalNodePolicy >, gum::MultiDimFunctionGraph< Size >, and gum::MultiDimFunctionGraph< Size, ExactTerminalNodePolicy >.

Definition at line 288 of file multiDimContainer_tpl.h.

                                                                                       {
    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);
  }

References MultiDimContainer(), beginMultipleChanges(), gum::MultiDimInterface::erase(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variable().

Referenced by gum::TreeRegress< GUM_SCALAR, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy >::compute().

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::MultiDimArray< GUM_SCALAR >, and gum::MultiDimICIModel< GUM_SCALAR >.

Definition at line 271 of file multiDimContainer_tpl.h.

                                                                                                 {
    if (src.domainSize() != domainSize()) {
      GUM_ERROR(OperationNotAllowed,
                "Domain sizes do not fit : " << src.domainSize() << "!=" << domainSize());
    }
 
    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]);
    }
  }

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

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

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 >, and gum::MultiDimFunctionGraph< GUM_SCALAR, ExactTerminalNodePolicy >.

Definition at line 225 of file multiDimContainer_tpl.h.

                                                                                                   {
    if (src.domainSize() != domainSize()) {
      GUM_ERROR(OperationNotAllowed,
                "Domain sizes do not fit : " << src.domainSize() << "!=" << domainSize());
    }
 
    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]);
      }
    }
  }

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

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

                                                                     {
    return _domainSize_;
  }

Referenced by gum::MultiDimArray< GUM_SCALAR >::add(), gum::MultiDimBucket< GUM_SCALAR >::add(), gum::MultiDimWithOffset< GUM_SCALAR >::add(), gum::MultiDimWithOffset< GUM_SCALAR >::changeNotification(), gum::MultiDimArray< GUM_SCALAR >::commitMultipleChanges_(), gum::MultiDimArray< GUM_SCALAR >::commitMultipleChanges_(), gum::MultiDimBucket< GUM_SCALAR >::commitMultipleChanges_(), compressionRate(), gum::MultiDimWithOffset< GUM_SCALAR >::computeInstantiationValue_(), gum::MultiDimArray< GUM_SCALAR >::erase(), gum::MultiDimBucket< GUM_SCALAR >::erase(), gum::aggregator::Sum< GUM_SCALAR >::fold_(), gum::MultiDimArray< GUM_SCALAR >::realSize(), gum::MultiDimBucket< GUM_SCALAR >::setBufferSize(), gum::MultiDimWithOffset< GUM_SCALAR >::setIncNotification(), and gum::MultiDimWithOffset< GUM_SCALAR >::setLastNotification().

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

                                                                {
    GUM_ASSERT(!this->isCommitNeeded_());
    return _vars_.empty();
  }

References _vars_, and isCommitNeeded_().

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

Here is the call graph for this function:

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

                                                                       {
    if (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE) {
      commitMultipleChanges_();
      _internalChangeState_ = _InternalChangeState_::NO_CHANGE;
    }
 
    _internalChangeMethod_ = _InternalChangeMethod_::DIRECT_CHANGE;
  }

References _internalChangeState_, commitMultipleChanges_(), NO_CHANGE, and NOT_COMMITTED_CHANGE.

Here is the call graph for this function:

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

                                                                                          {
    if (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE) {
      commitMultipleChanges_(x);
      _internalChangeState_ = _InternalChangeState_::NO_CHANGE;
    }
 
    _internalChangeMethod_ = _InternalChangeMethod_::DIRECT_CHANGE;
  }

References _internalChangeMethod_, _internalChangeState_, commitMultipleChanges_(), DIRECT_CHANGE, NO_CHANGE, and NOT_COMMITTED_CHANGE.

Here is the call graph for this function:

erase()

template<typename GUM_SCALAR>

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

virtual

This will raise an exception: you can't change the variables in a MultiDimBijArray.

Parameters

v	The variable not added.

Exceptions

OperationNotAllowed

You can't add variable in a MultiDimBijArray.

Reimplemented from gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 114 of file multiDimBijArray_tpl.h.

                                                                             {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

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 Tensor : the

extraction will concern every variable not in the instantiation and the copy of data will use the (relevant) values in this instantiation.

Definition at line 247 of file multiDimContainer_tpl.h.

                                                                                                  {
    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));
    }
 
    this->endMultipleChanges();
 
    if (this->nbrDim() == 0) { GUM_ERROR(FatalError, "Empty tensor") }
 
    Instantiation inst(src);
    inst.setVals(imask);
    for (inst.setFirstOut(imask); !inst.end(); inst.incOut(imask))
      set(inst, src[inst]);
  }

References MultiDimContainer(), and beginMultipleChanges().

Here is the call graph for this function:

fill()

template<typename GUM_SCALAR>

INLINE void gum::MultiDimBijArray< GUM_SCALAR >::fill ( const GUM_SCALAR & d ) const

virtual

This will raise an exception: you can't change the data.

Parameters

d	the value changed

Exceptions

OperationNotAllowed

You can't change data.

Implements gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 124 of file multiDimBijArray_tpl.h.

                                                                            {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

fromOffset()

template<typename GUM_SCALAR>

INLINE Instantiation & gum::MultiDimWithOffset< GUM_SCALAR >::fromOffset ( Instantiation & i, Size offset ) const

inherited

Set the Instantiation to the values corresponding to the offset (in this array).

We assume that the given instantiation already contains all the variables contained in the multidimarray (if V is the set of variables of this tab, V must be a subset of variables in result or the exact set).

Parameters

i	The instantiation i modified giving the offset.
offset	The offset used to compute the value of i.

Returns

Returns a reference over i.

Definition at line 290 of file multiDimWithOffset_tpl.h.

                                                                                                  {
    this->computeInstantiationValue_(i, offset);
    return i;
  }

References computeInstantiationValue_().

Here is the call graph for this function:

get()

template<typename GUM_SCALAR>

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

virtual

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 134 of file multiDimBijArray_tpl.h.

                                                                                    {
    if (i.isMaster(this)) {
      return _array_.values_[this->offsets_[&i]];
    } else {
      return _array_.values_[this->getOffs_(i)];
    }
  }

References _array_, gum::MultiDimWithOffset< GUM_SCALAR >::getOffs_(), gum::Instantiation::isMaster(), and gum::MultiDimWithOffset< GUM_SCALAR >::offsets_.

Here is the call graph for this function:

get_()

template<typename GUM_SCALAR>

INLINE GUM_SCALAR & gum::MultiDimBijArray< GUM_SCALAR >::get_ ( const Instantiation & i ) const

protectedvirtual

Return a data, given a Instantiation.

Note that get allows to change a value in the container. The method is tagged as const since a multidim is not const if its dimension changed.

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	The instantiation used to find the data.

Implements gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 160 of file multiDimBijArray_tpl.h.

                                                                                      {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

getMasterRef() [1/2]

template<typename GUM_SCALAR>

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

virtualinherited

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

Returns

Returns the ref to content as MultiDimAdressable&

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 306 of file multiDimContainer_tpl.h.

                                                                           {
    return static_cast< MultiDimAdressable& >(*content());
  }

References gum::MultiDimAdressable::MultiDimAdressable(), and content().

Here is the call graph for this function:

getMasterRef() [2/2]

template<typename GUM_SCALAR>

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

virtualinherited

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

Returns

Returns the master of this MultiDimAdressable.

Implements gum::MultiDimAdressable.

Reimplemented in gum::MultiDimBucket< GUM_SCALAR >.

Definition at line 311 of file multiDimContainer_tpl.h.

                                                                                       {
    return static_cast< const MultiDimAdressable& >(*content());
  }

References gum::MultiDimAdressable::MultiDimAdressable(), and content().

Here is the call graph for this function:

getOffs_()

template<typename GUM_SCALAR>

INLINE Size gum::MultiDimWithOffset< GUM_SCALAR >::getOffs_ ( const Instantiation & i ) const

protectedinherited

Compute the offset of a Instantiation.

If the instantiation is not fully compatible with the MultiDimWithOffset, no exception thrown but 0 is assumed for dimensions not present in the instantiation.

If the instantiation is not fully compatible with the MultiDimWithOffset, no exception thrown but 0 is assumed for dimensions not present in the instantiation.

for instance : M<

for instance : M<

Definition at line 217 of file multiDimWithOffset_tpl.h.

                                                                                     {
    Idx off = 0;
 
    for (auto iter = gaps_.begin(); iter != gaps_.end(); ++iter)
      if (i.contains(iter.key())) off += iter.val() * i.valFromPtr(iter.key());
      else
        GUM_ERROR(InvalidArgument, iter.key()->name() << " not present in the instantiation " << i)
 
    return off;
  }

References gum::Instantiation::contains(), gaps_, GUM_ERROR, and gum::Instantiation::valFromPtr().

Referenced by gum::MultiDimBijArray< GUM_SCALAR >::get(), gum::MultiDimSparse< GUM_SCALAR >::get(), gum::MultiDimArray< GUM_SCALAR >::get_(), registerSlave(), gum::MultiDimSparse< GUM_SCALAR >::set(), setChangeNotification(), and toOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

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

                                                                          {
    return (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE);
  }

References _internalChangeState_, and NOT_COMMITTED_CHANGE.

Referenced by MultiDimImplementation(), and empty().

Here is the caller graph for this function:

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

                                                                                    {
    return (_internalChangeMethod_ == _InternalChangeMethod_::MULTIPLE_CHANGE);
  }

References _internalChangeMethod_, and MULTIPLE_CHANGE.

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

Here is the caller graph for this function:

name()

template<typename GUM_SCALAR>

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

virtual

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 104 of file multiDimBijArray_tpl.h.

                                                                     {
    return _name_;
  }

References _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 178 of file multiDimImplementation_tpl.h.

                                                                {
    return _vars_.size();
  }

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::aggregator::MultiDimAggregator< GUM_SCALAR >::get(), gum::MultiDimLogit< GUM_SCALAR >::get(), gum::MultiDimNoisyAND< GUM_SCALAR >::get(), gum::MultiDimNoisyORCompound< GUM_SCALAR >::get(), gum::MultiDimNoisyORNet< GUM_SCALAR >::get(), gum::MultiDimICIModel< GUM_SCALAR >::realSize(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString(), gum::MultiDimICIModel< GUM_SCALAR >::toString(), and gum::MultiDimLogit< GUM_SCALAR >::toString().

Here is the caller graph for this function:

newFactory()

template<typename GUM_SCALAR>

INLINE MultiDimBijArray< GUM_SCALAR > * gum::MultiDimBijArray< GUM_SCALAR >::newFactory ( ) const

virtual

Class constructor.

Implements gum::MultiDimWithOffset< GUM_SCALAR >.

Definition at line 99 of file multiDimBijArray_tpl.h.

                                                                                          {
    return new MultiDimBijArray< GUM_SCALAR >(*this);
  }

References MultiDimBijArray().

Here is the call graph for this function:

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 171 of file multiDimContainer_tpl.h.

                                                                                              {
    return !operator==(p);
  }

References MultiDimContainer().

Here is the call graph for this function:

operator=()

template<typename GUM_SCALAR>

MultiDimBijArray< GUM_SCALAR > & gum::MultiDimBijArray< GUM_SCALAR >::operator=

(

const MultiDimBijArray< GUM_SCALAR > &

from

)

Warning

This will raise an exception: read only structure.

Exceptions

OperationNotAllowed

Raised since you can't change a readonly structure.

Definition at line 94 of file multiDimBijArray_tpl.h.

                                                                                        {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray are readonly.")
  }

References MultiDimBijArray(), and GUM_ERROR.

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

                                                                                               {
    if ((nbrDim() == p.nbrDim()) && (domainSize() == p.domainSize())) {
      if (nbrDim() == 0) return true;
 
      for (auto 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;
  }

References MultiDimContainer(), gum::MultiDimInterface::domainSize(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variablesSequence().

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

                                                                                            {
    return get(i);
  }

References get().

Here is the call graph for this function:

populate() [1/2]

template<typename GUM_SCALAR>

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

virtual

This will raise an exception: you can't change the variables in a MultiDimBijArray.

Parameters

v	The variable not added.

Exceptions

OperationNotAllowed

You can't add variable in a MultiDimBijArray.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 149 of file multiDimBijArray_tpl.h.

                                                                                             {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

populate() [2/2]

template<typename GUM_SCALAR>

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

virtual

This will raise an exception: you can't change the variables in a MultiDimBijArray.

Parameters

l	The variable not added.

Exceptions

OperationNotAllowed

You can't add variable in a MultiDimBijArray.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 155 of file multiDimBijArray_tpl.h.

                                                                                        {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

pos()

template<typename GUM_SCALAR>

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

overridevirtualinherited

Returns the index of a variable.

Parameters

v	The variable for which the index is returned.

Returns

Returns the index of a variable.

Exceptions

NotFound

Raised if v is not in this multidimensional matrix.

Implements gum::MultiDimInterface.

Definition at line 203 of file multiDimImplementation_tpl.h.

                                                                                      {
    return _vars_.pos(&v);
  }

References _vars_.

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

Here is the caller graph for this function:

realSize()

template<typename GUM_SCALAR>

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

virtual

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 119 of file multiDimBijArray_tpl.h.

                                                             {
    return (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::MultiDimArray< GUM_SCALAR >, and gum::MultiDimDecorator< GUM_SCALAR >.

Definition at line 214 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

registerSlave()

template<typename GUM_SCALAR>

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

virtualinherited

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 189 of file multiDimWithOffset_tpl.h.

                                                                              {
    if (MultiDimImplementation< GUM_SCALAR >::registerSlave(i)) {
      GUM_ASSERT(!offsets_.exists(&i));
      offsets_.insert(&i, getOffs_(i));
      return true;
    }
 
    return false;
  }

References getOffs_(), offsets_, and gum::MultiDimImplementation< GUM_SCALAR >::registerSlave().

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

                                                                                      {
    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);
  }

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

Here is the call graph for this function:

replace_()

template<typename GUM_SCALAR>

INLINE void gum::MultiDimBijArray< GUM_SCALAR >::replace_ ( const DiscreteVariable * x, const DiscreteVariable * y )

protectedvirtual

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 165 of file multiDimBijArray_tpl.h.

                                                                                  {
    MultiDimImplementation< GUM_SCALAR >::replace_(x, y);
  }

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

Here is the call graph for this function:

set()

template<typename GUM_SCALAR>

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

virtual

Warning

This will raise an exception: read only structure.

Exceptions

OperationNotAllowed

Raised since you can't change a readonly structure.

Reimplemented from gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 143 of file multiDimBijArray_tpl.h.

                                                                                    {
    GUM_ERROR(OperationNotAllowed, "MultiDimBijArray<GUM_SCALAR> are read only.")
  }

References GUM_ERROR.

setChangeNotification()

template<typename GUM_SCALAR>

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

virtualinherited

Listen to an assignment of a value in a Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 147 of file multiDimWithOffset_tpl.h.

                                                                                            {
    GUM_ASSERT(offsets_.exists(&i));
    offsets_[&i] = getOffs_(i);
  }

References getOffs_(), and offsets_.

Here is the call graph for this function:

setDecNotification()

template<typename GUM_SCALAR>

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

virtualinherited

Listen to increment in each recorded Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 180 of file multiDimWithOffset_tpl.h.

                                                                                         {
    GUM_ASSERT(offsets_.exists(&i));
    GUM_ASSERT(offsets_[&i] != 0);
    --offsets_[&i];
  }

References offsets_.

setFirstNotification()

template<typename GUM_SCALAR>

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

virtualinherited

Listen to setFirst in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 155 of file multiDimWithOffset_tpl.h.

                                                                                           {
    GUM_ASSERT(offsets_.exists(&i));
    offsets_[&i] = 0;
  }

References offsets_.

setIncNotification()

template<typename GUM_SCALAR>

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

virtualinherited

Listen to increment in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 171 of file multiDimWithOffset_tpl.h.

                                                                                         {
    GUM_ASSERT(offsets_.exists(&i));
    GUM_ASSERT(offsets_[&i] != this->domainSize() - 1);
    ++offsets_[&i];
  }

References gum::MultiDimImplementation< GUM_SCALAR >::domainSize(), and offsets_.

Here is the call graph for this function:

setLastNotification()

template<typename GUM_SCALAR>

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

virtualinherited

Listen to setLast in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 163 of file multiDimWithOffset_tpl.h.

                                                                                          {
    GUM_ASSERT(offsets_.exists(&i));
    offsets_[&i] = this->domainSize() - 1;
  }

References gum::MultiDimImplementation< GUM_SCALAR >::domainSize(), and offsets_.

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

                                                                                           {
    return _slaveInstantiations_;
  }

References _slaveInstantiations_.

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

Here is the caller graph for this function:

toOffset()

template<typename GUM_SCALAR>

INLINE Size gum::MultiDimWithOffset< GUM_SCALAR >::toOffset ( const Instantiation & i ) const

inherited

Compute offset from an Instantiation (in this array).

If the instantiation is not fully compatible with the MultiDimWithOffset, no exception will be thrown but 0 is assumed for dimensions not present in the instantiation. for instance : M<

Definition at line 283 of file multiDimWithOffset_tpl.h.

                                                                                     {
    return getOffs_(i);
  }

References getOffs_().

Here is the call graph for this function:

toString() [1/2]

template<typename GUM_SCALAR>

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::aggregator::MultiDimAggregator< GUM_SCALAR >, gum::MultiDimDecorator< GUM_SCALAR >, gum::MultiDimICIModel< GUM_SCALAR >, gum::MultiDimLogit< GUM_SCALAR >, gum::MultiDimNoisyAND< GUM_SCALAR >, gum::MultiDimNoisyORCompound< GUM_SCALAR >, gum::MultiDimNoisyORNet< GUM_SCALAR >, and gum::Tensor< GUM_SCALAR >.

Definition at line 123 of file multiDimContainer_tpl.h.

                                                            {
    // 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();
  }

Referenced by gum::operator<<().

Here is the caller graph for this function:

toString() [2/2]

template<typename GUM_SCALAR>

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

virtualinherited

Display the internal representation of i.

Returns

Returns an internal representation of i.

Implements gum::MultiDimContainer< GUM_SCALAR >.

Definition at line 270 of file multiDimWithOffset_tpl.h.

                                                                                          {
    if (i->isMaster(this)) {
      std::stringstream s;
      s << offsets_[i];
      std::string res;
      s >> res;
      return res;
    } else {
      return "--";
    }
  }

References gum::Instantiation::isMaster(), and offsets_.

Here is the call graph for this function:

unregisterSlave()

template<typename GUM_SCALAR>

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

virtualinherited

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 202 of file multiDimWithOffset_tpl.h.

                                                                                {
    MultiDimImplementation< GUM_SCALAR >::unregisterSlave(i);
    offsets_.erase(&i);
    return true;
  }

References offsets_, and gum::MultiDimImplementation< GUM_SCALAR >::unregisterSlave().

Here is the call graph for this function:

variable() [1/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. @warging This function is not O(1)

Exceptions

NotFound

Raised if the element cannot be found.

Implements gum::MultiDimInterface.

Definition at line 194 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.")
  }

variable() [2/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 188 of file multiDimImplementation_tpl.h.

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

References _vars_.

Referenced by gum::aggregator::MultiDimAggregator< GUM_SCALAR >::buildValue_(), gum::MultiDimWithOffset< GUM_SCALAR >::computeInstantiationValue_(), gum::MultiDimICIModel< GUM_SCALAR >::copyFrom(), gum::aggregator::Sum< GUM_SCALAR >::fold_(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::get(), gum::MultiDimLogit< GUM_SCALAR >::get(), gum::MultiDimNoisyAND< GUM_SCALAR >::get(), gum::MultiDimNoisyORCompound< GUM_SCALAR >::get(), gum::MultiDimNoisyORNet< GUM_SCALAR >::get(), gum::aggregator::MultiDimAggregator< GUM_SCALAR >::toString(), gum::MultiDimICIModel< GUM_SCALAR >::toString(), gum::MultiDimLogit< GUM_SCALAR >::toString(), gum::MultiDimNoisyAND< GUM_SCALAR >::toString(), gum::MultiDimNoisyORCompound< GUM_SCALAR >::toString(), and gum::MultiDimNoisyORNet< GUM_SCALAR >::toString().

Here is the caller graph for this function:

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

                                                                             {
    return _vars_;
  }

References _vars_.

Referenced by gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray(), gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray(), gum::MultiDimBijArray< GUM_SCALAR >::MultiDimBijArray(), gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_distance_(), gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_findRetrogradeVariables_(), gum::Regress< GUM_SCALAR, COMBINEOPERATOR, PROJECTOPERATOR, TerminalNodePolicy >::_findRetrogradeVariables_(), gum::MultiDimBucket< GUM_SCALAR >::_initializeBuffer_(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::add(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::clear(), gum::prm::copyTensor(), gum::MultiDimArray< GUM_SCALAR >::erase(), gum::MultiDimWithOffset< GUM_SCALAR >::erase(), gum::MultiDimFunctionGraphGenerator::generate(), gum::MDDOperatorStrategy< GUM_SCALAR >::lastVar_(), gum::StructuredPlaner< GUM_SCALAR >::makeArgMax_(), gum::TreeOperatorStrategy< GUM_SCALAR >::regress(), and gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::varNodeListe().

Here is the caller graph for this function:

Member Data Documentation

_array_

template<typename GUM_SCALAR>

const MultiDimArray< GUM_SCALAR >& gum::MultiDimBijArray< GUM_SCALAR >::_array_

private

The true data.

Definition at line 196 of file multiDimBijArray.h.

Referenced by MultiDimBijArray(), MultiDimBijArray(), MultiDimBijArray(), and get().

_domainSize_

template<typename GUM_SCALAR>

Size gum::MultiDimImplementation< GUM_SCALAR >::_domainSize_

privateinherited

This MultiDimImplementation domain size.

Definition at line 307 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), and erase().

_internalChangeMethod_

template<typename GUM_SCALAR>

_InternalChangeMethod_ gum::MultiDimImplementation< GUM_SCALAR >::_internalChangeMethod_

privateinherited

The current change method.

Definition at line 301 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), beginMultipleChanges(), endMultipleChanges(), and isInMultipleChangeMethod_().

_internalChangeState_

template<typename GUM_SCALAR>

_InternalChangeState_ gum::MultiDimImplementation< GUM_SCALAR >::_internalChangeState_

privateinherited

The current change state.

Definition at line 304 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), _setNotCommitedChange_(), endMultipleChanges(), endMultipleChanges(), and isCommitNeeded_().

_name_

template<typename GUM_SCALAR>

std::string gum::MultiDimBijArray< GUM_SCALAR >::_name_

private

The class name.

Definition at line 199 of file multiDimBijArray.h.

Referenced by MultiDimBijArray(), MultiDimBijArray(), MultiDimBijArray(), and name().

_slaveInstantiations_

template<typename GUM_SCALAR>

List< Instantiation* > gum::MultiDimImplementation< GUM_SCALAR >::_slaveInstantiations_

privateinherited

List of instantiations of the tuples (sequences) of variables.

Definition at line 292 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), ~MultiDimImplementation(), erase(), replace_(), and slaves_().

_vars_

template<typename GUM_SCALAR>

Sequence< const DiscreteVariable* > gum::MultiDimImplementation< GUM_SCALAR >::_vars_

privateinherited

List of discrete variables (dimensions).

Definition at line 289 of file multiDimImplementation.h.

Referenced by MultiDimImplementation(), MultiDimImplementation(), empty(), erase(), pos(), registerSlave(), replace_(), variable(), and variablesSequence().

gaps_

template<typename GUM_SCALAR>

HashTable< const DiscreteVariable*, Size > gum::MultiDimWithOffset< GUM_SCALAR >::gaps_

protectedinherited

The gaps between consecutive values of a given variable.

For each variable, we keep track of the interval between two consecutive values of the variable in vector values. Thus, shifting from one value to the next one is equivalent to incrementing/decrementing by gaps the current offset w.r.t. vector values.

Definition at line 200 of file multiDimWithOffset.h.

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

offsets_

template<typename GUM_SCALAR>

HashTable< const Instantiation*, Size > gum::MultiDimWithOffset< GUM_SCALAR >::offsets_

protectedinherited

The position in the array of each slave Instantiation.

Definition at line 203 of file multiDimWithOffset.h.

Referenced by changeNotification(), gum::MultiDimBijArray< GUM_SCALAR >::get(), gum::MultiDimSparse< GUM_SCALAR >::get(), gum::MultiDimArray< GUM_SCALAR >::get_(), registerSlave(), gum::MultiDimSparse< GUM_SCALAR >::set(), setChangeNotification(), setDecNotification(), setFirstNotification(), setIncNotification(), setLastNotification(), toString(), and unregisterSlave().

---

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

• agrum/base/multidim/implementations/multiDimArray.h
• agrum/base/multidim/implementations/multiDimBijArray.h
• agrum/base/multidim/implementations/multiDimBijArray_tpl.h