Multidimensional matrix stored as an array in memory. More...

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

Inheritance diagram for gum::MultiDimArray< GUM_ELEMENT >:

Collaboration diagram for gum::MultiDimArray< GUM_ELEMENT >:

Public Member Functions
Constructors, destructors and copy
	MultiDimArray ()
	Default constructor.
	MultiDimArray (const MultiDimArray< GUM_ELEMENT > &src)
	Copy constructor.
	~MultiDimArray () override
	Copy operator.
MultiDimContainer< GUM_ELEMENT > *	newFactory () const override
	Default constructor.
Inherited methods
}
void	copyFrom (const MultiDimContainer< GUM_ELEMENT > &src) const override
	Copy from a other MultiDimContainer.
void	apply (std::function< GUM_ELEMENT(GUM_ELEMENT) > f) const override
	Apply a function on every element of the container.
GUM_ELEMENT	reduce (std::function< GUM_ELEMENT(GUM_ELEMENT, GUM_ELEMENT) > f, GUM_ELEMENT base) const override
	compute lfold for this container
void	add (const DiscreteVariable &v) override
	Adds a variable.
void	erase (const DiscreteVariable &v) override
	Removes a variable.
Size	realSize () const override
	Returns the real size of this MultiDimArray.
void	fill (const GUM_ELEMENT &d) const override
	Fills the MultiDimArray with the given value.
const std::string &	name () const override
	Returns the MultiDimArray name.
Accessors / Modifiers
const GUM_ELEMENT &	unsafeGet (Idx offset) const
	Returns the element stored in the multidimArray at a given offset.
const GUM_ELEMENT &	getByOffset (Idx offset) const
	Returns the element stored in the multidimArray at a given offset.
void	unsafeSet (Idx offset, const GUM_ELEMENT &val)
	Modifies the element stored in the multidimArray at a given offset.
void	setByOffset (Idx offset, const GUM_ELEMENT &val)
	Modifies the element stored in the multidimArray at a given offset.
const GUM_ELEMENT *	data () const noexcept override
	Returns a pointer to the contiguous data buffer.
GUM_ELEMENT *	data () noexcept override
	Returns a mutable pointer to the contiguous data buffer.
Accessors and modifiers
std::string	toString (const Instantiation *i) const override
	Display the internal representation of i.
void	changeNotification (const Instantiation &i, const DiscreteVariable *const var, Idx oldval, Idx newval) override
	Listen to changes in a given Instantiation.
void	setChangeNotification (const Instantiation &i) override
	Listen to an assignment of a value in a Instantiation.
void	setFirstNotification (const Instantiation &i) override
	Listen to setFirst in a given Instantiation.
void	setLastNotification (const Instantiation &i) override
	Listen to setLast in a given Instantiation.
void	setIncNotification (const Instantiation &i) override
	Listen to increment in a given Instantiation.
void	setDecNotification (const Instantiation &i) override
	Listen to increment in each recorded Instantiation.
bool	registerSlave (Instantiation &i) override
	Register i as a slave of this MultiDimAdressable.
bool	unregisterSlave (Instantiation &i) override
	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_ELEMENT > &p) const
	Test if this MultiDimContainer is equal to p.
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
Idx	nbrDim () const override
	Returns the number of vars in the multidimensional container.
Size	domainSize () const override
	Returns the product of the variables domain size.
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 (std::string_view name) const override
	Returns the variable with the name.
Idx	pos (const DiscreteVariable &v) const override
	Returns the index of a variable.
bool	contains (const DiscreteVariable &v) const override
	Returns true if var is in *this.
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_ELEMENT &) override
	Call this method after doing important changes in this MultiDimContainer.
Accessors / Modifiers
virtual void	set (const Instantiation &i, const GUM_ELEMENT &value) const
	Changes the value pointed by i.
virtual GUM_ELEMENT	get (const Instantiation &i) const
	Returns the value pointed by i.
GUM_ELEMENT	operator[] (const Instantiation &i) const
	An [] operator using a Instantiation as argument.
virtual void	populate (const std::vector< GUM_ELEMENT > &v) const
	Automatically fills this MultiDimContainer with the values in v.
virtual void	populate (std::initializer_list< GUM_ELEMENT > l) const
	Automatically fills this MultiDimContainer with the values in l.
Copy methods.
virtual void	copyFrom (const MultiDimContainer< GUM_ELEMENT > &src, Instantiation *p_i) const
	Basic copy of a MultiDimContainer.
virtual void	extractFrom (const MultiDimContainer< GUM_ELEMENT > &src, const Instantiation &mask)
	Basic extraction of a MultiDimContainer.
MultiDimAdressable &	getMasterRef () override
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer.
const MultiDimAdressable &	getMasterRef () const override
	In order to insure the dereference for decorators, we need to virtualize the access to master pointer.
virtual void	copy (const MultiDimContainer< GUM_ELEMENT > &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
void	commitMultipleChanges_ () final
	Synchronize content after MultipleChanges.
void	commitMultipleChanges_ (const GUM_ELEMENT &) final
	Synchronize content after MultipleChanges.
GUM_ELEMENT &	get_ (const Instantiation &i) const final
	Return a data, given a Instantiation.
void	replace_ (const DiscreteVariable x, const DiscreteVariable y) final
	This is called by MultiDimContainer::replace() to proceed with the replacing between x and 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.
const MultiDimImplementation< GUM_ELEMENT > *	content () const final
	Returns the implementation for this object (may be *this).
MultiDimImplementation< GUM_ELEMENT > *	content () final
	Returns the implementation for this object (may be *this).
Fast large modifications in structures
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
std::vector< GUM_ELEMENT >	values_
	The true data : the values is mutable since we can change the value / in a const multiDimArray.
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
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.

Friends
template<typename GUM_ELEMENTBIS>
class	MultiDimBijArray

Detailed Description

template<typename GUM_ELEMENT>
class gum::MultiDimArray< GUM_ELEMENT >

Multidimensional matrix stored as an array in memory.

Template Parameters

GUM_ELEMENT The type of the scalars stroed in the multidimensional table.

Definition at line 75 of file multiDimArray.h.

Member Enumeration Documentation

◆ _InternalChangeMethod_

template<typename GUM_ELEMENT>

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

317: char { DIRECT_CHANGE, MULTIPLE_CHANGE };

◆ _InternalChangeState_

template<typename GUM_ELEMENT>

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 320 of file multiDimImplementation.h.

320: char { NO_CHANGE, NOT_COMMITTED_CHANGE };

Constructor & Destructor Documentation

◆ MultiDimArray() [1/2]

template<typename GUM_SCALAR>

gum::MultiDimArray< GUM_SCALAR >::MultiDimArray ( )

Default constructor.

Creates an empty null dimensional matrix

Definition at line 58 of file multiDimArray_tpl.h.

                                             : MultiDimWithOffset< GUM_SCALAR >() {
    // for debugging purposes
    GUM_CONSTRUCTOR(MultiDimArray);
  }

References MultiDimArray(), and gum::MultiDimWithOffset< GUM_ELEMENT >::MultiDimWithOffset().

Referenced by MultiDimArray(), MultiDimArray(), ~MultiDimArray(), commitMultipleChanges_(), copyFrom(), and newFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MultiDimArray() [2/2]

template<typename GUM_ELEMENT>

gum::MultiDimArray< GUM_ELEMENT >::MultiDimArray ( const MultiDimArray< GUM_ELEMENT > & src )

Copy constructor.

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

Parameters

src	The MultiDimArray to copy.

References MultiDimArray(), and data().

Here is the call graph for this function:

◆ ~MultiDimArray()

template<typename GUM_SCALAR>

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

override

Copy operator.

Todo: : operator= for MultiDimArray

Parameters

src	The MultiDimArray to copy.

Returns: Returns this MultiDimArray. MultiDimArray<GUM_ELEMENT>& operator=( const MultiDimArray<GUM_ELEMENT>& src );

Class destructor.

Note that, when the multidimensional array is removed src memory, its variables are not removed as well.

Definition at line 73 of file multiDimArray_tpl.h.

                                              {
    // for debugging purposes
    GUM_DESTRUCTOR(MultiDimArray);
    // no need to unregister all slaves as it will be done by MultiDimWithOffset
  }

References MultiDimArray().

Here is the call graph for this function:

Member Function Documentation

◆ _setNotCommitedChange_()

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::_setNotCommitedChange_ ( )

privateinherited

Change the internalChangeState to NOT_COMMITTED_CHANGE.

Definition at line 286 of file multiDimImplementation_tpl.h.

                                                                     {
    _internalChangeState_ = _InternalChangeState_::NOT_COMMITTED_CHANGE;
  }

References _internalChangeState_, and NOT_COMMITTED_CHANGE.

◆ add()

template<typename GUM_SCALAR>

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

overridevirtual

Adds a variable.

Implements gum::MultiDimInterface.

Definition at line 112 of file multiDimArray_tpl.h.

                                                                 {
    Size lg = MultiDimWithOffset< GUM_SCALAR >::domainSize();
    MultiDimWithOffset< GUM_SCALAR >::add(v);
 
    if (!this->isInMultipleChangeMethod_()) { values_.resize(lg * v.domainSize()); }
  }

References gum::MultiDimWithOffset< GUM_ELEMENT >::add(), gum::DiscreteVariable::domainSize(), gum::MultiDimImplementation< GUM_ELEMENT >::domainSize(), gum::MultiDimImplementation< GUM_ELEMENT >::isInMultipleChangeMethod_(), and values_.

Here is the call graph for this function:

◆ apply()

template<typename GUM_ELEMENT>

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

overridevirtual

Apply a function on every element of the container.

Parameters

f	the function to apply

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 89 of file multiDimArray_tpl.h.

                                                                                       {
    std::transform(values_.begin(), values_.end(), values_.begin(), f);
  }

References values_.

◆ basename()

template<typename GUM_ELEMENT>

const std::string & gum::MultiDimImplementation< GUM_ELEMENT >::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 298 of file multiDimImplementation_tpl.h.

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

◆ beginMultipleChanges()

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::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_ELEMENT >.

Definition at line 232 of file multiDimImplementation_tpl.h.

                                                                   {
    _internalChangeMethod_ = _InternalChangeMethod_::MULTIPLE_CHANGE;
  }

References _internalChangeMethod_, and MULTIPLE_CHANGE.

◆ changeNotification()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

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 127 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_ELEMENT >::domainSize(), gaps_, and offsets_.

Here is the call graph for this function:

◆ commitMultipleChanges_() [1/2]

template<typename GUM_SCALAR>

void gum::MultiDimArray< GUM_SCALAR >::commitMultipleChanges_ ( )

finalprotectedvirtual

Synchronize content after MultipleChanges.

Reimplemented from gum::MultiDimImplementation< GUM_ELEMENT >.

Definition at line 166 of file multiDimArray_tpl.h.

                                                           {
    if (MultiDimWithOffset< GUM_SCALAR >::domainSize() != values_.size()) {
      values_.resize(MultiDimWithOffset< GUM_SCALAR >::domainSize());
    }
  }

References gum::MultiDimImplementation< GUM_ELEMENT >::domainSize(), and values_.

Referenced by commitMultipleChanges_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ commitMultipleChanges_() [2/2]

template<typename GUM_ELEMENT>

void gum::MultiDimArray< GUM_ELEMENT >::commitMultipleChanges_ ( const GUM_ELEMENT & value )

finalprotectedvirtual

Synchronize content after MultipleChanges.

Parameters

value Default value for uninitialized values.

Reimplemented from gum::MultiDimImplementation< GUM_ELEMENT >.

References MultiDimArray(), commitMultipleChanges_(), get_(), and replace_().

Here is the call graph for this function:

◆ compressionRate()

template<typename GUM_ELEMENT>

float gum::MultiDimImplementation< GUM_ELEMENT >::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 292 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_ELEMENT>

void gum::MultiDimWithOffset< GUM_ELEMENT >::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_ELEMENT >::domainSize(), gum::MultiDimImplementation< GUM_ELEMENT >::nbrDim(), and gum::MultiDimImplementation< GUM_ELEMENT >::variable().

Referenced by fromOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contains()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::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.

Definition at line 212 of file multiDimImplementation_tpl.h.

                                                                                      {
    return _vars_.exists(&v);
  }

References _vars_.

Referenced by gum::MultiDimBucket< GUM_ELEMENT >::contains().

Here is the caller graph for this function:

◆ content() [1/2]

template<typename GUM_ELEMENT>

const MultiDimImplementation< GUM_ELEMENT > * gum::MultiDimImplementation< GUM_ELEMENT >::content ( ) const

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 335 of file multiDimImplementation_tpl.h.

                                                           {
    return this;
  }

◆ content() [2/2]

template<typename GUM_ELEMENT>

MultiDimImplementation< GUM_ELEMENT > * gum::MultiDimImplementation< GUM_ELEMENT >::content ( )

finalprotectedvirtualinherited

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

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 328 of file multiDimImplementation_tpl.h.

                                                                                        {
    return this;
  }

References MultiDimImplementation().

Here is the call graph for this function:

◆ copy()

template<typename GUM_ELEMENT>

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

virtualinherited

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

Parameters

src	The MultiDimContainer to copy.

Definition at line 284 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(), gum::MultiDimInterface::add(), beginMultipleChanges(), endMultipleChanges(), gum::MultiDimInterface::erase(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variable().

Referenced by gum::TreeRegress< GUM_ELEMENT, 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_ELEMENT>

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

overridevirtual

Copy from a other MultiDimContainer.

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 80 of file multiDimArray_tpl.h.

                                                                                             {
    if (auto mda = dynamic_cast< const MultiDimArray< GUM_SCALAR >* >(&src)) {
      values_ = mda->values_;
    } else {
      MultiDimContainer< GUM_SCALAR >::copyFrom(src);
    }
  }

References MultiDimArray(), gum::MultiDimContainer< GUM_ELEMENT >::copyFrom(), and values_.

Here is the call graph for this function:

◆ copyFrom() [2/2]

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::copyFrom	(	const MultiDimContainer< GUM_ELEMENT > &	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_ELEMENT, TerminalNodePolicy >, and gum::MultiDimFunctionGraph< GUM_ELEMENT, ExactTerminalNodePolicy >.

Definition at line 220 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(), gum::Instantiation::end(), GUM_ERROR, and gum::Instantiation::setFirst().

Here is the call graph for this function:

◆ data() [1/2]

template<typename GUM_SCALAR>

const GUM_SCALAR * gum::MultiDimArray< GUM_SCALAR >::data ( ) const

overridevirtualnoexcept

Returns a pointer to the contiguous data buffer.

Returns: Pointer to the first element of values_.

Reimplemented from gum::MultiDimImplementation< GUM_ELEMENT >.

Definition at line 232 of file multiDimArray_tpl.h.

                                                                     {
    return values_.data();
  }

References values_.

Referenced by MultiDimArray(), and setByOffset().

Here is the caller graph for this function:

◆ data() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR * gum::MultiDimArray< GUM_SCALAR >::data ( )

overridevirtualnoexcept

Returns a mutable pointer to the contiguous data buffer.

Returns: Pointer to the first element of values_.

Reimplemented from gum::MultiDimImplementation< GUM_ELEMENT >.

Definition at line 237 of file multiDimArray_tpl.h.

                                                         {
    return values_.data();
  }

References values_.

◆ domainSize()

template<typename GUM_ELEMENT>

Size gum::MultiDimImplementation< GUM_ELEMENT >::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 187 of file multiDimImplementation_tpl.h.

                                                               {
    return _domainSize_;
  }

References _domainSize_.

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

Here is the caller graph for this function:

◆ empty()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::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 226 of file multiDimImplementation_tpl.h.

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

References _vars_, and isCommitNeeded_().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ endMultipleChanges() [1/2]

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::endMultipleChanges ( )

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 237 of file multiDimImplementation_tpl.h.

                                                                 {
    if (_internalChangeState_ == _InternalChangeState_::NOT_COMMITTED_CHANGE) {
      commitMultipleChanges_();
      _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:

◆ endMultipleChanges() [2/2]

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Call this method after doing important changes in this MultiDimContainer.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 247 of file multiDimImplementation_tpl.h.

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

◆ erase()

template<typename GUM_SCALAR>

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

overridevirtual

Removes a variable.

Implements gum::MultiDimInterface.

Definition at line 121 of file multiDimArray_tpl.h.

                                                                   {
    Sequence< const DiscreteVariable* > variables = this->variablesSequence();
    Idx                                 pos = variables.pos(&v);   // throw a NotFound if necessary
 
    if (variables.size() == 1) {
      if (!this->isInMultipleChangeMethod_()) values_.clear();
    } else {
      Size v_size = v.domainSize();
      Size size   = this->domainSize();
      // here, the variable does belong to the array.
      // => if pos = variables.size() - 1 then we just have to extract the
      // beginning of the array (actually the first gap of variable v)
      // if pos = 0, then copy every element whose index is a multiple of |v|
      // Assume now that pos != 0 and pos != variables.size() - 1, then
      // let w be the next variable in the set of variables of the array.
      // Then we must copy |gap(v)| elements every |gap(w)| elements
 
      if (!this->isInMultipleChangeMethod_()) {
        if (pos != variables.size() - 1) {
          Size gap_v = this->gaps_[variables[pos]];
          Size gap_w = this->gaps_[variables[pos + 1]];
 
          for (Idx i = 0, j = 0; i < size; i += gap_w) {
            Idx last = i + gap_v;
 
            for (Idx k = i; k < last; ++k, ++j)
              values_[j] = values_[k];
          }
        }
 
        // shrink values_
        values_.resize(size / v_size);
      }
    }
 
    MultiDimWithOffset< GUM_SCALAR >::erase(v);
  }

References gum::DiscreteVariable::domainSize(), gum::MultiDimImplementation< GUM_ELEMENT >::domainSize(), gum::MultiDimWithOffset< GUM_ELEMENT >::erase(), gum::MultiDimWithOffset< GUM_ELEMENT >::gaps_, gum::MultiDimImplementation< GUM_ELEMENT >::isInMultipleChangeMethod_(), gum::MultiDimImplementation< GUM_ELEMENT >::pos(), gum::SequenceImplementation< Key, Gen >::pos(), gum::SequenceImplementation< Key, Gen >::size(), values_, and gum::MultiDimImplementation< GUM_ELEMENT >::variablesSequence().

Here is the call graph for this function:

◆ extractFrom()

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::extractFrom	(	const MultiDimContainer< GUM_ELEMENT > &	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 242 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(), beginMultipleChanges(), gum::MultiDimInterface::erase(), gum::MultiDimInterface::nbrDim(), and gum::MultiDimInterface::variable().

Here is the call graph for this function:

◆ fill()

template<typename GUM_ELEMENT>

void gum::MultiDimArray< GUM_SCALAR >::fill ( const GUM_ELEMENT & d ) const

overridevirtual

Fills the MultiDimArray with the given value.

Implements gum::MultiDimWithOffset< GUM_ELEMENT >.

Definition at line 182 of file multiDimArray_tpl.h.

                                                                  {
    if (!this->empty()) std::fill(values_.begin(), values_.end(), d);
  }

References gum::MultiDimImplementation< GUM_ELEMENT >::empty(), and values_.

Here is the call graph for this function:

◆ fromOffset()

template<typename GUM_ELEMENT>

Instantiation & gum::MultiDimWithOffset< GUM_ELEMENT >::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 286 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_ELEMENT>

GUM_ELEMENT gum::MultiDimContainer< GUM_ELEMENT >::get ( const Instantiation & i ) const

virtualinherited

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.

Definition at line 118 of file multiDimContainer_tpl.h.

                                                                                {
    return get_(i);
  }

References get_().

Referenced by apply(), and operator[]().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_()

template<typename GUM_SCALAR>

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

finalprotectedvirtual

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

Definition at line 102 of file multiDimArray_tpl.h.

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

References gum::MultiDimWithOffset< GUM_ELEMENT >::getOffs_(), gum::Instantiation::isMaster(), gum::MultiDimWithOffset< GUM_ELEMENT >::offsets_, and values_.

Referenced by commitMultipleChanges_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getByOffset()

template<typename GUM_SCALAR>

const GUM_SCALAR & gum::MultiDimArray< GUM_SCALAR >::getByOffset ( Idx offset ) const

Returns the element stored in the multidimArray at a given offset.

The offset is computed as follows: let S={X1,...,Xk} be the sequence of variables in the multidim, and let x1,...,xk be their values respectively. then the corresponding offset is x1 + |X1| * x2 + [X1| * |X2| * x3 + ... This thus corresponds to the internal MultiDimArray's offset we would get by using function get with instantiation {x1,...,xk}.

Parameters

offset The offset of the returned value.

Returns the element stored in the multidimArray at a given offset.

Exceptions

OutOfBounds Raised if the referenced element does not belong to the MultiDimArray.

Definition at line 205 of file multiDimArray_tpl.h.

                                                                             {
    if (offset >= values_.size()) { GUM_ERROR(OutOfBounds, "offset too large") }
 
    return values_[offset];
  }

References GUM_ERROR, and values_.

◆ getMasterRef() [1/2]

template<typename GUM_ELEMENT>

const MultiDimAdressable & gum::MultiDimContainer< GUM_ELEMENT >::getMasterRef ( ) const

overridevirtualinherited

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.

Definition at line 307 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:

◆ getMasterRef() [2/2]

template<typename GUM_ELEMENT>

MultiDimAdressable & gum::MultiDimContainer< GUM_ELEMENT >::getMasterRef ( )

overridevirtualinherited

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.

Definition at line 302 of file multiDimContainer_tpl.h.

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

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

Here is the call graph for this function:

◆ getOffs_()

template<typename GUM_ELEMENT>

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

protectedinherited

Compute the offset of a Instantiation.

If a variable present in the MultiDimWithOffset is missing from the instantiation, throws InvalidArgument.

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<

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_ELEMENT >::get(), gum::MultiDimSparse< GUM_ELEMENT >::get(), gum::MultiDimArray< GUM_ELEMENT >::get_(), registerSlave(), gum::MultiDimSparse< GUM_ELEMENT >::set(), setChangeNotification(), and toOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invert_()

template<typename GUM_ELEMENT>

void gum::MultiDimImplementation< GUM_ELEMENT >::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);
  }

References _vars_.

◆ isCommitNeeded_()

template<typename GUM_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::isCommitNeeded_ ( ) const

protectedinherited

Get the actual state of *this.

Returns: Returns true if a commit is needed.

Definition at line 274 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_ELEMENT>

bool gum::MultiDimImplementation< GUM_ELEMENT >::isInMultipleChangeMethod_ ( ) const

protectedinherited

Get the actual change method of this MultiDimImplementation.

Returns: Returns true if in multiple changes.

Definition at line 268 of file multiDimImplementation_tpl.h.

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

References _internalChangeMethod_, and MULTIPLE_CHANGE.

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

Here is the caller graph for this function:

◆ name()

template<typename GUM_SCALAR>

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

overridevirtual

Returns the MultiDimArray name.

Implements gum::MultiDimImplementation< GUM_ELEMENT >.

Definition at line 220 of file multiDimArray_tpl.h.

                                                           {
    // Here, this initialization is thread-safe due to Meyer’s Singleton property
    static const std::string str("MultiDimArray");
    return str;
  }

◆ nbrDim()

template<typename GUM_ELEMENT>

Idx gum::MultiDimImplementation< GUM_ELEMENT >::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 182 of file multiDimImplementation_tpl.h.

                                                          {
    return _vars_.size();
  }

References _vars_.

Referenced by gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::buildValue_(), gum::MultiDimWithOffset< GUM_ELEMENT >::computeInstantiationValue_(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::get(), gum::MultiDimICIModel< GUM_ELEMENT >::realSize(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::toString(), and gum::MultiDimICIModel< GUM_ELEMENT >::toString().

Here is the caller graph for this function:

◆ newFactory()

template<typename GUM_SCALAR>

MultiDimContainer< GUM_SCALAR > * gum::MultiDimArray< GUM_SCALAR >::newFactory ( ) const

nodiscardoverridevirtual

Default constructor.

Creates an empty null dimensional matrix

Implements gum::MultiDimWithOffset< GUM_ELEMENT >.

Definition at line 188 of file multiDimArray_tpl.h.

                                                                                 {
    return new MultiDimArray< GUM_SCALAR >;
  }

References MultiDimArray().

Here is the call graph for this function:

◆ operator==()

template<typename GUM_ELEMENT>

bool gum::MultiDimContainer< GUM_ELEMENT >::operator== ( const MultiDimContainer< GUM_ELEMENT > & 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 148 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_ELEMENT > 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_ELEMENT>

GUM_ELEMENT gum::MultiDimContainer< GUM_ELEMENT >::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_ELEMENT) value.

Definition at line 103 of file multiDimContainer_tpl.h.

                                                                                       {
    return get(i);
  }

References get().

Here is the call graph for this function:

◆ populate() [1/2]

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::populate ( const std::vector< GUM_ELEMENT > & 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.

Definition at line 172 of file multiDimContainer_tpl.h.

                                                                                         {
    if (domainSize() != v.size()) {
      GUM_ERROR(SizeError, "Sizes do not match : " << domainSize() << "!=" << v.size())
    }
 
    Size cpt = 0;
 
    Instantiation i(*this);
 
    for (i.setFirst(); !i.end(); ++i, ++cpt)
      set(i, v[cpt]);
  }

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByLines().

Here is the caller graph for this function:

◆ populate() [2/2]

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::populate ( std::initializer_list< GUM_ELEMENT > 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_ELEMENT >, and gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >.

Definition at line 186 of file multiDimContainer_tpl.h.

                                                                                            {
    if (domainSize() != l.size()) {
      GUM_ERROR(SizeError, "Sizes do not match : " << domainSize() << "!=" << l.size())
    }
 
    Instantiation i(*this);
    // insert all the elements
    for (const auto& elt: l) {
      set(i, elt);
      ++i;
    }
  }

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

Here is the call graph for this function:

◆ pos()

template<typename GUM_ELEMENT>

Idx gum::MultiDimImplementation< GUM_ELEMENT >::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 207 of file multiDimImplementation_tpl.h.

                                                                                {
    return _vars_.pos(&v);
  }

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

Here is the caller graph for this function:

◆ realSize()

template<typename GUM_SCALAR>

Size gum::MultiDimArray< GUM_SCALAR >::realSize ( ) const

overridevirtual

Returns the real size of this MultiDimArray.

Implements gum::MultiDimImplementation< GUM_ELEMENT >.

Definition at line 160 of file multiDimArray_tpl.h.

                                                   {
    return this->domainSize();
  }

References gum::MultiDimImplementation< GUM_ELEMENT >::domainSize().

Here is the call graph for this function:

◆ reduce()

template<typename GUM_ELEMENT>

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

overridevirtual

compute lfold for this container

Parameters

f	the function to apply
base	the initial value

Reimplemented from gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 95 of file multiDimArray_tpl.h.

                                                                 {
    return std::accumulate(values_.begin(), values_.end(), base, f);
  }

References values_.

◆ registerSlave()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

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

Definition at line 190 of file multiDimWithOffset_tpl.h.

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

References getOffs_(), offsets_, and gum::MultiDimImplementation< GUM_ELEMENT >::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 57 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>

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

finalprotectedvirtual

This is called by MultiDimContainer::replace() to proceed with the replacing between x and y.

This is called only when everything have been checked.

Parameters

x	The variable to replace in
y	The second variable to swap.

Implements gum::MultiDimInterface.

Definition at line 227 of file multiDimArray_tpl.h.

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

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

Referenced by commitMultipleChanges_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set()

template<typename GUM_ELEMENT>

void gum::MultiDimContainer< GUM_ELEMENT >::set	(	const Instantiation &	i,
		const GUM_ELEMENT &	value ) const

virtualinherited

Changes 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 prensent in the instantiation.

Parameters

i	An Instantiation of this MultiDimContainer.
value	The new value.

Definition at line 110 of file multiDimContainer_tpl.h.

                                                                               {
    get_(i) = value;
  }

References get_().

Referenced by apply(), copyFrom(), and populate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setByOffset()

template<typename GUM_ELEMENT>

void gum::MultiDimArray< GUM_SCALAR >::setByOffset	(	Idx	offset,
		const GUM_ELEMENT &	val )

Modifies the element stored in the multidimArray at a given offset.

The offset is computed as follows: let S={X1,...,Xk} be the sequence of variables in the multidim, and let x1,...,xk be their values respectively. then the corresponding offset is x1 + |X1| * x2 + [X1| * |X2| * x3 + ... This thus corresponds to the internal MultiDimArray's offset we would get by using function get with instantiation {x1,...,xk}.

Parameters

offset	The offset where to store the value.
val	The value to store.

Exceptions

OutOfBounds Raised if the referenced element does not belong to the MultiDimArray.

Definition at line 212 of file multiDimArray_tpl.h.

                                                                                  {
    if (offset >= values_.size()) { GUM_ERROR(OutOfBounds, "offset too large") }
 
    values_[offset] = data;
  }

References data(), GUM_ERROR, and values_.

Here is the call graph for this function:

◆ setChangeNotification()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Listen to an assignment of a value in a Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 148 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_ELEMENT>

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

overridevirtualinherited

Listen to increment in each recorded Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 181 of file multiDimWithOffset_tpl.h.

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

References offsets_.

◆ setFirstNotification()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Listen to setFirst in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 156 of file multiDimWithOffset_tpl.h.

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

References offsets_.

◆ setIncNotification()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Listen to increment in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 172 of file multiDimWithOffset_tpl.h.

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

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

Here is the call graph for this function:

◆ setLastNotification()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Listen to setLast in a given Instantiation.

Parameters

i	The Instantiation to listen.

Implements gum::MultiDimAdressable.

Definition at line 164 of file multiDimWithOffset_tpl.h.

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

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

Here is the call graph for this function:

◆ slaves_()

template<typename GUM_ELEMENT>

const List< Instantiation * > & gum::MultiDimImplementation< GUM_ELEMENT >::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 280 of file multiDimImplementation_tpl.h.

                                                                                     {
    return _slaveInstantiations_;
  }

References _slaveInstantiations_.

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

Here is the caller graph for this function:

◆ toOffset()

template<typename GUM_ELEMENT>

Size gum::MultiDimWithOffset< GUM_ELEMENT >::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 279 of file multiDimWithOffset_tpl.h.

                                                                               {
    return getOffs_(i);
  }

References getOffs_().

Here is the call graph for this function:

◆ toString() [1/2]

template<typename GUM_ELEMENT>

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

virtualinherited

Returns a representation of this MultiDimContainer.

Returns: Returns a representation of this MultiDimContainer.

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

Definition at line 125 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();
  }

References gum::MultiDimInterface::nbrDim().

Referenced by gum::MultiDimContainer< double >::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toString() [2/2]

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Display the internal representation of i.

Returns: Returns an internal representation of i.

Implements gum::MultiDimContainer< GUM_ELEMENT >.

Definition at line 270 of file multiDimWithOffset_tpl.h.

                                                                                    {
    if (i->isMaster(this)) {
      return std::to_string(offsets_[i]);
    } else {
      return "--";
    }
  }

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

Here is the call graph for this function:

◆ unregisterSlave()

template<typename GUM_ELEMENT>

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

overridevirtualinherited

Unregister i as a slave of this MultiDimAdressable.

Parameters

i	The Instantiation to free.

Returns: Returns true, whatever happens.

Reimplemented from gum::MultiDimImplementation< GUM_ELEMENT >.

Definition at line 203 of file multiDimWithOffset_tpl.h.

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

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

Here is the call graph for this function:

◆ unsafeGet()

template<typename GUM_SCALAR>

const GUM_SCALAR & gum::MultiDimArray< GUM_SCALAR >::unsafeGet ( Idx offset ) const

Returns the element stored in the multidimArray at a given offset.

The offset is computed as follows: let S={X1,...,Xk} be the sequence of variables in the multidim, and let x1,...,xk be their values respectively. then the corresponding offset is x1 + |X1| * x2 + [X1| * |X2| * x3 + ... This thus corresponds to the internal MultiDimArray's offset we would get by using function get with instantiation {x1,...,xk}.

Warning: for efficiency reasons, this function does not check whether the element referenced by the offset actually belongs to the MultiDimArray. If you want this additional feature, use instead MultiDimArray::getByOffset(Idx).

Parameters

offset The offset of the returned value.

Returns the element stored in the multidimArray at a given offset.

Definition at line 194 of file multiDimArray_tpl.h.

                                                                           {
    return values_[offset];
  }

References values_.

◆ unsafeSet()

template<typename GUM_ELEMENT>

void gum::MultiDimArray< GUM_SCALAR >::unsafeSet	(	Idx	offset,
		const GUM_ELEMENT &	val )

Modifies the element stored in the multidimArray at a given offset.

The offset is computed as follows: let S={X1,...,Xk} be the sequence of variables in the multidim, and let x1,...,xk be their values respectively. then the corresponding offset is x1 + |X1| * x2 + [X1| * |X2| * x3 + ... This thus corresponds to the internal MultiDimArray's offset we would get by using function get with instantiation {x1,...,xk}.

Warning: for efficiency reasons, this function does not check whether the element referenced by the offset actually belongs to the MultiDimArray. If you want this additional feature, use instead function MultiDimArray::setByOffset(Idx, const GUM_ELEMENT&).

Parameters

offset	The offset where to store the value.
val	The value to store.

Definition at line 199 of file multiDimArray_tpl.h.

                                                                               {
    values_[offset] = val;
  }

References values_.

◆ variable() [1/2]

template<typename GUM_ELEMENT>

const DiscreteVariable & gum::MultiDimImplementation< GUM_ELEMENT >::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 192 of file multiDimImplementation_tpl.h.

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

Referenced by gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::buildValue_(), gum::MultiDimWithOffset< GUM_ELEMENT >::computeInstantiationValue_(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::get(), gum::aggregator::MultiDimAggregator< GUM_ELEMENT >::toString(), gum::MultiDimICIModel< GUM_ELEMENT >::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:

◆ variable() [2/2]

template<typename GUM_ELEMENT>

const DiscreteVariable & gum::MultiDimImplementation< GUM_ELEMENT >::variable ( std::string_view 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 198 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.")
  }

References name().

Here is the call graph for this function:

◆ variablesSequence()

template<typename GUM_ELEMENT>

const Sequence< const DiscreteVariable * > & gum::MultiDimImplementation< GUM_ELEMENT >::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 220 of file multiDimImplementation_tpl.h.

                                                                     {
    return _vars_;
  }

References _vars_.

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

Here is the caller graph for this function:

◆ MultiDimBijArray

template<typename GUM_ELEMENT>

template<typename GUM_ELEMENTBIS>

template<typename GUM_ELEMENT>

HashTable< const DiscreteVariable*, Size > gum::MultiDimWithOffset< GUM_ELEMENT >::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_ELEMENT >::erase(), erase(), and getOffs_().

◆ offsets_

template<typename GUM_ELEMENT>

HashTable< const Instantiation*, Size > gum::MultiDimWithOffset< GUM_ELEMENT >::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_ELEMENT >::get(), gum::MultiDimSparse< GUM_ELEMENT >::get(), gum::MultiDimArray< GUM_ELEMENT >::get_(), registerSlave(), gum::MultiDimSparse< GUM_ELEMENT >::set(), setChangeNotification(), setDecNotification(), setFirstNotification(), setIncNotification(), setLastNotification(), toString(), and unregisterSlave().

◆ values_

template<typename GUM_ELEMENT>

std::vector< GUM_ELEMENT > gum::MultiDimArray< GUM_ELEMENT >::values_

mutableprotected

The true data : the values is mutable since we can change the value / in a const multiDimArray.

Definition at line 276 of file multiDimArray.h.

Referenced by add(), apply(), commitMultipleChanges_(), copyFrom(), data(), data(), erase(), fill(), get_(), getByOffset(), reduce(), setByOffset(), unsafeGet(), and unsafeSet().

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

agrum/base/multidim/implementations/multiDimArray.h
agrum/base/multidim/implementations/multiDimArray_tpl.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ _InternalChangeMethod_

◆ _InternalChangeState_

Constructor & Destructor Documentation

◆ MultiDimArray() [1/2]

◆ MultiDimArray() [2/2]

◆ ~MultiDimArray()

Member Function Documentation

◆ _setNotCommitedChange_()

◆ add()

◆ apply()

◆ basename()

◆ beginMultipleChanges()

◆ changeNotification()

◆ commitMultipleChanges_() [1/2]

◆ commitMultipleChanges_() [2/2]

◆ compressionRate()

◆ computeInstantiationValue_()

◆ contains()

◆ content() [1/2]

◆ content() [2/2]

◆ copy()

◆ copyFrom() [1/2]

◆ copyFrom() [2/2]

◆ data() [1/2]

◆ data() [2/2]

◆ domainSize()

◆ empty()

◆ endMultipleChanges() [1/2]

◆ endMultipleChanges() [2/2]

◆ erase()

◆ extractFrom()

◆ fill()

◆ fromOffset()

◆ get()

◆ get_()

◆ getByOffset()

◆ getMasterRef() [1/2]

◆ getMasterRef() [2/2]

◆ getOffs_()

◆ invert_()

◆ isCommitNeeded_()

◆ isInMultipleChangeMethod_()

◆ name()

◆ nbrDim()

◆ newFactory()

◆ operator==()

◆ operator[]()

◆ populate() [1/2]

◆ populate() [2/2]

◆ pos()

◆ realSize()

◆ reduce()

◆ registerSlave()

◆ replace()

◆ replace_()

◆ set()

◆ setByOffset()

◆ setChangeNotification()

◆ setDecNotification()

◆ setFirstNotification()

◆ setIncNotification()

◆ setLastNotification()

◆ slaves_()

◆ toOffset()

◆ toString() [1/2]

◆ toString() [2/2]

◆ unregisterSlave()

◆ unsafeGet()

◆ unsafeSet()

◆ variable() [1/2]

◆ variable() [2/2]